]> Git Repo - qemu.git/blob - linux-user/signal.c
linux-user: Handle images where lowest vaddr is not page aligned
[qemu.git] / linux-user / signal.c
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, see <http://www.gnu.org/licenses/>.
18  */
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <string.h>
22 #include <stdarg.h>
23 #include <unistd.h>
24 #include <errno.h>
25 #include <assert.h>
26 #include <sys/ucontext.h>
27 #include <sys/resource.h>
28
29 #include "qemu.h"
30 #include "qemu-common.h"
31 #include "target_signal.h"
32
33 //#define DEBUG_SIGNAL
34
35 static struct target_sigaltstack target_sigaltstack_used = {
36     .ss_sp = 0,
37     .ss_size = 0,
38     .ss_flags = TARGET_SS_DISABLE,
39 };
40
41 static struct target_sigaction sigact_table[TARGET_NSIG];
42
43 static void host_signal_handler(int host_signum, siginfo_t *info,
44                                 void *puc);
45
46 static uint8_t host_to_target_signal_table[_NSIG] = {
47     [SIGHUP] = TARGET_SIGHUP,
48     [SIGINT] = TARGET_SIGINT,
49     [SIGQUIT] = TARGET_SIGQUIT,
50     [SIGILL] = TARGET_SIGILL,
51     [SIGTRAP] = TARGET_SIGTRAP,
52     [SIGABRT] = TARGET_SIGABRT,
53 /*    [SIGIOT] = TARGET_SIGIOT,*/
54     [SIGBUS] = TARGET_SIGBUS,
55     [SIGFPE] = TARGET_SIGFPE,
56     [SIGKILL] = TARGET_SIGKILL,
57     [SIGUSR1] = TARGET_SIGUSR1,
58     [SIGSEGV] = TARGET_SIGSEGV,
59     [SIGUSR2] = TARGET_SIGUSR2,
60     [SIGPIPE] = TARGET_SIGPIPE,
61     [SIGALRM] = TARGET_SIGALRM,
62     [SIGTERM] = TARGET_SIGTERM,
63 #ifdef SIGSTKFLT
64     [SIGSTKFLT] = TARGET_SIGSTKFLT,
65 #endif
66     [SIGCHLD] = TARGET_SIGCHLD,
67     [SIGCONT] = TARGET_SIGCONT,
68     [SIGSTOP] = TARGET_SIGSTOP,
69     [SIGTSTP] = TARGET_SIGTSTP,
70     [SIGTTIN] = TARGET_SIGTTIN,
71     [SIGTTOU] = TARGET_SIGTTOU,
72     [SIGURG] = TARGET_SIGURG,
73     [SIGXCPU] = TARGET_SIGXCPU,
74     [SIGXFSZ] = TARGET_SIGXFSZ,
75     [SIGVTALRM] = TARGET_SIGVTALRM,
76     [SIGPROF] = TARGET_SIGPROF,
77     [SIGWINCH] = TARGET_SIGWINCH,
78     [SIGIO] = TARGET_SIGIO,
79     [SIGPWR] = TARGET_SIGPWR,
80     [SIGSYS] = TARGET_SIGSYS,
81     /* next signals stay the same */
82     /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with
83        host libpthread signals.  This assumes noone actually uses SIGRTMAX :-/
84        To fix this properly we need to do manual signal delivery multiplexed
85        over a single host signal.  */
86     [__SIGRTMIN] = __SIGRTMAX,
87     [__SIGRTMAX] = __SIGRTMIN,
88 };
89 static uint8_t target_to_host_signal_table[_NSIG];
90
91 static inline int on_sig_stack(unsigned long sp)
92 {
93     return (sp - target_sigaltstack_used.ss_sp
94             < target_sigaltstack_used.ss_size);
95 }
96
97 static inline int sas_ss_flags(unsigned long sp)
98 {
99     return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE
100             : on_sig_stack(sp) ? SS_ONSTACK : 0);
101 }
102
103 int host_to_target_signal(int sig)
104 {
105     if (sig >= _NSIG)
106         return sig;
107     return host_to_target_signal_table[sig];
108 }
109
110 int target_to_host_signal(int sig)
111 {
112     if (sig >= _NSIG)
113         return sig;
114     return target_to_host_signal_table[sig];
115 }
116
117 static inline void target_sigemptyset(target_sigset_t *set)
118 {
119     memset(set, 0, sizeof(*set));
120 }
121
122 static inline void target_sigaddset(target_sigset_t *set, int signum)
123 {
124     signum--;
125     abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
126     set->sig[signum / TARGET_NSIG_BPW] |= mask;
127 }
128
129 static inline int target_sigismember(const target_sigset_t *set, int signum)
130 {
131     signum--;
132     abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
133     return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0);
134 }
135
136 static void host_to_target_sigset_internal(target_sigset_t *d,
137                                            const sigset_t *s)
138 {
139     int i;
140     target_sigemptyset(d);
141     for (i = 1; i <= TARGET_NSIG; i++) {
142         if (sigismember(s, i)) {
143             target_sigaddset(d, host_to_target_signal(i));
144         }
145     }
146 }
147
148 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
149 {
150     target_sigset_t d1;
151     int i;
152
153     host_to_target_sigset_internal(&d1, s);
154     for(i = 0;i < TARGET_NSIG_WORDS; i++)
155         d->sig[i] = tswapl(d1.sig[i]);
156 }
157
158 static void target_to_host_sigset_internal(sigset_t *d,
159                                            const target_sigset_t *s)
160 {
161     int i;
162     sigemptyset(d);
163     for (i = 1; i <= TARGET_NSIG; i++) {
164         if (target_sigismember(s, i)) {
165             sigaddset(d, target_to_host_signal(i));
166         }
167      }
168 }
169
170 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
171 {
172     target_sigset_t s1;
173     int i;
174
175     for(i = 0;i < TARGET_NSIG_WORDS; i++)
176         s1.sig[i] = tswapl(s->sig[i]);
177     target_to_host_sigset_internal(d, &s1);
178 }
179
180 void host_to_target_old_sigset(abi_ulong *old_sigset,
181                                const sigset_t *sigset)
182 {
183     target_sigset_t d;
184     host_to_target_sigset(&d, sigset);
185     *old_sigset = d.sig[0];
186 }
187
188 void target_to_host_old_sigset(sigset_t *sigset,
189                                const abi_ulong *old_sigset)
190 {
191     target_sigset_t d;
192     int i;
193
194     d.sig[0] = *old_sigset;
195     for(i = 1;i < TARGET_NSIG_WORDS; i++)
196         d.sig[i] = 0;
197     target_to_host_sigset(sigset, &d);
198 }
199
200 /* siginfo conversion */
201
202 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
203                                                  const siginfo_t *info)
204 {
205     int sig;
206     sig = host_to_target_signal(info->si_signo);
207     tinfo->si_signo = sig;
208     tinfo->si_errno = 0;
209     tinfo->si_code = info->si_code;
210     if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
211         sig == SIGBUS || sig == SIGTRAP) {
212         /* should never come here, but who knows. The information for
213            the target is irrelevant */
214         tinfo->_sifields._sigfault._addr = 0;
215     } else if (sig == SIGIO) {
216         tinfo->_sifields._sigpoll._fd = info->si_fd;
217     } else if (sig >= TARGET_SIGRTMIN) {
218         tinfo->_sifields._rt._pid = info->si_pid;
219         tinfo->_sifields._rt._uid = info->si_uid;
220         /* XXX: potential problem if 64 bit */
221         tinfo->_sifields._rt._sigval.sival_ptr =
222             (abi_ulong)(unsigned long)info->si_value.sival_ptr;
223     }
224 }
225
226 static void tswap_siginfo(target_siginfo_t *tinfo,
227                           const target_siginfo_t *info)
228 {
229     int sig;
230     sig = info->si_signo;
231     tinfo->si_signo = tswap32(sig);
232     tinfo->si_errno = tswap32(info->si_errno);
233     tinfo->si_code = tswap32(info->si_code);
234     if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
235         sig == SIGBUS || sig == SIGTRAP) {
236         tinfo->_sifields._sigfault._addr =
237             tswapl(info->_sifields._sigfault._addr);
238     } else if (sig == SIGIO) {
239         tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd);
240     } else if (sig >= TARGET_SIGRTMIN) {
241         tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
242         tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
243         tinfo->_sifields._rt._sigval.sival_ptr =
244             tswapl(info->_sifields._rt._sigval.sival_ptr);
245     }
246 }
247
248
249 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
250 {
251     host_to_target_siginfo_noswap(tinfo, info);
252     tswap_siginfo(tinfo, tinfo);
253 }
254
255 /* XXX: we support only POSIX RT signals are used. */
256 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
257 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
258 {
259     info->si_signo = tswap32(tinfo->si_signo);
260     info->si_errno = tswap32(tinfo->si_errno);
261     info->si_code = tswap32(tinfo->si_code);
262     info->si_pid = tswap32(tinfo->_sifields._rt._pid);
263     info->si_uid = tswap32(tinfo->_sifields._rt._uid);
264     info->si_value.sival_ptr =
265             (void *)(long)tswapl(tinfo->_sifields._rt._sigval.sival_ptr);
266 }
267
268 static int fatal_signal (int sig)
269 {
270     switch (sig) {
271     case TARGET_SIGCHLD:
272     case TARGET_SIGURG:
273     case TARGET_SIGWINCH:
274         /* Ignored by default.  */
275         return 0;
276     case TARGET_SIGCONT:
277     case TARGET_SIGSTOP:
278     case TARGET_SIGTSTP:
279     case TARGET_SIGTTIN:
280     case TARGET_SIGTTOU:
281         /* Job control signals.  */
282         return 0;
283     default:
284         return 1;
285     }
286 }
287
288 /* returns 1 if given signal should dump core if not handled */
289 static int core_dump_signal(int sig)
290 {
291     switch (sig) {
292     case TARGET_SIGABRT:
293     case TARGET_SIGFPE:
294     case TARGET_SIGILL:
295     case TARGET_SIGQUIT:
296     case TARGET_SIGSEGV:
297     case TARGET_SIGTRAP:
298     case TARGET_SIGBUS:
299         return (1);
300     default:
301         return (0);
302     }
303 }
304
305 void signal_init(void)
306 {
307     struct sigaction act;
308     struct sigaction oact;
309     int i, j;
310     int host_sig;
311
312     /* generate signal conversion tables */
313     for(i = 1; i < _NSIG; i++) {
314         if (host_to_target_signal_table[i] == 0)
315             host_to_target_signal_table[i] = i;
316     }
317     for(i = 1; i < _NSIG; i++) {
318         j = host_to_target_signal_table[i];
319         target_to_host_signal_table[j] = i;
320     }
321
322     /* set all host signal handlers. ALL signals are blocked during
323        the handlers to serialize them. */
324     memset(sigact_table, 0, sizeof(sigact_table));
325
326     sigfillset(&act.sa_mask);
327     act.sa_flags = SA_SIGINFO;
328     act.sa_sigaction = host_signal_handler;
329     for(i = 1; i <= TARGET_NSIG; i++) {
330         host_sig = target_to_host_signal(i);
331         sigaction(host_sig, NULL, &oact);
332         if (oact.sa_sigaction == (void *)SIG_IGN) {
333             sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;
334         } else if (oact.sa_sigaction == (void *)SIG_DFL) {
335             sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;
336         }
337         /* If there's already a handler installed then something has
338            gone horribly wrong, so don't even try to handle that case.  */
339         /* Install some handlers for our own use.  We need at least
340            SIGSEGV and SIGBUS, to detect exceptions.  We can not just
341            trap all signals because it affects syscall interrupt
342            behavior.  But do trap all default-fatal signals.  */
343         if (fatal_signal (i))
344             sigaction(host_sig, &act, NULL);
345     }
346 }
347
348 /* signal queue handling */
349
350 static inline struct sigqueue *alloc_sigqueue(CPUState *env)
351 {
352     TaskState *ts = env->opaque;
353     struct sigqueue *q = ts->first_free;
354     if (!q)
355         return NULL;
356     ts->first_free = q->next;
357     return q;
358 }
359
360 static inline void free_sigqueue(CPUState *env, struct sigqueue *q)
361 {
362     TaskState *ts = env->opaque;
363     q->next = ts->first_free;
364     ts->first_free = q;
365 }
366
367 /* abort execution with signal */
368 static void QEMU_NORETURN force_sig(int target_sig)
369 {
370     TaskState *ts = (TaskState *)thread_env->opaque;
371     int host_sig, core_dumped = 0;
372     struct sigaction act;
373     host_sig = target_to_host_signal(target_sig);
374     gdb_signalled(thread_env, target_sig);
375
376     /* dump core if supported by target binary format */
377     if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) {
378         stop_all_tasks();
379         core_dumped =
380             ((*ts->bprm->core_dump)(target_sig, thread_env) == 0);
381     }
382     if (core_dumped) {
383         /* we already dumped the core of target process, we don't want
384          * a coredump of qemu itself */
385         struct rlimit nodump;
386         getrlimit(RLIMIT_CORE, &nodump);
387         nodump.rlim_cur=0;
388         setrlimit(RLIMIT_CORE, &nodump);
389         (void) fprintf(stderr, "qemu: uncaught target signal %d (%s) - %s\n",
390             target_sig, strsignal(host_sig), "core dumped" );
391     }
392
393     /* The proper exit code for dying from an uncaught signal is
394      * -<signal>.  The kernel doesn't allow exit() or _exit() to pass
395      * a negative value.  To get the proper exit code we need to
396      * actually die from an uncaught signal.  Here the default signal
397      * handler is installed, we send ourself a signal and we wait for
398      * it to arrive. */
399     sigfillset(&act.sa_mask);
400     act.sa_handler = SIG_DFL;
401     sigaction(host_sig, &act, NULL);
402
403     /* For some reason raise(host_sig) doesn't send the signal when
404      * statically linked on x86-64. */
405     kill(getpid(), host_sig);
406
407     /* Make sure the signal isn't masked (just reuse the mask inside
408     of act) */
409     sigdelset(&act.sa_mask, host_sig);
410     sigsuspend(&act.sa_mask);
411
412     /* unreachable */
413     abort();
414 }
415
416 /* queue a signal so that it will be send to the virtual CPU as soon
417    as possible */
418 int queue_signal(CPUState *env, int sig, target_siginfo_t *info)
419 {
420     TaskState *ts = env->opaque;
421     struct emulated_sigtable *k;
422     struct sigqueue *q, **pq;
423     abi_ulong handler;
424     int queue;
425
426 #if defined(DEBUG_SIGNAL)
427     fprintf(stderr, "queue_signal: sig=%d\n",
428             sig);
429 #endif
430     k = &ts->sigtab[sig - 1];
431     queue = gdb_queuesig ();
432     handler = sigact_table[sig - 1]._sa_handler;
433     if (!queue && handler == TARGET_SIG_DFL) {
434         if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
435             kill(getpid(),SIGSTOP);
436             return 0;
437         } else
438         /* default handler : ignore some signal. The other are fatal */
439         if (sig != TARGET_SIGCHLD &&
440             sig != TARGET_SIGURG &&
441             sig != TARGET_SIGWINCH &&
442             sig != TARGET_SIGCONT) {
443             force_sig(sig);
444         } else {
445             return 0; /* indicate ignored */
446         }
447     } else if (!queue && handler == TARGET_SIG_IGN) {
448         /* ignore signal */
449         return 0;
450     } else if (!queue && handler == TARGET_SIG_ERR) {
451         force_sig(sig);
452     } else {
453         pq = &k->first;
454         if (sig < TARGET_SIGRTMIN) {
455             /* if non real time signal, we queue exactly one signal */
456             if (!k->pending)
457                 q = &k->info;
458             else
459                 return 0;
460         } else {
461             if (!k->pending) {
462                 /* first signal */
463                 q = &k->info;
464             } else {
465                 q = alloc_sigqueue(env);
466                 if (!q)
467                     return -EAGAIN;
468                 while (*pq != NULL)
469                     pq = &(*pq)->next;
470             }
471         }
472         *pq = q;
473         q->info = *info;
474         q->next = NULL;
475         k->pending = 1;
476         /* signal that a new signal is pending */
477         ts->signal_pending = 1;
478         return 1; /* indicates that the signal was queued */
479     }
480 }
481
482 static void host_signal_handler(int host_signum, siginfo_t *info,
483                                 void *puc)
484 {
485     int sig;
486     target_siginfo_t tinfo;
487
488     /* the CPU emulator uses some host signals to detect exceptions,
489        we forward to it some signals */
490     if ((host_signum == SIGSEGV || host_signum == SIGBUS)
491         && info->si_code > 0) {
492         if (cpu_signal_handler(host_signum, info, puc))
493             return;
494     }
495
496     /* get target signal number */
497     sig = host_to_target_signal(host_signum);
498     if (sig < 1 || sig > TARGET_NSIG)
499         return;
500 #if defined(DEBUG_SIGNAL)
501     fprintf(stderr, "qemu: got signal %d\n", sig);
502 #endif
503     host_to_target_siginfo_noswap(&tinfo, info);
504     if (queue_signal(thread_env, sig, &tinfo) == 1) {
505         /* interrupt the virtual CPU as soon as possible */
506         cpu_exit(thread_env);
507     }
508 }
509
510 /* do_sigaltstack() returns target values and errnos. */
511 /* compare linux/kernel/signal.c:do_sigaltstack() */
512 abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp)
513 {
514     int ret;
515     struct target_sigaltstack oss;
516
517     /* XXX: test errors */
518     if(uoss_addr)
519     {
520         __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp);
521         __put_user(target_sigaltstack_used.ss_size, &oss.ss_size);
522         __put_user(sas_ss_flags(sp), &oss.ss_flags);
523     }
524
525     if(uss_addr)
526     {
527         struct target_sigaltstack *uss;
528         struct target_sigaltstack ss;
529
530         ret = -TARGET_EFAULT;
531         if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)
532             || __get_user(ss.ss_sp, &uss->ss_sp)
533             || __get_user(ss.ss_size, &uss->ss_size)
534             || __get_user(ss.ss_flags, &uss->ss_flags))
535             goto out;
536         unlock_user_struct(uss, uss_addr, 0);
537
538         ret = -TARGET_EPERM;
539         if (on_sig_stack(sp))
540             goto out;
541
542         ret = -TARGET_EINVAL;
543         if (ss.ss_flags != TARGET_SS_DISABLE
544             && ss.ss_flags != TARGET_SS_ONSTACK
545             && ss.ss_flags != 0)
546             goto out;
547
548         if (ss.ss_flags == TARGET_SS_DISABLE) {
549             ss.ss_size = 0;
550             ss.ss_sp = 0;
551         } else {
552             ret = -TARGET_ENOMEM;
553             if (ss.ss_size < MINSIGSTKSZ)
554                 goto out;
555         }
556
557         target_sigaltstack_used.ss_sp = ss.ss_sp;
558         target_sigaltstack_used.ss_size = ss.ss_size;
559     }
560
561     if (uoss_addr) {
562         ret = -TARGET_EFAULT;
563         if (copy_to_user(uoss_addr, &oss, sizeof(oss)))
564             goto out;
565     }
566
567     ret = 0;
568 out:
569     return ret;
570 }
571
572 /* do_sigaction() return host values and errnos */
573 int do_sigaction(int sig, const struct target_sigaction *act,
574                  struct target_sigaction *oact)
575 {
576     struct target_sigaction *k;
577     struct sigaction act1;
578     int host_sig;
579     int ret = 0;
580
581     if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP)
582         return -EINVAL;
583     k = &sigact_table[sig - 1];
584 #if defined(DEBUG_SIGNAL)
585     fprintf(stderr, "sigaction sig=%d act=0x%p, oact=0x%p\n",
586             sig, act, oact);
587 #endif
588     if (oact) {
589         oact->_sa_handler = tswapl(k->_sa_handler);
590         oact->sa_flags = tswapl(k->sa_flags);
591 #if !defined(TARGET_MIPS)
592         oact->sa_restorer = tswapl(k->sa_restorer);
593 #endif
594         oact->sa_mask = k->sa_mask;
595     }
596     if (act) {
597         /* FIXME: This is not threadsafe.  */
598         k->_sa_handler = tswapl(act->_sa_handler);
599         k->sa_flags = tswapl(act->sa_flags);
600 #if !defined(TARGET_MIPS)
601         k->sa_restorer = tswapl(act->sa_restorer);
602 #endif
603         k->sa_mask = act->sa_mask;
604
605         /* we update the host linux signal state */
606         host_sig = target_to_host_signal(sig);
607         if (host_sig != SIGSEGV && host_sig != SIGBUS) {
608             sigfillset(&act1.sa_mask);
609             act1.sa_flags = SA_SIGINFO;
610             if (k->sa_flags & TARGET_SA_RESTART)
611                 act1.sa_flags |= SA_RESTART;
612             /* NOTE: it is important to update the host kernel signal
613                ignore state to avoid getting unexpected interrupted
614                syscalls */
615             if (k->_sa_handler == TARGET_SIG_IGN) {
616                 act1.sa_sigaction = (void *)SIG_IGN;
617             } else if (k->_sa_handler == TARGET_SIG_DFL) {
618                 if (fatal_signal (sig))
619                     act1.sa_sigaction = host_signal_handler;
620                 else
621                     act1.sa_sigaction = (void *)SIG_DFL;
622             } else {
623                 act1.sa_sigaction = host_signal_handler;
624             }
625             ret = sigaction(host_sig, &act1, NULL);
626         }
627     }
628     return ret;
629 }
630
631 static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,
632                                        const target_siginfo_t *info)
633 {
634     tswap_siginfo(tinfo, info);
635     return 0;
636 }
637
638 static inline int current_exec_domain_sig(int sig)
639 {
640     return /* current->exec_domain && current->exec_domain->signal_invmap
641               && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig;
642 }
643
644 #if defined(TARGET_I386) && TARGET_ABI_BITS == 32
645
646 /* from the Linux kernel */
647
648 struct target_fpreg {
649         uint16_t significand[4];
650         uint16_t exponent;
651 };
652
653 struct target_fpxreg {
654         uint16_t significand[4];
655         uint16_t exponent;
656         uint16_t padding[3];
657 };
658
659 struct target_xmmreg {
660         abi_ulong element[4];
661 };
662
663 struct target_fpstate {
664         /* Regular FPU environment */
665         abi_ulong       cw;
666         abi_ulong       sw;
667         abi_ulong       tag;
668         abi_ulong       ipoff;
669         abi_ulong       cssel;
670         abi_ulong       dataoff;
671         abi_ulong       datasel;
672         struct target_fpreg     _st[8];
673         uint16_t        status;
674         uint16_t        magic;          /* 0xffff = regular FPU data only */
675
676         /* FXSR FPU environment */
677         abi_ulong       _fxsr_env[6];   /* FXSR FPU env is ignored */
678         abi_ulong       mxcsr;
679         abi_ulong       reserved;
680         struct target_fpxreg    _fxsr_st[8];    /* FXSR FPU reg data is ignored */
681         struct target_xmmreg    _xmm[8];
682         abi_ulong       padding[56];
683 };
684
685 #define X86_FXSR_MAGIC          0x0000
686
687 struct target_sigcontext {
688         uint16_t gs, __gsh;
689         uint16_t fs, __fsh;
690         uint16_t es, __esh;
691         uint16_t ds, __dsh;
692         abi_ulong edi;
693         abi_ulong esi;
694         abi_ulong ebp;
695         abi_ulong esp;
696         abi_ulong ebx;
697         abi_ulong edx;
698         abi_ulong ecx;
699         abi_ulong eax;
700         abi_ulong trapno;
701         abi_ulong err;
702         abi_ulong eip;
703         uint16_t cs, __csh;
704         abi_ulong eflags;
705         abi_ulong esp_at_signal;
706         uint16_t ss, __ssh;
707         abi_ulong fpstate; /* pointer */
708         abi_ulong oldmask;
709         abi_ulong cr2;
710 };
711
712 struct target_ucontext {
713         abi_ulong         tuc_flags;
714         abi_ulong         tuc_link;
715         target_stack_t    tuc_stack;
716         struct target_sigcontext tuc_mcontext;
717         target_sigset_t   tuc_sigmask;  /* mask last for extensibility */
718 };
719
720 struct sigframe
721 {
722     abi_ulong pretcode;
723     int sig;
724     struct target_sigcontext sc;
725     struct target_fpstate fpstate;
726     abi_ulong extramask[TARGET_NSIG_WORDS-1];
727     char retcode[8];
728 };
729
730 struct rt_sigframe
731 {
732     abi_ulong pretcode;
733     int sig;
734     abi_ulong pinfo;
735     abi_ulong puc;
736     struct target_siginfo info;
737     struct target_ucontext uc;
738     struct target_fpstate fpstate;
739     char retcode[8];
740 };
741
742 /*
743  * Set up a signal frame.
744  */
745
746 /* XXX: save x87 state */
747 static int
748 setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
749                  CPUX86State *env, abi_ulong mask, abi_ulong fpstate_addr)
750 {
751         int err = 0;
752         uint16_t magic;
753
754         /* already locked in setup_frame() */
755         err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
756         err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
757         err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
758         err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
759         err |= __put_user(env->regs[R_EDI], &sc->edi);
760         err |= __put_user(env->regs[R_ESI], &sc->esi);
761         err |= __put_user(env->regs[R_EBP], &sc->ebp);
762         err |= __put_user(env->regs[R_ESP], &sc->esp);
763         err |= __put_user(env->regs[R_EBX], &sc->ebx);
764         err |= __put_user(env->regs[R_EDX], &sc->edx);
765         err |= __put_user(env->regs[R_ECX], &sc->ecx);
766         err |= __put_user(env->regs[R_EAX], &sc->eax);
767         err |= __put_user(env->exception_index, &sc->trapno);
768         err |= __put_user(env->error_code, &sc->err);
769         err |= __put_user(env->eip, &sc->eip);
770         err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
771         err |= __put_user(env->eflags, &sc->eflags);
772         err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);
773         err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
774
775         cpu_x86_fsave(env, fpstate_addr, 1);
776         fpstate->status = fpstate->sw;
777         magic = 0xffff;
778         err |= __put_user(magic, &fpstate->magic);
779         err |= __put_user(fpstate_addr, &sc->fpstate);
780
781         /* non-iBCS2 extensions.. */
782         err |= __put_user(mask, &sc->oldmask);
783         err |= __put_user(env->cr[2], &sc->cr2);
784         return err;
785 }
786
787 /*
788  * Determine which stack to use..
789  */
790
791 static inline abi_ulong
792 get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size)
793 {
794         unsigned long esp;
795
796         /* Default to using normal stack */
797         esp = env->regs[R_ESP];
798         /* This is the X/Open sanctioned signal stack switching.  */
799         if (ka->sa_flags & TARGET_SA_ONSTACK) {
800             if (sas_ss_flags(esp) == 0)
801                 esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
802         }
803
804         /* This is the legacy signal stack switching. */
805         else
806         if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
807             !(ka->sa_flags & TARGET_SA_RESTORER) &&
808             ka->sa_restorer) {
809             esp = (unsigned long) ka->sa_restorer;
810         }
811         return (esp - frame_size) & -8ul;
812 }
813
814 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */
815 static void setup_frame(int sig, struct target_sigaction *ka,
816                         target_sigset_t *set, CPUX86State *env)
817 {
818         abi_ulong frame_addr;
819         struct sigframe *frame;
820         int i, err = 0;
821
822         frame_addr = get_sigframe(ka, env, sizeof(*frame));
823
824         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
825                 goto give_sigsegv;
826
827         err |= __put_user(current_exec_domain_sig(sig),
828                           &frame->sig);
829         if (err)
830                 goto give_sigsegv;
831
832         setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0],
833                          frame_addr + offsetof(struct sigframe, fpstate));
834         if (err)
835                 goto give_sigsegv;
836
837         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
838             if (__put_user(set->sig[i], &frame->extramask[i - 1]))
839                 goto give_sigsegv;
840         }
841
842         /* Set up to return from userspace.  If provided, use a stub
843            already in userspace.  */
844         if (ka->sa_flags & TARGET_SA_RESTORER) {
845                 err |= __put_user(ka->sa_restorer, &frame->pretcode);
846         } else {
847                 uint16_t val16;
848                 abi_ulong retcode_addr;
849                 retcode_addr = frame_addr + offsetof(struct sigframe, retcode);
850                 err |= __put_user(retcode_addr, &frame->pretcode);
851                 /* This is popl %eax ; movl $,%eax ; int $0x80 */
852                 val16 = 0xb858;
853                 err |= __put_user(val16, (uint16_t *)(frame->retcode+0));
854                 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
855                 val16 = 0x80cd;
856                 err |= __put_user(val16, (uint16_t *)(frame->retcode+6));
857         }
858
859         if (err)
860                 goto give_sigsegv;
861
862         /* Set up registers for signal handler */
863         env->regs[R_ESP] = frame_addr;
864         env->eip = ka->_sa_handler;
865
866         cpu_x86_load_seg(env, R_DS, __USER_DS);
867         cpu_x86_load_seg(env, R_ES, __USER_DS);
868         cpu_x86_load_seg(env, R_SS, __USER_DS);
869         cpu_x86_load_seg(env, R_CS, __USER_CS);
870         env->eflags &= ~TF_MASK;
871
872         unlock_user_struct(frame, frame_addr, 1);
873
874         return;
875
876 give_sigsegv:
877         unlock_user_struct(frame, frame_addr, 1);
878         if (sig == TARGET_SIGSEGV)
879                 ka->_sa_handler = TARGET_SIG_DFL;
880         force_sig(TARGET_SIGSEGV /* , current */);
881 }
882
883 /* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */
884 static void setup_rt_frame(int sig, struct target_sigaction *ka,
885                            target_siginfo_t *info,
886                            target_sigset_t *set, CPUX86State *env)
887 {
888         abi_ulong frame_addr, addr;
889         struct rt_sigframe *frame;
890         int i, err = 0;
891
892         frame_addr = get_sigframe(ka, env, sizeof(*frame));
893
894         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
895                 goto give_sigsegv;
896
897         err |= __put_user(current_exec_domain_sig(sig),
898                           &frame->sig);
899         addr = frame_addr + offsetof(struct rt_sigframe, info);
900         err |= __put_user(addr, &frame->pinfo);
901         addr = frame_addr + offsetof(struct rt_sigframe, uc);
902         err |= __put_user(addr, &frame->puc);
903         err |= copy_siginfo_to_user(&frame->info, info);
904         if (err)
905                 goto give_sigsegv;
906
907         /* Create the ucontext.  */
908         err |= __put_user(0, &frame->uc.tuc_flags);
909         err |= __put_user(0, &frame->uc.tuc_link);
910         err |= __put_user(target_sigaltstack_used.ss_sp,
911                           &frame->uc.tuc_stack.ss_sp);
912         err |= __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
913                           &frame->uc.tuc_stack.ss_flags);
914         err |= __put_user(target_sigaltstack_used.ss_size,
915                           &frame->uc.tuc_stack.ss_size);
916         err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate,
917                                 env, set->sig[0], 
918                                 frame_addr + offsetof(struct rt_sigframe, fpstate));
919         for(i = 0; i < TARGET_NSIG_WORDS; i++) {
920             if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
921                 goto give_sigsegv;
922         }
923
924         /* Set up to return from userspace.  If provided, use a stub
925            already in userspace.  */
926         if (ka->sa_flags & TARGET_SA_RESTORER) {
927                 err |= __put_user(ka->sa_restorer, &frame->pretcode);
928         } else {
929                 uint16_t val16;
930                 addr = frame_addr + offsetof(struct rt_sigframe, retcode);
931                 err |= __put_user(addr, &frame->pretcode);
932                 /* This is movl $,%eax ; int $0x80 */
933                 err |= __put_user(0xb8, (char *)(frame->retcode+0));
934                 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
935                 val16 = 0x80cd;
936                 err |= __put_user(val16, (uint16_t *)(frame->retcode+5));
937         }
938
939         if (err)
940                 goto give_sigsegv;
941
942         /* Set up registers for signal handler */
943         env->regs[R_ESP] = frame_addr;
944         env->eip = ka->_sa_handler;
945
946         cpu_x86_load_seg(env, R_DS, __USER_DS);
947         cpu_x86_load_seg(env, R_ES, __USER_DS);
948         cpu_x86_load_seg(env, R_SS, __USER_DS);
949         cpu_x86_load_seg(env, R_CS, __USER_CS);
950         env->eflags &= ~TF_MASK;
951
952         unlock_user_struct(frame, frame_addr, 1);
953
954         return;
955
956 give_sigsegv:
957         unlock_user_struct(frame, frame_addr, 1);
958         if (sig == TARGET_SIGSEGV)
959                 ka->_sa_handler = TARGET_SIG_DFL;
960         force_sig(TARGET_SIGSEGV /* , current */);
961 }
962
963 static int
964 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
965 {
966         unsigned int err = 0;
967         abi_ulong fpstate_addr;
968         unsigned int tmpflags;
969
970         cpu_x86_load_seg(env, R_GS, tswap16(sc->gs));
971         cpu_x86_load_seg(env, R_FS, tswap16(sc->fs));
972         cpu_x86_load_seg(env, R_ES, tswap16(sc->es));
973         cpu_x86_load_seg(env, R_DS, tswap16(sc->ds));
974
975         env->regs[R_EDI] = tswapl(sc->edi);
976         env->regs[R_ESI] = tswapl(sc->esi);
977         env->regs[R_EBP] = tswapl(sc->ebp);
978         env->regs[R_ESP] = tswapl(sc->esp);
979         env->regs[R_EBX] = tswapl(sc->ebx);
980         env->regs[R_EDX] = tswapl(sc->edx);
981         env->regs[R_ECX] = tswapl(sc->ecx);
982         env->eip = tswapl(sc->eip);
983
984         cpu_x86_load_seg(env, R_CS, lduw_p(&sc->cs) | 3);
985         cpu_x86_load_seg(env, R_SS, lduw_p(&sc->ss) | 3);
986
987         tmpflags = tswapl(sc->eflags);
988         env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
989         //              regs->orig_eax = -1;            /* disable syscall checks */
990
991         fpstate_addr = tswapl(sc->fpstate);
992         if (fpstate_addr != 0) {
993                 if (!access_ok(VERIFY_READ, fpstate_addr, 
994                                sizeof(struct target_fpstate)))
995                         goto badframe;
996                 cpu_x86_frstor(env, fpstate_addr, 1);
997         }
998
999         *peax = tswapl(sc->eax);
1000         return err;
1001 badframe:
1002         return 1;
1003 }
1004
1005 long do_sigreturn(CPUX86State *env)
1006 {
1007     struct sigframe *frame;
1008     abi_ulong frame_addr = env->regs[R_ESP] - 8;
1009     target_sigset_t target_set;
1010     sigset_t set;
1011     int eax, i;
1012
1013 #if defined(DEBUG_SIGNAL)
1014     fprintf(stderr, "do_sigreturn\n");
1015 #endif
1016     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1017         goto badframe;
1018     /* set blocked signals */
1019     if (__get_user(target_set.sig[0], &frame->sc.oldmask))
1020         goto badframe;
1021     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1022         if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
1023             goto badframe;
1024     }
1025
1026     target_to_host_sigset_internal(&set, &target_set);
1027     sigprocmask(SIG_SETMASK, &set, NULL);
1028
1029     /* restore registers */
1030     if (restore_sigcontext(env, &frame->sc, &eax))
1031         goto badframe;
1032     unlock_user_struct(frame, frame_addr, 0);
1033     return eax;
1034
1035 badframe:
1036     unlock_user_struct(frame, frame_addr, 0);
1037     force_sig(TARGET_SIGSEGV);
1038     return 0;
1039 }
1040
1041 long do_rt_sigreturn(CPUX86State *env)
1042 {
1043         abi_ulong frame_addr;
1044         struct rt_sigframe *frame;
1045         sigset_t set;
1046         int eax;
1047
1048         frame_addr = env->regs[R_ESP] - 4;
1049         if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1050                 goto badframe;
1051         target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
1052         sigprocmask(SIG_SETMASK, &set, NULL);
1053
1054         if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))
1055                 goto badframe;
1056
1057         if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0, 
1058                            get_sp_from_cpustate(env)) == -EFAULT)
1059                 goto badframe;
1060
1061         unlock_user_struct(frame, frame_addr, 0);
1062         return eax;
1063
1064 badframe:
1065         unlock_user_struct(frame, frame_addr, 0);
1066         force_sig(TARGET_SIGSEGV);
1067         return 0;
1068 }
1069
1070 #elif defined(TARGET_ARM)
1071
1072 struct target_sigcontext {
1073         abi_ulong trap_no;
1074         abi_ulong error_code;
1075         abi_ulong oldmask;
1076         abi_ulong arm_r0;
1077         abi_ulong arm_r1;
1078         abi_ulong arm_r2;
1079         abi_ulong arm_r3;
1080         abi_ulong arm_r4;
1081         abi_ulong arm_r5;
1082         abi_ulong arm_r6;
1083         abi_ulong arm_r7;
1084         abi_ulong arm_r8;
1085         abi_ulong arm_r9;
1086         abi_ulong arm_r10;
1087         abi_ulong arm_fp;
1088         abi_ulong arm_ip;
1089         abi_ulong arm_sp;
1090         abi_ulong arm_lr;
1091         abi_ulong arm_pc;
1092         abi_ulong arm_cpsr;
1093         abi_ulong fault_address;
1094 };
1095
1096 struct target_ucontext_v1 {
1097     abi_ulong tuc_flags;
1098     abi_ulong tuc_link;
1099     target_stack_t tuc_stack;
1100     struct target_sigcontext tuc_mcontext;
1101     target_sigset_t  tuc_sigmask;       /* mask last for extensibility */
1102 };
1103
1104 struct target_ucontext_v2 {
1105     abi_ulong tuc_flags;
1106     abi_ulong tuc_link;
1107     target_stack_t tuc_stack;
1108     struct target_sigcontext tuc_mcontext;
1109     target_sigset_t  tuc_sigmask;       /* mask last for extensibility */
1110     char __unused[128 - sizeof(target_sigset_t)];
1111     abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
1112 };
1113
1114 struct target_user_vfp {
1115     uint64_t fpregs[32];
1116     abi_ulong fpscr;
1117 };
1118
1119 struct target_user_vfp_exc {
1120     abi_ulong fpexc;
1121     abi_ulong fpinst;
1122     abi_ulong fpinst2;
1123 };
1124
1125 struct target_vfp_sigframe {
1126     abi_ulong magic;
1127     abi_ulong size;
1128     struct target_user_vfp ufp;
1129     struct target_user_vfp_exc ufp_exc;
1130 } __attribute__((__aligned__(8)));
1131
1132 struct target_iwmmxt_sigframe {
1133     abi_ulong magic;
1134     abi_ulong size;
1135     uint64_t regs[16];
1136     /* Note that not all the coprocessor control registers are stored here */
1137     uint32_t wcssf;
1138     uint32_t wcasf;
1139     uint32_t wcgr0;
1140     uint32_t wcgr1;
1141     uint32_t wcgr2;
1142     uint32_t wcgr3;
1143 } __attribute__((__aligned__(8)));
1144
1145 #define TARGET_VFP_MAGIC 0x56465001
1146 #define TARGET_IWMMXT_MAGIC 0x12ef842a
1147
1148 struct sigframe_v1
1149 {
1150     struct target_sigcontext sc;
1151     abi_ulong extramask[TARGET_NSIG_WORDS-1];
1152     abi_ulong retcode;
1153 };
1154
1155 struct sigframe_v2
1156 {
1157     struct target_ucontext_v2 uc;
1158     abi_ulong retcode;
1159 };
1160
1161 struct rt_sigframe_v1
1162 {
1163     abi_ulong pinfo;
1164     abi_ulong puc;
1165     struct target_siginfo info;
1166     struct target_ucontext_v1 uc;
1167     abi_ulong retcode;
1168 };
1169
1170 struct rt_sigframe_v2
1171 {
1172     struct target_siginfo info;
1173     struct target_ucontext_v2 uc;
1174     abi_ulong retcode;
1175 };
1176
1177 #define TARGET_CONFIG_CPU_32 1
1178
1179 /*
1180  * For ARM syscalls, we encode the syscall number into the instruction.
1181  */
1182 #define SWI_SYS_SIGRETURN       (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1183 #define SWI_SYS_RT_SIGRETURN    (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1184
1185 /*
1186  * For Thumb syscalls, we pass the syscall number via r7.  We therefore
1187  * need two 16-bit instructions.
1188  */
1189 #define SWI_THUMB_SIGRETURN     (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1190 #define SWI_THUMB_RT_SIGRETURN  (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1191
1192 static const abi_ulong retcodes[4] = {
1193         SWI_SYS_SIGRETURN,      SWI_THUMB_SIGRETURN,
1194         SWI_SYS_RT_SIGRETURN,   SWI_THUMB_RT_SIGRETURN
1195 };
1196
1197
1198 #define __get_user_error(x,p,e) __get_user(x, p)
1199
1200 static inline int valid_user_regs(CPUState *regs)
1201 {
1202     return 1;
1203 }
1204
1205 static void
1206 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1207                  CPUState *env, abi_ulong mask)
1208 {
1209         __put_user(env->regs[0], &sc->arm_r0);
1210         __put_user(env->regs[1], &sc->arm_r1);
1211         __put_user(env->regs[2], &sc->arm_r2);
1212         __put_user(env->regs[3], &sc->arm_r3);
1213         __put_user(env->regs[4], &sc->arm_r4);
1214         __put_user(env->regs[5], &sc->arm_r5);
1215         __put_user(env->regs[6], &sc->arm_r6);
1216         __put_user(env->regs[7], &sc->arm_r7);
1217         __put_user(env->regs[8], &sc->arm_r8);
1218         __put_user(env->regs[9], &sc->arm_r9);
1219         __put_user(env->regs[10], &sc->arm_r10);
1220         __put_user(env->regs[11], &sc->arm_fp);
1221         __put_user(env->regs[12], &sc->arm_ip);
1222         __put_user(env->regs[13], &sc->arm_sp);
1223         __put_user(env->regs[14], &sc->arm_lr);
1224         __put_user(env->regs[15], &sc->arm_pc);
1225 #ifdef TARGET_CONFIG_CPU_32
1226         __put_user(cpsr_read(env), &sc->arm_cpsr);
1227 #endif
1228
1229         __put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
1230         __put_user(/* current->thread.error_code */ 0, &sc->error_code);
1231         __put_user(/* current->thread.address */ 0, &sc->fault_address);
1232         __put_user(mask, &sc->oldmask);
1233 }
1234
1235 static inline abi_ulong
1236 get_sigframe(struct target_sigaction *ka, CPUState *regs, int framesize)
1237 {
1238         unsigned long sp = regs->regs[13];
1239
1240         /*
1241          * This is the X/Open sanctioned signal stack switching.
1242          */
1243         if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp))
1244             sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1245         /*
1246          * ATPCS B01 mandates 8-byte alignment
1247          */
1248         return (sp - framesize) & ~7;
1249 }
1250
1251 static int
1252 setup_return(CPUState *env, struct target_sigaction *ka,
1253              abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr)
1254 {
1255         abi_ulong handler = ka->_sa_handler;
1256         abi_ulong retcode;
1257         int thumb = handler & 1;
1258         uint32_t cpsr = cpsr_read(env);
1259
1260         cpsr &= ~CPSR_IT;
1261         if (thumb) {
1262                 cpsr |= CPSR_T;
1263         } else {
1264                 cpsr &= ~CPSR_T;
1265         }
1266
1267         if (ka->sa_flags & TARGET_SA_RESTORER) {
1268                 retcode = ka->sa_restorer;
1269         } else {
1270                 unsigned int idx = thumb;
1271
1272                 if (ka->sa_flags & TARGET_SA_SIGINFO)
1273                         idx += 2;
1274
1275                 if (__put_user(retcodes[idx], rc))
1276                         return 1;
1277 #if 0
1278                 flush_icache_range((abi_ulong)rc,
1279                                    (abi_ulong)(rc + 1));
1280 #endif
1281                 retcode = rc_addr + thumb;
1282         }
1283
1284         env->regs[0] = usig;
1285         env->regs[13] = frame_addr;
1286         env->regs[14] = retcode;
1287         env->regs[15] = handler & (thumb ? ~1 : ~3);
1288         cpsr_write(env, cpsr, 0xffffffff);
1289
1290         return 0;
1291 }
1292
1293 static abi_ulong *setup_sigframe_v2_vfp(abi_ulong *regspace, CPUState *env)
1294 {
1295     int i;
1296     struct target_vfp_sigframe *vfpframe;
1297     vfpframe = (struct target_vfp_sigframe *)regspace;
1298     __put_user(TARGET_VFP_MAGIC, &vfpframe->magic);
1299     __put_user(sizeof(*vfpframe), &vfpframe->size);
1300     for (i = 0; i < 32; i++) {
1301         __put_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
1302     }
1303     __put_user(vfp_get_fpscr(env), &vfpframe->ufp.fpscr);
1304     __put_user(env->vfp.xregs[ARM_VFP_FPEXC], &vfpframe->ufp_exc.fpexc);
1305     __put_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1306     __put_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1307     return (abi_ulong*)(vfpframe+1);
1308 }
1309
1310 static abi_ulong *setup_sigframe_v2_iwmmxt(abi_ulong *regspace, CPUState *env)
1311 {
1312     int i;
1313     struct target_iwmmxt_sigframe *iwmmxtframe;
1314     iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1315     __put_user(TARGET_IWMMXT_MAGIC, &iwmmxtframe->magic);
1316     __put_user(sizeof(*iwmmxtframe), &iwmmxtframe->size);
1317     for (i = 0; i < 16; i++) {
1318         __put_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1319     }
1320     __put_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1321     __put_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1322     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1323     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1324     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1325     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1326     return (abi_ulong*)(iwmmxtframe+1);
1327 }
1328
1329 static void setup_sigframe_v2(struct target_ucontext_v2 *uc,
1330                               target_sigset_t *set, CPUState *env)
1331 {
1332     struct target_sigaltstack stack;
1333     int i;
1334     abi_ulong *regspace;
1335
1336     /* Clear all the bits of the ucontext we don't use.  */
1337     memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext));
1338
1339     memset(&stack, 0, sizeof(stack));
1340     __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1341     __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1342     __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1343     memcpy(&uc->tuc_stack, &stack, sizeof(stack));
1344
1345     setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
1346     /* Save coprocessor signal frame.  */
1347     regspace = uc->tuc_regspace;
1348     if (arm_feature(env, ARM_FEATURE_VFP)) {
1349         regspace = setup_sigframe_v2_vfp(regspace, env);
1350     }
1351     if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
1352         regspace = setup_sigframe_v2_iwmmxt(regspace, env);
1353     }
1354
1355     /* Write terminating magic word */
1356     __put_user(0, regspace);
1357
1358     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1359         __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
1360     }
1361 }
1362
1363 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */
1364 static void setup_frame_v1(int usig, struct target_sigaction *ka,
1365                            target_sigset_t *set, CPUState *regs)
1366 {
1367         struct sigframe_v1 *frame;
1368         abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1369         int i;
1370
1371         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1372                 return;
1373
1374         setup_sigcontext(&frame->sc, regs, set->sig[0]);
1375
1376         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1377             if (__put_user(set->sig[i], &frame->extramask[i - 1]))
1378                 goto end;
1379         }
1380
1381         setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1382                      frame_addr + offsetof(struct sigframe_v1, retcode));
1383
1384 end:
1385         unlock_user_struct(frame, frame_addr, 1);
1386 }
1387
1388 static void setup_frame_v2(int usig, struct target_sigaction *ka,
1389                            target_sigset_t *set, CPUState *regs)
1390 {
1391         struct sigframe_v2 *frame;
1392         abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1393
1394         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1395                 return;
1396
1397         setup_sigframe_v2(&frame->uc, set, regs);
1398
1399         setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1400                      frame_addr + offsetof(struct sigframe_v2, retcode));
1401
1402         unlock_user_struct(frame, frame_addr, 1);
1403 }
1404
1405 static void setup_frame(int usig, struct target_sigaction *ka,
1406                         target_sigset_t *set, CPUState *regs)
1407 {
1408     if (get_osversion() >= 0x020612) {
1409         setup_frame_v2(usig, ka, set, regs);
1410     } else {
1411         setup_frame_v1(usig, ka, set, regs);
1412     }
1413 }
1414
1415 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
1416 static void setup_rt_frame_v1(int usig, struct target_sigaction *ka,
1417                               target_siginfo_t *info,
1418                               target_sigset_t *set, CPUState *env)
1419 {
1420         struct rt_sigframe_v1 *frame;
1421         abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
1422         struct target_sigaltstack stack;
1423         int i;
1424         abi_ulong info_addr, uc_addr;
1425
1426         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1427             return /* 1 */;
1428
1429         info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info);
1430         __put_user(info_addr, &frame->pinfo);
1431         uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);
1432         __put_user(uc_addr, &frame->puc);
1433         copy_siginfo_to_user(&frame->info, info);
1434
1435         /* Clear all the bits of the ucontext we don't use.  */
1436         memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));
1437
1438         memset(&stack, 0, sizeof(stack));
1439         __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1440         __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1441         __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1442         memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
1443
1444         setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]);
1445         for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1446             if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
1447                 goto end;
1448         }
1449
1450         setup_return(env, ka, &frame->retcode, frame_addr, usig,
1451                      frame_addr + offsetof(struct rt_sigframe_v1, retcode));
1452
1453         env->regs[1] = info_addr;
1454         env->regs[2] = uc_addr;
1455
1456 end:
1457         unlock_user_struct(frame, frame_addr, 1);
1458 }
1459
1460 static void setup_rt_frame_v2(int usig, struct target_sigaction *ka,
1461                               target_siginfo_t *info,
1462                               target_sigset_t *set, CPUState *env)
1463 {
1464         struct rt_sigframe_v2 *frame;
1465         abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
1466         abi_ulong info_addr, uc_addr;
1467
1468         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1469             return /* 1 */;
1470
1471         info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info);
1472         uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc);
1473         copy_siginfo_to_user(&frame->info, info);
1474
1475         setup_sigframe_v2(&frame->uc, set, env);
1476
1477         setup_return(env, ka, &frame->retcode, frame_addr, usig,
1478                      frame_addr + offsetof(struct rt_sigframe_v2, retcode));
1479
1480         env->regs[1] = info_addr;
1481         env->regs[2] = uc_addr;
1482
1483         unlock_user_struct(frame, frame_addr, 1);
1484 }
1485
1486 static void setup_rt_frame(int usig, struct target_sigaction *ka,
1487                            target_siginfo_t *info,
1488                            target_sigset_t *set, CPUState *env)
1489 {
1490     if (get_osversion() >= 0x020612) {
1491         setup_rt_frame_v2(usig, ka, info, set, env);
1492     } else {
1493         setup_rt_frame_v1(usig, ka, info, set, env);
1494     }
1495 }
1496
1497 static int
1498 restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
1499 {
1500         int err = 0;
1501         uint32_t cpsr;
1502
1503         __get_user_error(env->regs[0], &sc->arm_r0, err);
1504         __get_user_error(env->regs[1], &sc->arm_r1, err);
1505         __get_user_error(env->regs[2], &sc->arm_r2, err);
1506         __get_user_error(env->regs[3], &sc->arm_r3, err);
1507         __get_user_error(env->regs[4], &sc->arm_r4, err);
1508         __get_user_error(env->regs[5], &sc->arm_r5, err);
1509         __get_user_error(env->regs[6], &sc->arm_r6, err);
1510         __get_user_error(env->regs[7], &sc->arm_r7, err);
1511         __get_user_error(env->regs[8], &sc->arm_r8, err);
1512         __get_user_error(env->regs[9], &sc->arm_r9, err);
1513         __get_user_error(env->regs[10], &sc->arm_r10, err);
1514         __get_user_error(env->regs[11], &sc->arm_fp, err);
1515         __get_user_error(env->regs[12], &sc->arm_ip, err);
1516         __get_user_error(env->regs[13], &sc->arm_sp, err);
1517         __get_user_error(env->regs[14], &sc->arm_lr, err);
1518         __get_user_error(env->regs[15], &sc->arm_pc, err);
1519 #ifdef TARGET_CONFIG_CPU_32
1520         __get_user_error(cpsr, &sc->arm_cpsr, err);
1521         cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC);
1522 #endif
1523
1524         err |= !valid_user_regs(env);
1525
1526         return err;
1527 }
1528
1529 static long do_sigreturn_v1(CPUState *env)
1530 {
1531         abi_ulong frame_addr;
1532         struct sigframe_v1 *frame;
1533         target_sigset_t set;
1534         sigset_t host_set;
1535         int i;
1536
1537         /*
1538          * Since we stacked the signal on a 64-bit boundary,
1539          * then 'sp' should be word aligned here.  If it's
1540          * not, then the user is trying to mess with us.
1541          */
1542         if (env->regs[13] & 7)
1543                 goto badframe;
1544
1545         frame_addr = env->regs[13];
1546         if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1547                 goto badframe;
1548
1549         if (__get_user(set.sig[0], &frame->sc.oldmask))
1550             goto badframe;
1551         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1552             if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1553                 goto badframe;
1554         }
1555
1556         target_to_host_sigset_internal(&host_set, &set);
1557         sigprocmask(SIG_SETMASK, &host_set, NULL);
1558
1559         if (restore_sigcontext(env, &frame->sc))
1560                 goto badframe;
1561
1562 #if 0
1563         /* Send SIGTRAP if we're single-stepping */
1564         if (ptrace_cancel_bpt(current))
1565                 send_sig(SIGTRAP, current, 1);
1566 #endif
1567         unlock_user_struct(frame, frame_addr, 0);
1568         return env->regs[0];
1569
1570 badframe:
1571         unlock_user_struct(frame, frame_addr, 0);
1572         force_sig(TARGET_SIGSEGV /* , current */);
1573         return 0;
1574 }
1575
1576 static abi_ulong *restore_sigframe_v2_vfp(CPUState *env, abi_ulong *regspace)
1577 {
1578     int i;
1579     abi_ulong magic, sz;
1580     uint32_t fpscr, fpexc;
1581     struct target_vfp_sigframe *vfpframe;
1582     vfpframe = (struct target_vfp_sigframe *)regspace;
1583
1584     __get_user(magic, &vfpframe->magic);
1585     __get_user(sz, &vfpframe->size);
1586     if (magic != TARGET_VFP_MAGIC || sz != sizeof(*vfpframe)) {
1587         return 0;
1588     }
1589     for (i = 0; i < 32; i++) {
1590         __get_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
1591     }
1592     __get_user(fpscr, &vfpframe->ufp.fpscr);
1593     vfp_set_fpscr(env, fpscr);
1594     __get_user(fpexc, &vfpframe->ufp_exc.fpexc);
1595     /* Sanitise FPEXC: ensure VFP is enabled, FPINST2 is invalid
1596      * and the exception flag is cleared
1597      */
1598     fpexc |= (1 << 30);
1599     fpexc &= ~((1 << 31) | (1 << 28));
1600     env->vfp.xregs[ARM_VFP_FPEXC] = fpexc;
1601     __get_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1602     __get_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1603     return (abi_ulong*)(vfpframe + 1);
1604 }
1605
1606 static abi_ulong *restore_sigframe_v2_iwmmxt(CPUState *env, abi_ulong *regspace)
1607 {
1608     int i;
1609     abi_ulong magic, sz;
1610     struct target_iwmmxt_sigframe *iwmmxtframe;
1611     iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1612
1613     __get_user(magic, &iwmmxtframe->magic);
1614     __get_user(sz, &iwmmxtframe->size);
1615     if (magic != TARGET_IWMMXT_MAGIC || sz != sizeof(*iwmmxtframe)) {
1616         return 0;
1617     }
1618     for (i = 0; i < 16; i++) {
1619         __get_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1620     }
1621     __get_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1622     __get_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1623     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1624     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1625     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1626     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1627     return (abi_ulong*)(iwmmxtframe + 1);
1628 }
1629
1630 static int do_sigframe_return_v2(CPUState *env, target_ulong frame_addr,
1631                                  struct target_ucontext_v2 *uc)
1632 {
1633     sigset_t host_set;
1634     abi_ulong *regspace;
1635
1636     target_to_host_sigset(&host_set, &uc->tuc_sigmask);
1637     sigprocmask(SIG_SETMASK, &host_set, NULL);
1638
1639     if (restore_sigcontext(env, &uc->tuc_mcontext))
1640         return 1;
1641
1642     /* Restore coprocessor signal frame */
1643     regspace = uc->tuc_regspace;
1644     if (arm_feature(env, ARM_FEATURE_VFP)) {
1645         regspace = restore_sigframe_v2_vfp(env, regspace);
1646         if (!regspace) {
1647             return 1;
1648         }
1649     }
1650     if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
1651         regspace = restore_sigframe_v2_iwmmxt(env, regspace);
1652         if (!regspace) {
1653             return 1;
1654         }
1655     }
1656
1657     if (do_sigaltstack(frame_addr + offsetof(struct target_ucontext_v2, tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1658         return 1;
1659
1660 #if 0
1661     /* Send SIGTRAP if we're single-stepping */
1662     if (ptrace_cancel_bpt(current))
1663             send_sig(SIGTRAP, current, 1);
1664 #endif
1665
1666     return 0;
1667 }
1668
1669 static long do_sigreturn_v2(CPUState *env)
1670 {
1671         abi_ulong frame_addr;
1672         struct sigframe_v2 *frame;
1673
1674         /*
1675          * Since we stacked the signal on a 64-bit boundary,
1676          * then 'sp' should be word aligned here.  If it's
1677          * not, then the user is trying to mess with us.
1678          */
1679         if (env->regs[13] & 7)
1680                 goto badframe;
1681
1682         frame_addr = env->regs[13];
1683         if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1684                 goto badframe;
1685
1686         if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
1687                 goto badframe;
1688
1689         unlock_user_struct(frame, frame_addr, 0);
1690         return env->regs[0];
1691
1692 badframe:
1693         unlock_user_struct(frame, frame_addr, 0);
1694         force_sig(TARGET_SIGSEGV /* , current */);
1695         return 0;
1696 }
1697
1698 long do_sigreturn(CPUState *env)
1699 {
1700     if (get_osversion() >= 0x020612) {
1701         return do_sigreturn_v2(env);
1702     } else {
1703         return do_sigreturn_v1(env);
1704     }
1705 }
1706
1707 static long do_rt_sigreturn_v1(CPUState *env)
1708 {
1709         abi_ulong frame_addr;
1710         struct rt_sigframe_v1 *frame;
1711         sigset_t host_set;
1712
1713         /*
1714          * Since we stacked the signal on a 64-bit boundary,
1715          * then 'sp' should be word aligned here.  If it's
1716          * not, then the user is trying to mess with us.
1717          */
1718         if (env->regs[13] & 7)
1719                 goto badframe;
1720
1721         frame_addr = env->regs[13];
1722         if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1723                 goto badframe;
1724
1725         target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
1726         sigprocmask(SIG_SETMASK, &host_set, NULL);
1727
1728         if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
1729                 goto badframe;
1730
1731         if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1732                 goto badframe;
1733
1734 #if 0
1735         /* Send SIGTRAP if we're single-stepping */
1736         if (ptrace_cancel_bpt(current))
1737                 send_sig(SIGTRAP, current, 1);
1738 #endif
1739         unlock_user_struct(frame, frame_addr, 0);
1740         return env->regs[0];
1741
1742 badframe:
1743         unlock_user_struct(frame, frame_addr, 0);
1744         force_sig(TARGET_SIGSEGV /* , current */);
1745         return 0;
1746 }
1747
1748 static long do_rt_sigreturn_v2(CPUState *env)
1749 {
1750         abi_ulong frame_addr;
1751         struct rt_sigframe_v2 *frame;
1752
1753         /*
1754          * Since we stacked the signal on a 64-bit boundary,
1755          * then 'sp' should be word aligned here.  If it's
1756          * not, then the user is trying to mess with us.
1757          */
1758         if (env->regs[13] & 7)
1759                 goto badframe;
1760
1761         frame_addr = env->regs[13];
1762         if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1763                 goto badframe;
1764
1765         if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
1766                 goto badframe;
1767
1768         unlock_user_struct(frame, frame_addr, 0);
1769         return env->regs[0];
1770
1771 badframe:
1772         unlock_user_struct(frame, frame_addr, 0);
1773         force_sig(TARGET_SIGSEGV /* , current */);
1774         return 0;
1775 }
1776
1777 long do_rt_sigreturn(CPUState *env)
1778 {
1779     if (get_osversion() >= 0x020612) {
1780         return do_rt_sigreturn_v2(env);
1781     } else {
1782         return do_rt_sigreturn_v1(env);
1783     }
1784 }
1785
1786 #elif defined(TARGET_SPARC)
1787
1788 #define __SUNOS_MAXWIN   31
1789
1790 /* This is what SunOS does, so shall I. */
1791 struct target_sigcontext {
1792         abi_ulong sigc_onstack;      /* state to restore */
1793
1794         abi_ulong sigc_mask;         /* sigmask to restore */
1795         abi_ulong sigc_sp;           /* stack pointer */
1796         abi_ulong sigc_pc;           /* program counter */
1797         abi_ulong sigc_npc;          /* next program counter */
1798         abi_ulong sigc_psr;          /* for condition codes etc */
1799         abi_ulong sigc_g1;           /* User uses these two registers */
1800         abi_ulong sigc_o0;           /* within the trampoline code. */
1801
1802         /* Now comes information regarding the users window set
1803          * at the time of the signal.
1804          */
1805         abi_ulong sigc_oswins;       /* outstanding windows */
1806
1807         /* stack ptrs for each regwin buf */
1808         char *sigc_spbuf[__SUNOS_MAXWIN];
1809
1810         /* Windows to restore after signal */
1811         struct {
1812                 abi_ulong locals[8];
1813                 abi_ulong ins[8];
1814         } sigc_wbuf[__SUNOS_MAXWIN];
1815 };
1816 /* A Sparc stack frame */
1817 struct sparc_stackf {
1818         abi_ulong locals[8];
1819         abi_ulong ins[8];
1820         /* It's simpler to treat fp and callers_pc as elements of ins[]
1821          * since we never need to access them ourselves.
1822          */
1823         char *structptr;
1824         abi_ulong xargs[6];
1825         abi_ulong xxargs[1];
1826 };
1827
1828 typedef struct {
1829         struct {
1830                 abi_ulong psr;
1831                 abi_ulong pc;
1832                 abi_ulong npc;
1833                 abi_ulong y;
1834                 abi_ulong u_regs[16]; /* globals and ins */
1835         }               si_regs;
1836         int             si_mask;
1837 } __siginfo_t;
1838
1839 typedef struct {
1840         unsigned   long si_float_regs [32];
1841         unsigned   long si_fsr;
1842         unsigned   long si_fpqdepth;
1843         struct {
1844                 unsigned long *insn_addr;
1845                 unsigned long insn;
1846         } si_fpqueue [16];
1847 } qemu_siginfo_fpu_t;
1848
1849
1850 struct target_signal_frame {
1851         struct sparc_stackf     ss;
1852         __siginfo_t             info;
1853         abi_ulong               fpu_save;
1854         abi_ulong               insns[2] __attribute__ ((aligned (8)));
1855         abi_ulong               extramask[TARGET_NSIG_WORDS - 1];
1856         abi_ulong               extra_size; /* Should be 0 */
1857         qemu_siginfo_fpu_t      fpu_state;
1858 };
1859 struct target_rt_signal_frame {
1860         struct sparc_stackf     ss;
1861         siginfo_t               info;
1862         abi_ulong               regs[20];
1863         sigset_t                mask;
1864         abi_ulong               fpu_save;
1865         unsigned int            insns[2];
1866         stack_t                 stack;
1867         unsigned int            extra_size; /* Should be 0 */
1868         qemu_siginfo_fpu_t      fpu_state;
1869 };
1870
1871 #define UREG_O0        16
1872 #define UREG_O6        22
1873 #define UREG_I0        0
1874 #define UREG_I1        1
1875 #define UREG_I2        2
1876 #define UREG_I3        3
1877 #define UREG_I4        4
1878 #define UREG_I5        5
1879 #define UREG_I6        6
1880 #define UREG_I7        7
1881 #define UREG_L0        8
1882 #define UREG_FP        UREG_I6
1883 #define UREG_SP        UREG_O6
1884
1885 static inline abi_ulong get_sigframe(struct target_sigaction *sa, 
1886                                      CPUState *env, unsigned long framesize)
1887 {
1888         abi_ulong sp;
1889
1890         sp = env->regwptr[UREG_FP];
1891
1892         /* This is the X/Open sanctioned signal stack switching.  */
1893         if (sa->sa_flags & TARGET_SA_ONSTACK) {
1894             if (!on_sig_stack(sp)
1895                 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7))
1896                 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1897         }
1898         return sp - framesize;
1899 }
1900
1901 static int
1902 setup___siginfo(__siginfo_t *si, CPUState *env, abi_ulong mask)
1903 {
1904         int err = 0, i;
1905
1906         err |= __put_user(env->psr, &si->si_regs.psr);
1907         err |= __put_user(env->pc, &si->si_regs.pc);
1908         err |= __put_user(env->npc, &si->si_regs.npc);
1909         err |= __put_user(env->y, &si->si_regs.y);
1910         for (i=0; i < 8; i++) {
1911                 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
1912         }
1913         for (i=0; i < 8; i++) {
1914                 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
1915         }
1916         err |= __put_user(mask, &si->si_mask);
1917         return err;
1918 }
1919
1920 #if 0
1921 static int
1922 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1923                  CPUState *env, unsigned long mask)
1924 {
1925         int err = 0;
1926
1927         err |= __put_user(mask, &sc->sigc_mask);
1928         err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
1929         err |= __put_user(env->pc, &sc->sigc_pc);
1930         err |= __put_user(env->npc, &sc->sigc_npc);
1931         err |= __put_user(env->psr, &sc->sigc_psr);
1932         err |= __put_user(env->gregs[1], &sc->sigc_g1);
1933         err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
1934
1935         return err;
1936 }
1937 #endif
1938 #define NF_ALIGNEDSZ  (((sizeof(struct target_signal_frame) + 7) & (~7)))
1939
1940 static void setup_frame(int sig, struct target_sigaction *ka,
1941                         target_sigset_t *set, CPUState *env)
1942 {
1943         abi_ulong sf_addr;
1944         struct target_signal_frame *sf;
1945         int sigframe_size, err, i;
1946
1947         /* 1. Make sure everything is clean */
1948         //synchronize_user_stack();
1949
1950         sigframe_size = NF_ALIGNEDSZ;
1951         sf_addr = get_sigframe(ka, env, sigframe_size);
1952
1953         sf = lock_user(VERIFY_WRITE, sf_addr, 
1954                        sizeof(struct target_signal_frame), 0);
1955         if (!sf)
1956                 goto sigsegv;
1957                 
1958         //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1959 #if 0
1960         if (invalid_frame_pointer(sf, sigframe_size))
1961                 goto sigill_and_return;
1962 #endif
1963         /* 2. Save the current process state */
1964         err = setup___siginfo(&sf->info, env, set->sig[0]);
1965         err |= __put_user(0, &sf->extra_size);
1966
1967         //err |= save_fpu_state(regs, &sf->fpu_state);
1968         //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1969
1970         err |= __put_user(set->sig[0], &sf->info.si_mask);
1971         for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1972                 err |= __put_user(set->sig[i + 1], &sf->extramask[i]);
1973         }
1974
1975         for (i = 0; i < 8; i++) {
1976                 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
1977         }
1978         for (i = 0; i < 8; i++) {
1979                 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
1980         }
1981         if (err)
1982                 goto sigsegv;
1983
1984         /* 3. signal handler back-trampoline and parameters */
1985         env->regwptr[UREG_FP] = sf_addr;
1986         env->regwptr[UREG_I0] = sig;
1987         env->regwptr[UREG_I1] = sf_addr + 
1988                 offsetof(struct target_signal_frame, info);
1989         env->regwptr[UREG_I2] = sf_addr + 
1990                 offsetof(struct target_signal_frame, info);
1991
1992         /* 4. signal handler */
1993         env->pc = ka->_sa_handler;
1994         env->npc = (env->pc + 4);
1995         /* 5. return to kernel instructions */
1996         if (ka->sa_restorer)
1997                 env->regwptr[UREG_I7] = ka->sa_restorer;
1998         else {
1999                 uint32_t val32;
2000
2001                 env->regwptr[UREG_I7] = sf_addr + 
2002                         offsetof(struct target_signal_frame, insns) - 2 * 4;
2003
2004                 /* mov __NR_sigreturn, %g1 */
2005                 val32 = 0x821020d8;
2006                 err |= __put_user(val32, &sf->insns[0]);
2007
2008                 /* t 0x10 */
2009                 val32 = 0x91d02010;
2010                 err |= __put_user(val32, &sf->insns[1]);
2011                 if (err)
2012                         goto sigsegv;
2013
2014                 /* Flush instruction space. */
2015                 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
2016                 //              tb_flush(env);
2017         }
2018         unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
2019         return;
2020 #if 0
2021 sigill_and_return:
2022         force_sig(TARGET_SIGILL);
2023 #endif
2024 sigsegv:
2025         //fprintf(stderr, "force_sig\n");
2026         unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
2027         force_sig(TARGET_SIGSEGV);
2028 }
2029 static inline int
2030 restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu)
2031 {
2032         int err;
2033 #if 0
2034 #ifdef CONFIG_SMP
2035         if (current->flags & PF_USEDFPU)
2036                 regs->psr &= ~PSR_EF;
2037 #else
2038         if (current == last_task_used_math) {
2039                 last_task_used_math = 0;
2040                 regs->psr &= ~PSR_EF;
2041         }
2042 #endif
2043         current->used_math = 1;
2044         current->flags &= ~PF_USEDFPU;
2045 #endif
2046 #if 0
2047         if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
2048                 return -EFAULT;
2049 #endif
2050
2051 #if 0
2052         /* XXX: incorrect */
2053         err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0],
2054                                      (sizeof(unsigned long) * 32));
2055 #endif
2056         err |= __get_user(env->fsr, &fpu->si_fsr);
2057 #if 0
2058         err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
2059         if (current->thread.fpqdepth != 0)
2060                 err |= __copy_from_user(&current->thread.fpqueue[0],
2061                                         &fpu->si_fpqueue[0],
2062                                         ((sizeof(unsigned long) +
2063                                         (sizeof(unsigned long *)))*16));
2064 #endif
2065         return err;
2066 }
2067
2068
2069 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2070                            target_siginfo_t *info,
2071                            target_sigset_t *set, CPUState *env)
2072 {
2073     fprintf(stderr, "setup_rt_frame: not implemented\n");
2074 }
2075
2076 long do_sigreturn(CPUState *env)
2077 {
2078         abi_ulong sf_addr;
2079         struct target_signal_frame *sf;
2080         uint32_t up_psr, pc, npc;
2081         target_sigset_t set;
2082         sigset_t host_set;
2083         abi_ulong fpu_save_addr;
2084         int err, i;
2085
2086         sf_addr = env->regwptr[UREG_FP];
2087         if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1))
2088                 goto segv_and_exit;
2089 #if 0
2090         fprintf(stderr, "sigreturn\n");
2091         fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
2092 #endif
2093         //cpu_dump_state(env, stderr, fprintf, 0);
2094
2095         /* 1. Make sure we are not getting garbage from the user */
2096
2097         if (sf_addr & 3)
2098                 goto segv_and_exit;
2099
2100         err = __get_user(pc,  &sf->info.si_regs.pc);
2101         err |= __get_user(npc, &sf->info.si_regs.npc);
2102
2103         if ((pc | npc) & 3)
2104                 goto segv_and_exit;
2105
2106         /* 2. Restore the state */
2107         err |= __get_user(up_psr, &sf->info.si_regs.psr);
2108
2109         /* User can only change condition codes and FPU enabling in %psr. */
2110         env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
2111                   | (env->psr & ~(PSR_ICC /* | PSR_EF */));
2112
2113         env->pc = pc;
2114         env->npc = npc;
2115         err |= __get_user(env->y, &sf->info.si_regs.y);
2116         for (i=0; i < 8; i++) {
2117                 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
2118         }
2119         for (i=0; i < 8; i++) {
2120                 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
2121         }
2122
2123         err |= __get_user(fpu_save_addr, &sf->fpu_save);
2124
2125         //if (fpu_save)
2126         //        err |= restore_fpu_state(env, fpu_save);
2127
2128         /* This is pretty much atomic, no amount locking would prevent
2129          * the races which exist anyways.
2130          */
2131         err |= __get_user(set.sig[0], &sf->info.si_mask);
2132         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
2133             err |= (__get_user(set.sig[i], &sf->extramask[i - 1]));
2134         }
2135
2136         target_to_host_sigset_internal(&host_set, &set);
2137         sigprocmask(SIG_SETMASK, &host_set, NULL);
2138
2139         if (err)
2140                 goto segv_and_exit;
2141         unlock_user_struct(sf, sf_addr, 0);
2142         return env->regwptr[0];
2143
2144 segv_and_exit:
2145         unlock_user_struct(sf, sf_addr, 0);
2146         force_sig(TARGET_SIGSEGV);
2147 }
2148
2149 long do_rt_sigreturn(CPUState *env)
2150 {
2151     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2152     return -TARGET_ENOSYS;
2153 }
2154
2155 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
2156 #define MC_TSTATE 0
2157 #define MC_PC 1
2158 #define MC_NPC 2
2159 #define MC_Y 3
2160 #define MC_G1 4
2161 #define MC_G2 5
2162 #define MC_G3 6
2163 #define MC_G4 7
2164 #define MC_G5 8
2165 #define MC_G6 9
2166 #define MC_G7 10
2167 #define MC_O0 11
2168 #define MC_O1 12
2169 #define MC_O2 13
2170 #define MC_O3 14
2171 #define MC_O4 15
2172 #define MC_O5 16
2173 #define MC_O6 17
2174 #define MC_O7 18
2175 #define MC_NGREG 19
2176
2177 typedef abi_ulong target_mc_greg_t;
2178 typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG];
2179
2180 struct target_mc_fq {
2181     abi_ulong *mcfq_addr;
2182     uint32_t mcfq_insn;
2183 };
2184
2185 struct target_mc_fpu {
2186     union {
2187         uint32_t sregs[32];
2188         uint64_t dregs[32];
2189         //uint128_t qregs[16];
2190     } mcfpu_fregs;
2191     abi_ulong mcfpu_fsr;
2192     abi_ulong mcfpu_fprs;
2193     abi_ulong mcfpu_gsr;
2194     struct target_mc_fq *mcfpu_fq;
2195     unsigned char mcfpu_qcnt;
2196     unsigned char mcfpu_qentsz;
2197     unsigned char mcfpu_enab;
2198 };
2199 typedef struct target_mc_fpu target_mc_fpu_t;
2200
2201 typedef struct {
2202     target_mc_gregset_t mc_gregs;
2203     target_mc_greg_t mc_fp;
2204     target_mc_greg_t mc_i7;
2205     target_mc_fpu_t mc_fpregs;
2206 } target_mcontext_t;
2207
2208 struct target_ucontext {
2209     struct target_ucontext *tuc_link;
2210     abi_ulong tuc_flags;
2211     target_sigset_t tuc_sigmask;
2212     target_mcontext_t tuc_mcontext;
2213 };
2214
2215 /* A V9 register window */
2216 struct target_reg_window {
2217     abi_ulong locals[8];
2218     abi_ulong ins[8];
2219 };
2220
2221 #define TARGET_STACK_BIAS 2047
2222
2223 /* {set, get}context() needed for 64-bit SparcLinux userland. */
2224 void sparc64_set_context(CPUSPARCState *env)
2225 {
2226     abi_ulong ucp_addr;
2227     struct target_ucontext *ucp;
2228     target_mc_gregset_t *grp;
2229     abi_ulong pc, npc, tstate;
2230     abi_ulong fp, i7, w_addr;
2231     unsigned char fenab;
2232     int err;
2233     unsigned int i;
2234
2235     ucp_addr = env->regwptr[UREG_I0];
2236     if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1))
2237         goto do_sigsegv;
2238     grp  = &ucp->tuc_mcontext.mc_gregs;
2239     err  = __get_user(pc, &((*grp)[MC_PC]));
2240     err |= __get_user(npc, &((*grp)[MC_NPC]));
2241     if (err || ((pc | npc) & 3))
2242         goto do_sigsegv;
2243     if (env->regwptr[UREG_I1]) {
2244         target_sigset_t target_set;
2245         sigset_t set;
2246
2247         if (TARGET_NSIG_WORDS == 1) {
2248             if (__get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]))
2249                 goto do_sigsegv;
2250         } else {
2251             abi_ulong *src, *dst;
2252             src = ucp->tuc_sigmask.sig;
2253             dst = target_set.sig;
2254             for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
2255                  i++, dst++, src++)
2256                 err |= __get_user(*dst, src);
2257             if (err)
2258                 goto do_sigsegv;
2259         }
2260         target_to_host_sigset_internal(&set, &target_set);
2261         sigprocmask(SIG_SETMASK, &set, NULL);
2262     }
2263     env->pc = pc;
2264     env->npc = npc;
2265     err |= __get_user(env->y, &((*grp)[MC_Y]));
2266     err |= __get_user(tstate, &((*grp)[MC_TSTATE]));
2267     env->asi = (tstate >> 24) & 0xff;
2268     cpu_put_ccr(env, tstate >> 32);
2269     cpu_put_cwp64(env, tstate & 0x1f);
2270     err |= __get_user(env->gregs[1], (&(*grp)[MC_G1]));
2271     err |= __get_user(env->gregs[2], (&(*grp)[MC_G2]));
2272     err |= __get_user(env->gregs[3], (&(*grp)[MC_G3]));
2273     err |= __get_user(env->gregs[4], (&(*grp)[MC_G4]));
2274     err |= __get_user(env->gregs[5], (&(*grp)[MC_G5]));
2275     err |= __get_user(env->gregs[6], (&(*grp)[MC_G6]));
2276     err |= __get_user(env->gregs[7], (&(*grp)[MC_G7]));
2277     err |= __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0]));
2278     err |= __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1]));
2279     err |= __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2]));
2280     err |= __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3]));
2281     err |= __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4]));
2282     err |= __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5]));
2283     err |= __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6]));
2284     err |= __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7]));
2285
2286     err |= __get_user(fp, &(ucp->tuc_mcontext.mc_fp));
2287     err |= __get_user(i7, &(ucp->tuc_mcontext.mc_i7));
2288
2289     w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2290     if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), 
2291                  abi_ulong) != 0)
2292         goto do_sigsegv;
2293     if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), 
2294                  abi_ulong) != 0)
2295         goto do_sigsegv;
2296     err |= __get_user(fenab, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_enab));
2297     err |= __get_user(env->fprs, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fprs));
2298     {
2299         uint32_t *src, *dst;
2300         src = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2301         dst = env->fpr;
2302         /* XXX: check that the CPU storage is the same as user context */
2303         for (i = 0; i < 64; i++, dst++, src++)
2304             err |= __get_user(*dst, src);
2305     }
2306     err |= __get_user(env->fsr,
2307                       &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fsr));
2308     err |= __get_user(env->gsr,
2309                       &(ucp->tuc_mcontext.mc_fpregs.mcfpu_gsr));
2310     if (err)
2311         goto do_sigsegv;
2312     unlock_user_struct(ucp, ucp_addr, 0);
2313     return;
2314  do_sigsegv:
2315     unlock_user_struct(ucp, ucp_addr, 0);
2316     force_sig(TARGET_SIGSEGV);
2317 }
2318
2319 void sparc64_get_context(CPUSPARCState *env)
2320 {
2321     abi_ulong ucp_addr;
2322     struct target_ucontext *ucp;
2323     target_mc_gregset_t *grp;
2324     target_mcontext_t *mcp;
2325     abi_ulong fp, i7, w_addr;
2326     int err;
2327     unsigned int i;
2328     target_sigset_t target_set;
2329     sigset_t set;
2330
2331     ucp_addr = env->regwptr[UREG_I0];
2332     if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0))
2333         goto do_sigsegv;
2334     
2335     mcp = &ucp->tuc_mcontext;
2336     grp = &mcp->mc_gregs;
2337
2338     /* Skip over the trap instruction, first. */
2339     env->pc = env->npc;
2340     env->npc += 4;
2341
2342     err = 0;
2343
2344     sigprocmask(0, NULL, &set);
2345     host_to_target_sigset_internal(&target_set, &set);
2346     if (TARGET_NSIG_WORDS == 1) {
2347         err |= __put_user(target_set.sig[0],
2348                           (abi_ulong *)&ucp->tuc_sigmask);
2349     } else {
2350         abi_ulong *src, *dst;
2351         src = target_set.sig;
2352         dst = ucp->tuc_sigmask.sig;
2353         for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
2354              i++, dst++, src++)
2355             err |= __put_user(*src, dst);
2356         if (err)
2357             goto do_sigsegv;
2358     }
2359
2360     /* XXX: tstate must be saved properly */
2361     //    err |= __put_user(env->tstate, &((*grp)[MC_TSTATE]));
2362     err |= __put_user(env->pc, &((*grp)[MC_PC]));
2363     err |= __put_user(env->npc, &((*grp)[MC_NPC]));
2364     err |= __put_user(env->y, &((*grp)[MC_Y]));
2365     err |= __put_user(env->gregs[1], &((*grp)[MC_G1]));
2366     err |= __put_user(env->gregs[2], &((*grp)[MC_G2]));
2367     err |= __put_user(env->gregs[3], &((*grp)[MC_G3]));
2368     err |= __put_user(env->gregs[4], &((*grp)[MC_G4]));
2369     err |= __put_user(env->gregs[5], &((*grp)[MC_G5]));
2370     err |= __put_user(env->gregs[6], &((*grp)[MC_G6]));
2371     err |= __put_user(env->gregs[7], &((*grp)[MC_G7]));
2372     err |= __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0]));
2373     err |= __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1]));
2374     err |= __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2]));
2375     err |= __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3]));
2376     err |= __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4]));
2377     err |= __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5]));
2378     err |= __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6]));
2379     err |= __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7]));
2380
2381     w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2382     fp = i7 = 0;
2383     if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), 
2384                  abi_ulong) != 0)
2385         goto do_sigsegv;
2386     if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), 
2387                  abi_ulong) != 0)
2388         goto do_sigsegv;
2389     err |= __put_user(fp, &(mcp->mc_fp));
2390     err |= __put_user(i7, &(mcp->mc_i7));
2391
2392     {
2393         uint32_t *src, *dst;
2394         src = env->fpr;
2395         dst = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2396         /* XXX: check that the CPU storage is the same as user context */
2397         for (i = 0; i < 64; i++, dst++, src++)
2398             err |= __put_user(*src, dst);
2399     }
2400     err |= __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr));
2401     err |= __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr));
2402     err |= __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs));
2403
2404     if (err)
2405         goto do_sigsegv;
2406     unlock_user_struct(ucp, ucp_addr, 1);
2407     return;
2408  do_sigsegv:
2409     unlock_user_struct(ucp, ucp_addr, 1);
2410     force_sig(TARGET_SIGSEGV);
2411 }
2412 #endif
2413 #elif defined(TARGET_ABI_MIPSN64)
2414
2415 # warning signal handling not implemented
2416
2417 static void setup_frame(int sig, struct target_sigaction *ka,
2418                         target_sigset_t *set, CPUState *env)
2419 {
2420     fprintf(stderr, "setup_frame: not implemented\n");
2421 }
2422
2423 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2424                            target_siginfo_t *info,
2425                            target_sigset_t *set, CPUState *env)
2426 {
2427     fprintf(stderr, "setup_rt_frame: not implemented\n");
2428 }
2429
2430 long do_sigreturn(CPUState *env)
2431 {
2432     fprintf(stderr, "do_sigreturn: not implemented\n");
2433     return -TARGET_ENOSYS;
2434 }
2435
2436 long do_rt_sigreturn(CPUState *env)
2437 {
2438     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2439     return -TARGET_ENOSYS;
2440 }
2441
2442 #elif defined(TARGET_ABI_MIPSN32)
2443
2444 # warning signal handling not implemented
2445
2446 static void setup_frame(int sig, struct target_sigaction *ka,
2447                         target_sigset_t *set, CPUState *env)
2448 {
2449     fprintf(stderr, "setup_frame: not implemented\n");
2450 }
2451
2452 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2453                            target_siginfo_t *info,
2454                            target_sigset_t *set, CPUState *env)
2455 {
2456     fprintf(stderr, "setup_rt_frame: not implemented\n");
2457 }
2458
2459 long do_sigreturn(CPUState *env)
2460 {
2461     fprintf(stderr, "do_sigreturn: not implemented\n");
2462     return -TARGET_ENOSYS;
2463 }
2464
2465 long do_rt_sigreturn(CPUState *env)
2466 {
2467     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2468     return -TARGET_ENOSYS;
2469 }
2470
2471 #elif defined(TARGET_ABI_MIPSO32)
2472
2473 struct target_sigcontext {
2474     uint32_t   sc_regmask;     /* Unused */
2475     uint32_t   sc_status;
2476     uint64_t   sc_pc;
2477     uint64_t   sc_regs[32];
2478     uint64_t   sc_fpregs[32];
2479     uint32_t   sc_ownedfp;     /* Unused */
2480     uint32_t   sc_fpc_csr;
2481     uint32_t   sc_fpc_eir;     /* Unused */
2482     uint32_t   sc_used_math;
2483     uint32_t   sc_dsp;         /* dsp status, was sc_ssflags */
2484     uint32_t   pad0;
2485     uint64_t   sc_mdhi;
2486     uint64_t   sc_mdlo;
2487     target_ulong   sc_hi1;         /* Was sc_cause */
2488     target_ulong   sc_lo1;         /* Was sc_badvaddr */
2489     target_ulong   sc_hi2;         /* Was sc_sigset[4] */
2490     target_ulong   sc_lo2;
2491     target_ulong   sc_hi3;
2492     target_ulong   sc_lo3;
2493 };
2494
2495 struct sigframe {
2496     uint32_t sf_ass[4];                 /* argument save space for o32 */
2497     uint32_t sf_code[2];                        /* signal trampoline */
2498     struct target_sigcontext sf_sc;
2499     target_sigset_t sf_mask;
2500 };
2501
2502 struct target_ucontext {
2503     target_ulong tuc_flags;
2504     target_ulong tuc_link;
2505     target_stack_t tuc_stack;
2506     target_ulong pad0;
2507     struct target_sigcontext tuc_mcontext;
2508     target_sigset_t tuc_sigmask;
2509 };
2510
2511 struct target_rt_sigframe {
2512     uint32_t rs_ass[4];               /* argument save space for o32 */
2513     uint32_t rs_code[2];              /* signal trampoline */
2514     struct target_siginfo rs_info;
2515     struct target_ucontext rs_uc;
2516 };
2517
2518 /* Install trampoline to jump back from signal handler */
2519 static inline int install_sigtramp(unsigned int *tramp,   unsigned int syscall)
2520 {
2521     int err;
2522
2523     /*
2524     * Set up the return code ...
2525     *
2526     *         li      v0, __NR__foo_sigreturn
2527     *         syscall
2528     */
2529
2530     err = __put_user(0x24020000 + syscall, tramp + 0);
2531     err |= __put_user(0x0000000c          , tramp + 1);
2532     /* flush_cache_sigtramp((unsigned long) tramp); */
2533     return err;
2534 }
2535
2536 static inline int
2537 setup_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2538 {
2539     int err = 0;
2540
2541     err |= __put_user(regs->active_tc.PC, &sc->sc_pc);
2542
2543 #define save_gp_reg(i) do {                                             \
2544         err |= __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);     \
2545     } while(0)
2546     __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
2547     save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
2548     save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
2549     save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
2550     save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
2551     save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
2552     save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
2553     save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
2554     save_gp_reg(31);
2555 #undef save_gp_reg
2556
2557     err |= __put_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2558     err |= __put_user(regs->active_tc.LO[0], &sc->sc_mdlo);
2559
2560     /* Not used yet, but might be useful if we ever have DSP suppport */
2561 #if 0
2562     if (cpu_has_dsp) {
2563         err |= __put_user(mfhi1(), &sc->sc_hi1);
2564         err |= __put_user(mflo1(), &sc->sc_lo1);
2565         err |= __put_user(mfhi2(), &sc->sc_hi2);
2566         err |= __put_user(mflo2(), &sc->sc_lo2);
2567         err |= __put_user(mfhi3(), &sc->sc_hi3);
2568         err |= __put_user(mflo3(), &sc->sc_lo3);
2569         err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2570     }
2571     /* same with 64 bit */
2572 #ifdef CONFIG_64BIT
2573     err |= __put_user(regs->hi, &sc->sc_hi[0]);
2574     err |= __put_user(regs->lo, &sc->sc_lo[0]);
2575     if (cpu_has_dsp) {
2576         err |= __put_user(mfhi1(), &sc->sc_hi[1]);
2577         err |= __put_user(mflo1(), &sc->sc_lo[1]);
2578         err |= __put_user(mfhi2(), &sc->sc_hi[2]);
2579         err |= __put_user(mflo2(), &sc->sc_lo[2]);
2580         err |= __put_user(mfhi3(), &sc->sc_hi[3]);
2581         err |= __put_user(mflo3(), &sc->sc_lo[3]);
2582         err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2583     }
2584 #endif
2585 #endif
2586
2587 #if 0
2588     err |= __put_user(!!used_math(), &sc->sc_used_math);
2589
2590     if (!used_math())
2591         goto out;
2592
2593     /*
2594     * Save FPU state to signal context.  Signal handler will "inherit"
2595     * current FPU state.
2596     */
2597     preempt_disable();
2598
2599     if (!is_fpu_owner()) {
2600         own_fpu();
2601         restore_fp(current);
2602     }
2603     err |= save_fp_context(sc);
2604
2605     preempt_enable();
2606     out:
2607 #endif
2608     return err;
2609 }
2610
2611 static inline int
2612 restore_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2613 {
2614     int err = 0;
2615
2616     err |= __get_user(regs->CP0_EPC, &sc->sc_pc);
2617
2618     err |= __get_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2619     err |= __get_user(regs->active_tc.LO[0], &sc->sc_mdlo);
2620
2621 #define restore_gp_reg(i) do {                                                          \
2622         err |= __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);             \
2623     } while(0)
2624     restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
2625     restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
2626     restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
2627     restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
2628     restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
2629     restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
2630     restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
2631     restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
2632     restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
2633     restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
2634     restore_gp_reg(31);
2635 #undef restore_gp_reg
2636
2637 #if 0
2638     if (cpu_has_dsp) {
2639         err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
2640         err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
2641         err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
2642         err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
2643         err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
2644         err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
2645         err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2646     }
2647 #ifdef CONFIG_64BIT
2648     err |= __get_user(regs->hi, &sc->sc_hi[0]);
2649     err |= __get_user(regs->lo, &sc->sc_lo[0]);
2650     if (cpu_has_dsp) {
2651         err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg);
2652         err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg);
2653         err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg);
2654         err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg);
2655         err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg);
2656         err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg);
2657         err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2658     }
2659 #endif
2660
2661     err |= __get_user(used_math, &sc->sc_used_math);
2662     conditional_used_math(used_math);
2663
2664     preempt_disable();
2665
2666     if (used_math()) {
2667         /* restore fpu context if we have used it before */
2668         own_fpu();
2669         err |= restore_fp_context(sc);
2670     } else {
2671         /* signal handler may have used FPU.  Give it up. */
2672         lose_fpu();
2673     }
2674
2675     preempt_enable();
2676 #endif
2677     return err;
2678 }
2679 /*
2680  * Determine which stack to use..
2681  */
2682 static inline abi_ulong
2683 get_sigframe(struct target_sigaction *ka, CPUState *regs, size_t frame_size)
2684 {
2685     unsigned long sp;
2686
2687     /* Default to using normal stack */
2688     sp = regs->active_tc.gpr[29];
2689
2690     /*
2691      * FPU emulator may have it's own trampoline active just
2692      * above the user stack, 16-bytes before the next lowest
2693      * 16 byte boundary.  Try to avoid trashing it.
2694      */
2695     sp -= 32;
2696
2697     /* This is the X/Open sanctioned signal stack switching.  */
2698     if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
2699         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2700     }
2701
2702     return (sp - frame_size) & ~7;
2703 }
2704
2705 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */
2706 static void setup_frame(int sig, struct target_sigaction * ka,
2707                         target_sigset_t *set, CPUState *regs)
2708 {
2709     struct sigframe *frame;
2710     abi_ulong frame_addr;
2711     int i;
2712
2713     frame_addr = get_sigframe(ka, regs, sizeof(*frame));
2714     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2715         goto give_sigsegv;
2716
2717     install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
2718
2719     if(setup_sigcontext(regs, &frame->sf_sc))
2720         goto give_sigsegv;
2721
2722     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2723         if(__put_user(set->sig[i], &frame->sf_mask.sig[i]))
2724             goto give_sigsegv;
2725     }
2726
2727     /*
2728     * Arguments to signal handler:
2729     *
2730     *   a0 = signal number
2731     *   a1 = 0 (should be cause)
2732     *   a2 = pointer to struct sigcontext
2733     *
2734     * $25 and PC point to the signal handler, $29 points to the
2735     * struct sigframe.
2736     */
2737     regs->active_tc.gpr[ 4] = sig;
2738     regs->active_tc.gpr[ 5] = 0;
2739     regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc);
2740     regs->active_tc.gpr[29] = frame_addr;
2741     regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code);
2742     /* The original kernel code sets CP0_EPC to the handler
2743     * since it returns to userland using eret
2744     * we cannot do this here, and we must set PC directly */
2745     regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler;
2746     unlock_user_struct(frame, frame_addr, 1);
2747     return;
2748
2749 give_sigsegv:
2750     unlock_user_struct(frame, frame_addr, 1);
2751     force_sig(TARGET_SIGSEGV/*, current*/);
2752     return;
2753 }
2754
2755 long do_sigreturn(CPUState *regs)
2756 {
2757     struct sigframe *frame;
2758     abi_ulong frame_addr;
2759     sigset_t blocked;
2760     target_sigset_t target_set;
2761     int i;
2762
2763 #if defined(DEBUG_SIGNAL)
2764     fprintf(stderr, "do_sigreturn\n");
2765 #endif
2766     frame_addr = regs->active_tc.gpr[29];
2767     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2768         goto badframe;
2769
2770     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2771         if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i]))
2772             goto badframe;
2773     }
2774
2775     target_to_host_sigset_internal(&blocked, &target_set);
2776     sigprocmask(SIG_SETMASK, &blocked, NULL);
2777
2778     if (restore_sigcontext(regs, &frame->sf_sc))
2779         goto badframe;
2780
2781 #if 0
2782     /*
2783      * Don't let your children do this ...
2784      */
2785     __asm__ __volatile__(
2786         "move\t$29, %0\n\t"
2787         "j\tsyscall_exit"
2788         :/* no outputs */
2789         :"r" (&regs));
2790     /* Unreached */
2791 #endif
2792
2793     regs->active_tc.PC = regs->CP0_EPC;
2794     /* I am not sure this is right, but it seems to work
2795     * maybe a problem with nested signals ? */
2796     regs->CP0_EPC = 0;
2797     return -TARGET_QEMU_ESIGRETURN;
2798
2799 badframe:
2800     force_sig(TARGET_SIGSEGV/*, current*/);
2801     return 0;
2802 }
2803
2804 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2805                            target_siginfo_t *info,
2806                            target_sigset_t *set, CPUState *env)
2807 {
2808     struct target_rt_sigframe *frame;
2809     abi_ulong frame_addr;
2810     int i;
2811
2812     frame_addr = get_sigframe(ka, env, sizeof(*frame));
2813     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2814         goto give_sigsegv;
2815
2816     install_sigtramp(frame->rs_code, TARGET_NR_rt_sigreturn);
2817
2818     copy_siginfo_to_user(&frame->rs_info, info);
2819
2820     __put_user(0, &frame->rs_uc.tuc_flags);
2821     __put_user(0, &frame->rs_uc.tuc_link);
2822     __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.tuc_stack.ss_sp);
2823     __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.tuc_stack.ss_size);
2824     __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
2825                &frame->rs_uc.tuc_stack.ss_flags);
2826
2827     setup_sigcontext(env, &frame->rs_uc.tuc_mcontext);
2828
2829     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2830         __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]);
2831     }
2832
2833     /*
2834     * Arguments to signal handler:
2835     *
2836     *   a0 = signal number
2837     *   a1 = pointer to struct siginfo
2838     *   a2 = pointer to struct ucontext
2839     *
2840     * $25 and PC point to the signal handler, $29 points to the
2841     * struct sigframe.
2842     */
2843     env->active_tc.gpr[ 4] = sig;
2844     env->active_tc.gpr[ 5] = frame_addr
2845                              + offsetof(struct target_rt_sigframe, rs_info);
2846     env->active_tc.gpr[ 6] = frame_addr
2847                              + offsetof(struct target_rt_sigframe, rs_uc);
2848     env->active_tc.gpr[29] = frame_addr;
2849     env->active_tc.gpr[31] = frame_addr
2850                              + offsetof(struct target_rt_sigframe, rs_code);
2851     /* The original kernel code sets CP0_EPC to the handler
2852     * since it returns to userland using eret
2853     * we cannot do this here, and we must set PC directly */
2854     env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler;
2855     unlock_user_struct(frame, frame_addr, 1);
2856     return;
2857
2858 give_sigsegv:
2859     unlock_user_struct(frame, frame_addr, 1);
2860     force_sig(TARGET_SIGSEGV/*, current*/);
2861     return;
2862 }
2863
2864 long do_rt_sigreturn(CPUState *env)
2865 {
2866     struct target_rt_sigframe *frame;
2867     abi_ulong frame_addr;
2868     sigset_t blocked;
2869
2870 #if defined(DEBUG_SIGNAL)
2871     fprintf(stderr, "do_rt_sigreturn\n");
2872 #endif
2873     frame_addr = env->active_tc.gpr[29];
2874     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2875         goto badframe;
2876
2877     target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask);
2878     sigprocmask(SIG_SETMASK, &blocked, NULL);
2879
2880     if (restore_sigcontext(env, &frame->rs_uc.tuc_mcontext))
2881         goto badframe;
2882
2883     if (do_sigaltstack(frame_addr +
2884                        offsetof(struct target_rt_sigframe, rs_uc.tuc_stack),
2885                        0, get_sp_from_cpustate(env)) == -EFAULT)
2886         goto badframe;
2887
2888     env->active_tc.PC = env->CP0_EPC;
2889     /* I am not sure this is right, but it seems to work
2890     * maybe a problem with nested signals ? */
2891     env->CP0_EPC = 0;
2892     return -TARGET_QEMU_ESIGRETURN;
2893
2894 badframe:
2895     force_sig(TARGET_SIGSEGV/*, current*/);
2896     return 0;
2897 }
2898
2899 #elif defined(TARGET_SH4)
2900
2901 /*
2902  * code and data structures from linux kernel:
2903  * include/asm-sh/sigcontext.h
2904  * arch/sh/kernel/signal.c
2905  */
2906
2907 struct target_sigcontext {
2908     target_ulong  oldmask;
2909
2910     /* CPU registers */
2911     target_ulong  sc_gregs[16];
2912     target_ulong  sc_pc;
2913     target_ulong  sc_pr;
2914     target_ulong  sc_sr;
2915     target_ulong  sc_gbr;
2916     target_ulong  sc_mach;
2917     target_ulong  sc_macl;
2918
2919     /* FPU registers */
2920     target_ulong  sc_fpregs[16];
2921     target_ulong  sc_xfpregs[16];
2922     unsigned int sc_fpscr;
2923     unsigned int sc_fpul;
2924     unsigned int sc_ownedfp;
2925 };
2926
2927 struct target_sigframe
2928 {
2929     struct target_sigcontext sc;
2930     target_ulong extramask[TARGET_NSIG_WORDS-1];
2931     uint16_t retcode[3];
2932 };
2933
2934
2935 struct target_ucontext {
2936     target_ulong tuc_flags;
2937     struct target_ucontext *tuc_link;
2938     target_stack_t tuc_stack;
2939     struct target_sigcontext tuc_mcontext;
2940     target_sigset_t tuc_sigmask;        /* mask last for extensibility */
2941 };
2942
2943 struct target_rt_sigframe
2944 {
2945     struct target_siginfo info;
2946     struct target_ucontext uc;
2947     uint16_t retcode[3];
2948 };
2949
2950
2951 #define MOVW(n)  (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
2952 #define TRAP_NOARG 0xc310         /* Syscall w/no args (NR in R3) SH3/4 */
2953
2954 static abi_ulong get_sigframe(struct target_sigaction *ka,
2955                          unsigned long sp, size_t frame_size)
2956 {
2957     if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) {
2958         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2959     }
2960
2961     return (sp - frame_size) & -8ul;
2962 }
2963
2964 static int setup_sigcontext(struct target_sigcontext *sc,
2965                             CPUState *regs, unsigned long mask)
2966 {
2967     int err = 0;
2968     int i;
2969
2970 #define COPY(x)         err |= __put_user(regs->x, &sc->sc_##x)
2971     COPY(gregs[0]); COPY(gregs[1]);
2972     COPY(gregs[2]); COPY(gregs[3]);
2973     COPY(gregs[4]); COPY(gregs[5]);
2974     COPY(gregs[6]); COPY(gregs[7]);
2975     COPY(gregs[8]); COPY(gregs[9]);
2976     COPY(gregs[10]); COPY(gregs[11]);
2977     COPY(gregs[12]); COPY(gregs[13]);
2978     COPY(gregs[14]); COPY(gregs[15]);
2979     COPY(gbr); COPY(mach);
2980     COPY(macl); COPY(pr);
2981     COPY(sr); COPY(pc);
2982 #undef COPY
2983
2984     for (i=0; i<16; i++) {
2985         err |= __put_user(regs->fregs[i], &sc->sc_fpregs[i]);
2986     }
2987     err |= __put_user(regs->fpscr, &sc->sc_fpscr);
2988     err |= __put_user(regs->fpul, &sc->sc_fpul);
2989
2990     /* non-iBCS2 extensions.. */
2991     err |= __put_user(mask, &sc->oldmask);
2992
2993     return err;
2994 }
2995
2996 static int restore_sigcontext(CPUState *regs, struct target_sigcontext *sc,
2997                               target_ulong *r0_p)
2998 {
2999     unsigned int err = 0;
3000     int i;
3001
3002 #define COPY(x)         err |= __get_user(regs->x, &sc->sc_##x)
3003     COPY(gregs[1]);
3004     COPY(gregs[2]); COPY(gregs[3]);
3005     COPY(gregs[4]); COPY(gregs[5]);
3006     COPY(gregs[6]); COPY(gregs[7]);
3007     COPY(gregs[8]); COPY(gregs[9]);
3008     COPY(gregs[10]); COPY(gregs[11]);
3009     COPY(gregs[12]); COPY(gregs[13]);
3010     COPY(gregs[14]); COPY(gregs[15]);
3011     COPY(gbr); COPY(mach);
3012     COPY(macl); COPY(pr);
3013     COPY(sr); COPY(pc);
3014 #undef COPY
3015
3016     for (i=0; i<16; i++) {
3017         err |= __get_user(regs->fregs[i], &sc->sc_fpregs[i]);
3018     }
3019     err |= __get_user(regs->fpscr, &sc->sc_fpscr);
3020     err |= __get_user(regs->fpul, &sc->sc_fpul);
3021
3022     regs->tra = -1;         /* disable syscall checks */
3023     err |= __get_user(*r0_p, &sc->sc_gregs[0]);
3024     return err;
3025 }
3026
3027 static void setup_frame(int sig, struct target_sigaction *ka,
3028                         target_sigset_t *set, CPUState *regs)
3029 {
3030     struct target_sigframe *frame;
3031     abi_ulong frame_addr;
3032     int i;
3033     int err = 0;
3034     int signal;
3035
3036     frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3037     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3038         goto give_sigsegv;
3039
3040     signal = current_exec_domain_sig(sig);
3041
3042     err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
3043
3044     for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
3045         err |= __put_user(set->sig[i + 1], &frame->extramask[i]);
3046     }
3047
3048     /* Set up to return from userspace.  If provided, use a stub
3049        already in userspace.  */
3050     if (ka->sa_flags & TARGET_SA_RESTORER) {
3051         regs->pr = (unsigned long) ka->sa_restorer;
3052     } else {
3053         /* Generate return code (system call to sigreturn) */
3054         err |= __put_user(MOVW(2), &frame->retcode[0]);
3055         err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
3056         err |= __put_user((TARGET_NR_sigreturn), &frame->retcode[2]);
3057         regs->pr = (unsigned long) frame->retcode;
3058     }
3059
3060     if (err)
3061         goto give_sigsegv;
3062
3063     /* Set up registers for signal handler */
3064     regs->gregs[15] = (unsigned long) frame;
3065     regs->gregs[4] = signal; /* Arg for signal handler */
3066     regs->gregs[5] = 0;
3067     regs->gregs[6] = (unsigned long) &frame->sc;
3068     regs->pc = (unsigned long) ka->_sa_handler;
3069
3070     unlock_user_struct(frame, frame_addr, 1);
3071     return;
3072
3073 give_sigsegv:
3074     unlock_user_struct(frame, frame_addr, 1);
3075     force_sig(TARGET_SIGSEGV);
3076 }
3077
3078 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3079                            target_siginfo_t *info,
3080                            target_sigset_t *set, CPUState *regs)
3081 {
3082     struct target_rt_sigframe *frame;
3083     abi_ulong frame_addr;
3084     int i;
3085     int err = 0;
3086     int signal;
3087
3088     frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3089     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3090         goto give_sigsegv;
3091
3092     signal = current_exec_domain_sig(sig);
3093
3094     err |= copy_siginfo_to_user(&frame->info, info);
3095
3096     /* Create the ucontext.  */
3097     err |= __put_user(0, &frame->uc.tuc_flags);
3098     err |= __put_user(0, (unsigned long *)&frame->uc.tuc_link);
3099     err |= __put_user((unsigned long)target_sigaltstack_used.ss_sp,
3100                       &frame->uc.tuc_stack.ss_sp);
3101     err |= __put_user(sas_ss_flags(regs->gregs[15]),
3102                       &frame->uc.tuc_stack.ss_flags);
3103     err |= __put_user(target_sigaltstack_used.ss_size,
3104                       &frame->uc.tuc_stack.ss_size);
3105     err |= setup_sigcontext(&frame->uc.tuc_mcontext,
3106                             regs, set->sig[0]);
3107     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3108         err |= __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
3109     }
3110
3111     /* Set up to return from userspace.  If provided, use a stub
3112        already in userspace.  */
3113     if (ka->sa_flags & TARGET_SA_RESTORER) {
3114         regs->pr = (unsigned long) ka->sa_restorer;
3115     } else {
3116         /* Generate return code (system call to sigreturn) */
3117         err |= __put_user(MOVW(2), &frame->retcode[0]);
3118         err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
3119         err |= __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]);
3120         regs->pr = (unsigned long) frame->retcode;
3121     }
3122
3123     if (err)
3124         goto give_sigsegv;
3125
3126     /* Set up registers for signal handler */
3127     regs->gregs[15] = (unsigned long) frame;
3128     regs->gregs[4] = signal; /* Arg for signal handler */
3129     regs->gregs[5] = (unsigned long) &frame->info;
3130     regs->gregs[6] = (unsigned long) &frame->uc;
3131     regs->pc = (unsigned long) ka->_sa_handler;
3132
3133     unlock_user_struct(frame, frame_addr, 1);
3134     return;
3135
3136 give_sigsegv:
3137     unlock_user_struct(frame, frame_addr, 1);
3138     force_sig(TARGET_SIGSEGV);
3139 }
3140
3141 long do_sigreturn(CPUState *regs)
3142 {
3143     struct target_sigframe *frame;
3144     abi_ulong frame_addr;
3145     sigset_t blocked;
3146     target_sigset_t target_set;
3147     target_ulong r0;
3148     int i;
3149     int err = 0;
3150
3151 #if defined(DEBUG_SIGNAL)
3152     fprintf(stderr, "do_sigreturn\n");
3153 #endif
3154     frame_addr = regs->gregs[15];
3155     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3156         goto badframe;
3157
3158     err |= __get_user(target_set.sig[0], &frame->sc.oldmask);
3159     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3160         err |= (__get_user(target_set.sig[i], &frame->extramask[i - 1]));
3161     }
3162
3163     if (err)
3164         goto badframe;
3165
3166     target_to_host_sigset_internal(&blocked, &target_set);
3167     sigprocmask(SIG_SETMASK, &blocked, NULL);
3168
3169     if (restore_sigcontext(regs, &frame->sc, &r0))
3170         goto badframe;
3171
3172     unlock_user_struct(frame, frame_addr, 0);
3173     return r0;
3174
3175 badframe:
3176     unlock_user_struct(frame, frame_addr, 0);
3177     force_sig(TARGET_SIGSEGV);
3178     return 0;
3179 }
3180
3181 long do_rt_sigreturn(CPUState *regs)
3182 {
3183     struct target_rt_sigframe *frame;
3184     abi_ulong frame_addr;
3185     sigset_t blocked;
3186     target_ulong r0;
3187
3188 #if defined(DEBUG_SIGNAL)
3189     fprintf(stderr, "do_rt_sigreturn\n");
3190 #endif
3191     frame_addr = regs->gregs[15];
3192     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3193         goto badframe;
3194
3195     target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask);
3196     sigprocmask(SIG_SETMASK, &blocked, NULL);
3197
3198     if (restore_sigcontext(regs, &frame->uc.tuc_mcontext, &r0))
3199         goto badframe;
3200
3201     if (do_sigaltstack(frame_addr +
3202                        offsetof(struct target_rt_sigframe, uc.tuc_stack),
3203                        0, get_sp_from_cpustate(regs)) == -EFAULT)
3204         goto badframe;
3205
3206     unlock_user_struct(frame, frame_addr, 0);
3207     return r0;
3208
3209 badframe:
3210     unlock_user_struct(frame, frame_addr, 0);
3211     force_sig(TARGET_SIGSEGV);
3212     return 0;
3213 }
3214 #elif defined(TARGET_MICROBLAZE)
3215
3216 struct target_sigcontext {
3217     struct target_pt_regs regs;  /* needs to be first */
3218     uint32_t oldmask;
3219 };
3220
3221 struct target_stack_t {
3222     abi_ulong ss_sp;
3223     int ss_flags;
3224     unsigned int ss_size;
3225 };
3226
3227 struct target_ucontext {
3228     abi_ulong tuc_flags;
3229     abi_ulong tuc_link;
3230     struct target_stack_t tuc_stack;
3231     struct target_sigcontext tuc_mcontext;
3232     uint32_t tuc_extramask[TARGET_NSIG_WORDS - 1];
3233 };
3234
3235 /* Signal frames. */
3236 struct target_signal_frame {
3237     struct target_ucontext uc;
3238     uint32_t extramask[TARGET_NSIG_WORDS - 1];
3239     uint32_t tramp[2];
3240 };
3241
3242 struct rt_signal_frame {
3243     struct siginfo info;
3244     struct ucontext uc;
3245     uint32_t tramp[2];
3246 };
3247
3248 static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env)
3249 {
3250     __put_user(env->regs[0], &sc->regs.r0);
3251     __put_user(env->regs[1], &sc->regs.r1);
3252     __put_user(env->regs[2], &sc->regs.r2);
3253     __put_user(env->regs[3], &sc->regs.r3);
3254     __put_user(env->regs[4], &sc->regs.r4);
3255     __put_user(env->regs[5], &sc->regs.r5);
3256     __put_user(env->regs[6], &sc->regs.r6);
3257     __put_user(env->regs[7], &sc->regs.r7);
3258     __put_user(env->regs[8], &sc->regs.r8);
3259     __put_user(env->regs[9], &sc->regs.r9);
3260     __put_user(env->regs[10], &sc->regs.r10);
3261     __put_user(env->regs[11], &sc->regs.r11);
3262     __put_user(env->regs[12], &sc->regs.r12);
3263     __put_user(env->regs[13], &sc->regs.r13);
3264     __put_user(env->regs[14], &sc->regs.r14);
3265     __put_user(env->regs[15], &sc->regs.r15);
3266     __put_user(env->regs[16], &sc->regs.r16);
3267     __put_user(env->regs[17], &sc->regs.r17);
3268     __put_user(env->regs[18], &sc->regs.r18);
3269     __put_user(env->regs[19], &sc->regs.r19);
3270     __put_user(env->regs[20], &sc->regs.r20);
3271     __put_user(env->regs[21], &sc->regs.r21);
3272     __put_user(env->regs[22], &sc->regs.r22);
3273     __put_user(env->regs[23], &sc->regs.r23);
3274     __put_user(env->regs[24], &sc->regs.r24);
3275     __put_user(env->regs[25], &sc->regs.r25);
3276     __put_user(env->regs[26], &sc->regs.r26);
3277     __put_user(env->regs[27], &sc->regs.r27);
3278     __put_user(env->regs[28], &sc->regs.r28);
3279     __put_user(env->regs[29], &sc->regs.r29);
3280     __put_user(env->regs[30], &sc->regs.r30);
3281     __put_user(env->regs[31], &sc->regs.r31);
3282     __put_user(env->sregs[SR_PC], &sc->regs.pc);
3283 }
3284
3285 static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env)
3286 {
3287     __get_user(env->regs[0], &sc->regs.r0);
3288     __get_user(env->regs[1], &sc->regs.r1);
3289     __get_user(env->regs[2], &sc->regs.r2);
3290     __get_user(env->regs[3], &sc->regs.r3);
3291     __get_user(env->regs[4], &sc->regs.r4);
3292     __get_user(env->regs[5], &sc->regs.r5);
3293     __get_user(env->regs[6], &sc->regs.r6);
3294     __get_user(env->regs[7], &sc->regs.r7);
3295     __get_user(env->regs[8], &sc->regs.r8);
3296     __get_user(env->regs[9], &sc->regs.r9);
3297     __get_user(env->regs[10], &sc->regs.r10);
3298     __get_user(env->regs[11], &sc->regs.r11);
3299     __get_user(env->regs[12], &sc->regs.r12);
3300     __get_user(env->regs[13], &sc->regs.r13);
3301     __get_user(env->regs[14], &sc->regs.r14);
3302     __get_user(env->regs[15], &sc->regs.r15);
3303     __get_user(env->regs[16], &sc->regs.r16);
3304     __get_user(env->regs[17], &sc->regs.r17);
3305     __get_user(env->regs[18], &sc->regs.r18);
3306     __get_user(env->regs[19], &sc->regs.r19);
3307     __get_user(env->regs[20], &sc->regs.r20);
3308     __get_user(env->regs[21], &sc->regs.r21);
3309     __get_user(env->regs[22], &sc->regs.r22);
3310     __get_user(env->regs[23], &sc->regs.r23);
3311     __get_user(env->regs[24], &sc->regs.r24);
3312     __get_user(env->regs[25], &sc->regs.r25);
3313     __get_user(env->regs[26], &sc->regs.r26);
3314     __get_user(env->regs[27], &sc->regs.r27);
3315     __get_user(env->regs[28], &sc->regs.r28);
3316     __get_user(env->regs[29], &sc->regs.r29);
3317     __get_user(env->regs[30], &sc->regs.r30);
3318     __get_user(env->regs[31], &sc->regs.r31);
3319     __get_user(env->sregs[SR_PC], &sc->regs.pc);
3320 }
3321
3322 static abi_ulong get_sigframe(struct target_sigaction *ka,
3323                               CPUState *env, int frame_size)
3324 {
3325     abi_ulong sp = env->regs[1];
3326
3327     if ((ka->sa_flags & SA_ONSTACK) != 0 && !on_sig_stack(sp))
3328         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3329
3330     return ((sp - frame_size) & -8UL);
3331 }
3332
3333 static void setup_frame(int sig, struct target_sigaction *ka,
3334                         target_sigset_t *set, CPUState *env)
3335 {
3336     struct target_signal_frame *frame;
3337     abi_ulong frame_addr;
3338     int err = 0;
3339     int i;
3340
3341     frame_addr = get_sigframe(ka, env, sizeof *frame);
3342     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3343         goto badframe;
3344
3345     /* Save the mask.  */
3346     err |= __put_user(set->sig[0], &frame->uc.tuc_mcontext.oldmask);
3347     if (err)
3348         goto badframe;
3349
3350     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3351         if (__put_user(set->sig[i], &frame->extramask[i - 1]))
3352             goto badframe;
3353     }
3354
3355     setup_sigcontext(&frame->uc.tuc_mcontext, env);
3356
3357     /* Set up to return from userspace. If provided, use a stub
3358        already in userspace. */
3359     /* minus 8 is offset to cater for "rtsd r15,8" offset */
3360     if (ka->sa_flags & TARGET_SA_RESTORER) {
3361         env->regs[15] = ((unsigned long)ka->sa_restorer)-8;
3362     } else {
3363         uint32_t t;
3364         /* Note, these encodings are _big endian_! */
3365         /* addi r12, r0, __NR_sigreturn */
3366         t = 0x31800000UL | TARGET_NR_sigreturn;
3367         err |= __put_user(t, frame->tramp + 0);
3368         /* brki r14, 0x8 */
3369         t = 0xb9cc0008UL;
3370         err |= __put_user(t, frame->tramp + 1);
3371
3372         /* Return from sighandler will jump to the tramp.
3373            Negative 8 offset because return is rtsd r15, 8 */
3374         env->regs[15] = ((unsigned long)frame->tramp) - 8;
3375     }
3376
3377     if (err)
3378         goto badframe;
3379
3380     /* Set up registers for signal handler */
3381     env->regs[1] = (unsigned long) frame;
3382     /* Signal handler args: */
3383     env->regs[5] = sig; /* Arg 0: signum */
3384     env->regs[6] = 0;
3385     env->regs[7] = (unsigned long) &frame->uc; /* arg 1: sigcontext */
3386
3387     /* Offset of 4 to handle microblaze rtid r14, 0 */
3388     env->sregs[SR_PC] = (unsigned long)ka->_sa_handler;
3389
3390     unlock_user_struct(frame, frame_addr, 1);
3391     return;
3392   badframe:
3393     unlock_user_struct(frame, frame_addr, 1);
3394     force_sig(TARGET_SIGSEGV);
3395 }
3396
3397 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3398                            target_siginfo_t *info,
3399                            target_sigset_t *set, CPUState *env)
3400 {
3401     fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n");
3402 }
3403
3404 long do_sigreturn(CPUState *env)
3405 {
3406     struct target_signal_frame *frame;
3407     abi_ulong frame_addr;
3408     target_sigset_t target_set;
3409     sigset_t set;
3410     int i;
3411
3412     frame_addr = env->regs[R_SP];
3413     /* Make sure the guest isn't playing games.  */
3414     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3415         goto badframe;
3416
3417     /* Restore blocked signals */
3418     if (__get_user(target_set.sig[0], &frame->uc.tuc_mcontext.oldmask))
3419         goto badframe;
3420     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3421         if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3422             goto badframe;
3423     }
3424     target_to_host_sigset_internal(&set, &target_set);
3425     sigprocmask(SIG_SETMASK, &set, NULL);
3426
3427     restore_sigcontext(&frame->uc.tuc_mcontext, env);
3428     /* We got here through a sigreturn syscall, our path back is via an
3429        rtb insn so setup r14 for that.  */
3430     env->regs[14] = env->sregs[SR_PC];
3431  
3432     unlock_user_struct(frame, frame_addr, 0);
3433     return env->regs[10];
3434   badframe:
3435     unlock_user_struct(frame, frame_addr, 0);
3436     force_sig(TARGET_SIGSEGV);
3437 }
3438
3439 long do_rt_sigreturn(CPUState *env)
3440 {
3441     fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n");
3442     return -TARGET_ENOSYS;
3443 }
3444
3445 #elif defined(TARGET_CRIS)
3446
3447 struct target_sigcontext {
3448         struct target_pt_regs regs;  /* needs to be first */
3449         uint32_t oldmask;
3450         uint32_t usp;    /* usp before stacking this gunk on it */
3451 };
3452
3453 /* Signal frames. */
3454 struct target_signal_frame {
3455         struct target_sigcontext sc;
3456         uint32_t extramask[TARGET_NSIG_WORDS - 1];
3457         uint8_t retcode[8];       /* Trampoline code. */
3458 };
3459
3460 struct rt_signal_frame {
3461         struct siginfo *pinfo;
3462         void *puc;
3463         struct siginfo info;
3464         struct ucontext uc;
3465         uint8_t retcode[8];       /* Trampoline code. */
3466 };
3467
3468 static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env)
3469 {
3470         __put_user(env->regs[0], &sc->regs.r0);
3471         __put_user(env->regs[1], &sc->regs.r1);
3472         __put_user(env->regs[2], &sc->regs.r2);
3473         __put_user(env->regs[3], &sc->regs.r3);
3474         __put_user(env->regs[4], &sc->regs.r4);
3475         __put_user(env->regs[5], &sc->regs.r5);
3476         __put_user(env->regs[6], &sc->regs.r6);
3477         __put_user(env->regs[7], &sc->regs.r7);
3478         __put_user(env->regs[8], &sc->regs.r8);
3479         __put_user(env->regs[9], &sc->regs.r9);
3480         __put_user(env->regs[10], &sc->regs.r10);
3481         __put_user(env->regs[11], &sc->regs.r11);
3482         __put_user(env->regs[12], &sc->regs.r12);
3483         __put_user(env->regs[13], &sc->regs.r13);
3484         __put_user(env->regs[14], &sc->usp);
3485         __put_user(env->regs[15], &sc->regs.acr);
3486         __put_user(env->pregs[PR_MOF], &sc->regs.mof);
3487         __put_user(env->pregs[PR_SRP], &sc->regs.srp);
3488         __put_user(env->pc, &sc->regs.erp);
3489 }
3490
3491 static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env)
3492 {
3493         __get_user(env->regs[0], &sc->regs.r0);
3494         __get_user(env->regs[1], &sc->regs.r1);
3495         __get_user(env->regs[2], &sc->regs.r2);
3496         __get_user(env->regs[3], &sc->regs.r3);
3497         __get_user(env->regs[4], &sc->regs.r4);
3498         __get_user(env->regs[5], &sc->regs.r5);
3499         __get_user(env->regs[6], &sc->regs.r6);
3500         __get_user(env->regs[7], &sc->regs.r7);
3501         __get_user(env->regs[8], &sc->regs.r8);
3502         __get_user(env->regs[9], &sc->regs.r9);
3503         __get_user(env->regs[10], &sc->regs.r10);
3504         __get_user(env->regs[11], &sc->regs.r11);
3505         __get_user(env->regs[12], &sc->regs.r12);
3506         __get_user(env->regs[13], &sc->regs.r13);
3507         __get_user(env->regs[14], &sc->usp);
3508         __get_user(env->regs[15], &sc->regs.acr);
3509         __get_user(env->pregs[PR_MOF], &sc->regs.mof);
3510         __get_user(env->pregs[PR_SRP], &sc->regs.srp);
3511         __get_user(env->pc, &sc->regs.erp);
3512 }
3513
3514 static abi_ulong get_sigframe(CPUState *env, int framesize)
3515 {
3516         abi_ulong sp;
3517         /* Align the stack downwards to 4.  */
3518         sp = (env->regs[R_SP] & ~3);
3519         return sp - framesize;
3520 }
3521
3522 static void setup_frame(int sig, struct target_sigaction *ka,
3523                         target_sigset_t *set, CPUState *env)
3524 {
3525         struct target_signal_frame *frame;
3526         abi_ulong frame_addr;
3527         int err = 0;
3528         int i;
3529
3530         frame_addr = get_sigframe(env, sizeof *frame);
3531         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3532                 goto badframe;
3533
3534         /*
3535          * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
3536          * use this trampoline anymore but it sets it up for GDB.
3537          * In QEMU, using the trampoline simplifies things a bit so we use it.
3538          *
3539          * This is movu.w __NR_sigreturn, r9; break 13;
3540          */
3541         err |= __put_user(0x9c5f, frame->retcode+0);
3542         err |= __put_user(TARGET_NR_sigreturn, 
3543                           frame->retcode+2);
3544         err |= __put_user(0xe93d, frame->retcode+4);
3545
3546         /* Save the mask.  */
3547         err |= __put_user(set->sig[0], &frame->sc.oldmask);
3548         if (err)
3549                 goto badframe;
3550
3551         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3552                 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
3553                         goto badframe;
3554         }
3555
3556         setup_sigcontext(&frame->sc, env);
3557
3558         /* Move the stack and setup the arguments for the handler.  */
3559         env->regs[R_SP] = (uint32_t) (unsigned long) frame;
3560         env->regs[10] = sig;
3561         env->pc = (unsigned long) ka->_sa_handler;
3562         /* Link SRP so the guest returns through the trampoline.  */
3563         env->pregs[PR_SRP] = (uint32_t) (unsigned long) &frame->retcode[0];
3564
3565         unlock_user_struct(frame, frame_addr, 1);
3566         return;
3567   badframe:
3568         unlock_user_struct(frame, frame_addr, 1);
3569         force_sig(TARGET_SIGSEGV);
3570 }
3571
3572 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3573                            target_siginfo_t *info,
3574                            target_sigset_t *set, CPUState *env)
3575 {
3576     fprintf(stderr, "CRIS setup_rt_frame: not implemented\n");
3577 }
3578
3579 long do_sigreturn(CPUState *env)
3580 {
3581         struct target_signal_frame *frame;
3582         abi_ulong frame_addr;
3583         target_sigset_t target_set;
3584         sigset_t set;
3585         int i;
3586
3587         frame_addr = env->regs[R_SP];
3588         /* Make sure the guest isn't playing games.  */
3589         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3590                 goto badframe;
3591
3592         /* Restore blocked signals */
3593         if (__get_user(target_set.sig[0], &frame->sc.oldmask))
3594                 goto badframe;
3595         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3596                 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3597                         goto badframe;
3598         }
3599         target_to_host_sigset_internal(&set, &target_set);
3600         sigprocmask(SIG_SETMASK, &set, NULL);
3601
3602         restore_sigcontext(&frame->sc, env);
3603         unlock_user_struct(frame, frame_addr, 0);
3604         return env->regs[10];
3605   badframe:
3606         unlock_user_struct(frame, frame_addr, 0);
3607         force_sig(TARGET_SIGSEGV);
3608 }
3609
3610 long do_rt_sigreturn(CPUState *env)
3611 {
3612     fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n");
3613     return -TARGET_ENOSYS;
3614 }
3615
3616 #elif defined(TARGET_S390X)
3617
3618 #define __NUM_GPRS 16
3619 #define __NUM_FPRS 16
3620 #define __NUM_ACRS 16
3621
3622 #define S390_SYSCALL_SIZE   2
3623 #define __SIGNAL_FRAMESIZE      160 /* FIXME: 31-bit mode -> 96 */
3624
3625 #define _SIGCONTEXT_NSIG        64
3626 #define _SIGCONTEXT_NSIG_BPW    64 /* FIXME: 31-bit mode -> 32 */
3627 #define _SIGCONTEXT_NSIG_WORDS  (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW)
3628 #define _SIGMASK_COPY_SIZE    (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS)
3629 #define PSW_ADDR_AMODE            0x0000000000000000UL /* 0x80000000UL for 31-bit */
3630 #define S390_SYSCALL_OPCODE ((uint16_t)0x0a00)
3631
3632 typedef struct {
3633     target_psw_t psw;
3634     target_ulong gprs[__NUM_GPRS];
3635     unsigned int acrs[__NUM_ACRS];
3636 } target_s390_regs_common;
3637
3638 typedef struct {
3639     unsigned int fpc;
3640     double   fprs[__NUM_FPRS];
3641 } target_s390_fp_regs;
3642
3643 typedef struct {
3644     target_s390_regs_common regs;
3645     target_s390_fp_regs     fpregs;
3646 } target_sigregs;
3647
3648 struct target_sigcontext {
3649     target_ulong   oldmask[_SIGCONTEXT_NSIG_WORDS];
3650     target_sigregs *sregs;
3651 };
3652
3653 typedef struct {
3654     uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
3655     struct target_sigcontext sc;
3656     target_sigregs sregs;
3657     int signo;
3658     uint8_t retcode[S390_SYSCALL_SIZE];
3659 } sigframe;
3660
3661 struct target_ucontext {
3662     target_ulong uc_flags;
3663     struct target_ucontext *uc_link;
3664     target_stack_t uc_stack;
3665     target_sigregs uc_mcontext;
3666     target_sigset_t uc_sigmask;   /* mask last for extensibility */
3667 };
3668
3669 typedef struct {
3670     uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
3671     uint8_t retcode[S390_SYSCALL_SIZE];
3672     struct target_siginfo info;
3673     struct target_ucontext uc;
3674 } rt_sigframe;
3675
3676 static inline abi_ulong
3677 get_sigframe(struct target_sigaction *ka, CPUState *env, size_t frame_size)
3678 {
3679     abi_ulong sp;
3680
3681     /* Default to using normal stack */
3682     sp = env->regs[15];
3683
3684     /* This is the X/Open sanctioned signal stack switching.  */
3685     if (ka->sa_flags & TARGET_SA_ONSTACK) {
3686         if (!sas_ss_flags(sp)) {
3687             sp = target_sigaltstack_used.ss_sp +
3688                  target_sigaltstack_used.ss_size;
3689         }
3690     }
3691
3692     /* This is the legacy signal stack switching. */
3693     else if (/* FIXME !user_mode(regs) */ 0 &&
3694              !(ka->sa_flags & TARGET_SA_RESTORER) &&
3695              ka->sa_restorer) {
3696         sp = (abi_ulong) ka->sa_restorer;
3697     }
3698
3699     return (sp - frame_size) & -8ul;
3700 }
3701
3702 static void save_sigregs(CPUState *env, target_sigregs *sregs)
3703 {
3704     int i;
3705     //save_access_regs(current->thread.acrs); FIXME
3706
3707     /* Copy a 'clean' PSW mask to the user to avoid leaking
3708        information about whether PER is currently on.  */
3709     __put_user(env->psw.mask, &sregs->regs.psw.mask);
3710     __put_user(env->psw.addr, &sregs->regs.psw.addr);
3711     for (i = 0; i < 16; i++) {
3712         __put_user(env->regs[i], &sregs->regs.gprs[i]);
3713     }
3714     for (i = 0; i < 16; i++) {
3715         __put_user(env->aregs[i], &sregs->regs.acrs[i]);
3716     }
3717     /*
3718      * We have to store the fp registers to current->thread.fp_regs
3719      * to merge them with the emulated registers.
3720      */
3721     //save_fp_regs(&current->thread.fp_regs); FIXME
3722     for (i = 0; i < 16; i++) {
3723         __put_user(env->fregs[i].ll, &sregs->fpregs.fprs[i]);
3724     }
3725 }
3726
3727 static void setup_frame(int sig, struct target_sigaction *ka,
3728                         target_sigset_t *set, CPUState *env)
3729 {
3730     sigframe *frame;
3731     abi_ulong frame_addr;
3732
3733     frame_addr = get_sigframe(ka, env, sizeof(*frame));
3734     qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
3735              (unsigned long long)frame_addr);
3736     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3737             goto give_sigsegv;
3738     }
3739
3740     qemu_log("%s: 1\n", __FUNCTION__);
3741     if (__put_user(set->sig[0], &frame->sc.oldmask[0])) {
3742               goto give_sigsegv;
3743     }
3744
3745     save_sigregs(env, &frame->sregs);
3746
3747     __put_user((abi_ulong)(unsigned long)&frame->sregs,
3748                (abi_ulong *)&frame->sc.sregs);
3749
3750     /* Set up to return from userspace.  If provided, use a stub
3751        already in userspace.  */
3752     if (ka->sa_flags & TARGET_SA_RESTORER) {
3753             env->regs[14] = (unsigned long)
3754                     ka->sa_restorer | PSW_ADDR_AMODE;
3755     } else {
3756             env->regs[14] = (unsigned long)
3757                     frame->retcode | PSW_ADDR_AMODE;
3758             if (__put_user(S390_SYSCALL_OPCODE | TARGET_NR_sigreturn,
3759                            (uint16_t *)(frame->retcode)))
3760                     goto give_sigsegv;
3761     }
3762
3763     /* Set up backchain. */
3764     if (__put_user(env->regs[15], (abi_ulong *) frame)) {
3765             goto give_sigsegv;
3766     }
3767
3768     /* Set up registers for signal handler */
3769     env->regs[15] = (target_ulong)(unsigned long) frame;
3770     env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
3771
3772     env->regs[2] = sig; //map_signal(sig);
3773     env->regs[3] = (target_ulong)(unsigned long) &frame->sc;
3774
3775     /* We forgot to include these in the sigcontext.
3776        To avoid breaking binary compatibility, they are passed as args. */
3777     env->regs[4] = 0; // FIXME: no clue... current->thread.trap_no;
3778     env->regs[5] = 0; // FIXME: no clue... current->thread.prot_addr;
3779
3780     /* Place signal number on stack to allow backtrace from handler.  */
3781     if (__put_user(env->regs[2], (int *) &frame->signo)) {
3782             goto give_sigsegv;
3783     }
3784     unlock_user_struct(frame, frame_addr, 1);
3785     return;
3786
3787 give_sigsegv:
3788     qemu_log("%s: give_sigsegv\n", __FUNCTION__);
3789     unlock_user_struct(frame, frame_addr, 1);
3790     force_sig(TARGET_SIGSEGV);
3791 }
3792
3793 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3794                            target_siginfo_t *info,
3795                            target_sigset_t *set, CPUState *env)
3796 {
3797     int i;
3798     rt_sigframe *frame;
3799     abi_ulong frame_addr;
3800
3801     frame_addr = get_sigframe(ka, env, sizeof *frame);
3802     qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
3803              (unsigned long long)frame_addr);
3804     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3805         goto give_sigsegv;
3806     }
3807
3808     qemu_log("%s: 1\n", __FUNCTION__);
3809     if (copy_siginfo_to_user(&frame->info, info)) {
3810         goto give_sigsegv;
3811     }
3812
3813     /* Create the ucontext.  */
3814     __put_user(0, &frame->uc.uc_flags);
3815     __put_user((abi_ulong)0, (abi_ulong *)&frame->uc.uc_link);
3816     __put_user(target_sigaltstack_used.ss_sp, &frame->uc.uc_stack.ss_sp);
3817     __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
3818                       &frame->uc.uc_stack.ss_flags);
3819     __put_user(target_sigaltstack_used.ss_size, &frame->uc.uc_stack.ss_size);
3820     save_sigregs(env, &frame->uc.uc_mcontext);
3821     for (i = 0; i < TARGET_NSIG_WORDS; i++) {
3822         __put_user((abi_ulong)set->sig[i],
3823         (abi_ulong *)&frame->uc.uc_sigmask.sig[i]);
3824     }
3825
3826     /* Set up to return from userspace.  If provided, use a stub
3827        already in userspace.  */
3828     if (ka->sa_flags & TARGET_SA_RESTORER) {
3829         env->regs[14] = (unsigned long) ka->sa_restorer | PSW_ADDR_AMODE;
3830     } else {
3831         env->regs[14] = (unsigned long) frame->retcode | PSW_ADDR_AMODE;
3832         if (__put_user(S390_SYSCALL_OPCODE | TARGET_NR_rt_sigreturn,
3833                        (uint16_t *)(frame->retcode))) {
3834             goto give_sigsegv;
3835         }
3836     }
3837
3838     /* Set up backchain. */
3839     if (__put_user(env->regs[15], (abi_ulong *) frame)) {
3840         goto give_sigsegv;
3841     }
3842
3843     /* Set up registers for signal handler */
3844     env->regs[15] = (target_ulong)(unsigned long) frame;
3845     env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
3846
3847     env->regs[2] = sig; //map_signal(sig);
3848     env->regs[3] = (target_ulong)(unsigned long) &frame->info;
3849     env->regs[4] = (target_ulong)(unsigned long) &frame->uc;
3850     return;
3851
3852 give_sigsegv:
3853     qemu_log("%s: give_sigsegv\n", __FUNCTION__);
3854     unlock_user_struct(frame, frame_addr, 1);
3855     force_sig(TARGET_SIGSEGV);
3856 }
3857
3858 static int
3859 restore_sigregs(CPUState *env, target_sigregs *sc)
3860 {
3861     int err = 0;
3862     int i;
3863
3864     for (i = 0; i < 16; i++) {
3865         err |= __get_user(env->regs[i], &sc->regs.gprs[i]);
3866     }
3867
3868     err |= __get_user(env->psw.mask, &sc->regs.psw.mask);
3869     qemu_log("%s: sc->regs.psw.addr 0x%llx env->psw.addr 0x%llx\n",
3870              __FUNCTION__, (unsigned long long)sc->regs.psw.addr,
3871              (unsigned long long)env->psw.addr);
3872     err |= __get_user(env->psw.addr, &sc->regs.psw.addr);
3873     /* FIXME: 31-bit -> | PSW_ADDR_AMODE */
3874
3875     for (i = 0; i < 16; i++) {
3876         err |= __get_user(env->aregs[i], &sc->regs.acrs[i]);
3877     }
3878     for (i = 0; i < 16; i++) {
3879         err |= __get_user(env->fregs[i].ll, &sc->fpregs.fprs[i]);
3880     }
3881
3882     return err;
3883 }
3884
3885 long do_sigreturn(CPUState *env)
3886 {
3887     sigframe *frame;
3888     abi_ulong frame_addr = env->regs[15];
3889     qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
3890              (unsigned long long)frame_addr);
3891     target_sigset_t target_set;
3892     sigset_t set;
3893
3894     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
3895         goto badframe;
3896     }
3897     if (__get_user(target_set.sig[0], &frame->sc.oldmask[0])) {
3898         goto badframe;
3899     }
3900
3901     target_to_host_sigset_internal(&set, &target_set);
3902     sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */
3903
3904     if (restore_sigregs(env, &frame->sregs)) {
3905         goto badframe;
3906     }
3907
3908     unlock_user_struct(frame, frame_addr, 0);
3909     return env->regs[2];
3910
3911 badframe:
3912     unlock_user_struct(frame, frame_addr, 0);
3913     force_sig(TARGET_SIGSEGV);
3914     return 0;
3915 }
3916
3917 long do_rt_sigreturn(CPUState *env)
3918 {
3919     rt_sigframe *frame;
3920     abi_ulong frame_addr = env->regs[15];
3921     qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
3922              (unsigned long long)frame_addr);
3923     sigset_t set;
3924
3925     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
3926         goto badframe;
3927     }
3928     target_to_host_sigset(&set, &frame->uc.uc_sigmask);
3929
3930     sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */
3931
3932     if (restore_sigregs(env, &frame->uc.uc_mcontext)) {
3933         goto badframe;
3934     }
3935
3936     if (do_sigaltstack(frame_addr + offsetof(rt_sigframe, uc.uc_stack), 0,
3937                        get_sp_from_cpustate(env)) == -EFAULT) {
3938         goto badframe;
3939     }
3940     unlock_user_struct(frame, frame_addr, 0);
3941     return env->regs[2];
3942
3943 badframe:
3944     unlock_user_struct(frame, frame_addr, 0);
3945     force_sig(TARGET_SIGSEGV);
3946     return 0;
3947 }
3948
3949 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
3950
3951 /* FIXME: Many of the structures are defined for both PPC and PPC64, but
3952    the signal handling is different enough that we haven't implemented
3953    support for PPC64 yet.  Hence the restriction above.
3954
3955    There are various #if'd blocks for code for TARGET_PPC64.  These
3956    blocks should go away so that we can successfully run 32-bit and
3957    64-bit binaries on a QEMU configured for PPC64.  */
3958
3959 /* Size of dummy stack frame allocated when calling signal handler.
3960    See arch/powerpc/include/asm/ptrace.h.  */
3961 #if defined(TARGET_PPC64)
3962 #define SIGNAL_FRAMESIZE 128
3963 #else
3964 #define SIGNAL_FRAMESIZE 64
3965 #endif
3966
3967 /* See arch/powerpc/include/asm/sigcontext.h.  */
3968 struct target_sigcontext {
3969     target_ulong _unused[4];
3970     int32_t signal;
3971 #if defined(TARGET_PPC64)
3972     int32_t pad0;
3973 #endif
3974     target_ulong handler;
3975     target_ulong oldmask;
3976     target_ulong regs;      /* struct pt_regs __user * */
3977     /* TODO: PPC64 includes extra bits here.  */
3978 };
3979
3980 /* Indices for target_mcontext.mc_gregs, below.
3981    See arch/powerpc/include/asm/ptrace.h for details.  */
3982 enum {
3983     TARGET_PT_R0 = 0,
3984     TARGET_PT_R1 = 1,
3985     TARGET_PT_R2 = 2,
3986     TARGET_PT_R3 = 3,
3987     TARGET_PT_R4 = 4,
3988     TARGET_PT_R5 = 5,
3989     TARGET_PT_R6 = 6,
3990     TARGET_PT_R7 = 7,
3991     TARGET_PT_R8 = 8,
3992     TARGET_PT_R9 = 9,
3993     TARGET_PT_R10 = 10,
3994     TARGET_PT_R11 = 11,
3995     TARGET_PT_R12 = 12,
3996     TARGET_PT_R13 = 13,
3997     TARGET_PT_R14 = 14,
3998     TARGET_PT_R15 = 15,
3999     TARGET_PT_R16 = 16,
4000     TARGET_PT_R17 = 17,
4001     TARGET_PT_R18 = 18,
4002     TARGET_PT_R19 = 19,
4003     TARGET_PT_R20 = 20,
4004     TARGET_PT_R21 = 21,
4005     TARGET_PT_R22 = 22,
4006     TARGET_PT_R23 = 23,
4007     TARGET_PT_R24 = 24,
4008     TARGET_PT_R25 = 25,
4009     TARGET_PT_R26 = 26,
4010     TARGET_PT_R27 = 27,
4011     TARGET_PT_R28 = 28,
4012     TARGET_PT_R29 = 29,
4013     TARGET_PT_R30 = 30,
4014     TARGET_PT_R31 = 31,
4015     TARGET_PT_NIP = 32,
4016     TARGET_PT_MSR = 33,
4017     TARGET_PT_ORIG_R3 = 34,
4018     TARGET_PT_CTR = 35,
4019     TARGET_PT_LNK = 36,
4020     TARGET_PT_XER = 37,
4021     TARGET_PT_CCR = 38,
4022     /* Yes, there are two registers with #39.  One is 64-bit only.  */
4023     TARGET_PT_MQ = 39,
4024     TARGET_PT_SOFTE = 39,
4025     TARGET_PT_TRAP = 40,
4026     TARGET_PT_DAR = 41,
4027     TARGET_PT_DSISR = 42,
4028     TARGET_PT_RESULT = 43,
4029     TARGET_PT_REGS_COUNT = 44
4030 };
4031
4032 /* See arch/powerpc/include/asm/ucontext.h.  Only used for 32-bit PPC;
4033    on 64-bit PPC, sigcontext and mcontext are one and the same.  */
4034 struct target_mcontext {
4035     target_ulong mc_gregs[48];
4036     /* Includes fpscr.  */
4037     uint64_t mc_fregs[33];
4038     target_ulong mc_pad[2];
4039     /* We need to handle Altivec and SPE at the same time, which no
4040        kernel needs to do.  Fortunately, the kernel defines this bit to
4041        be Altivec-register-large all the time, rather than trying to
4042        twiddle it based on the specific platform.  */
4043     union {
4044         /* SPE vector registers.  One extra for SPEFSCR.  */
4045         uint32_t spe[33];
4046         /* Altivec vector registers.  The packing of VSCR and VRSAVE
4047            varies depending on whether we're PPC64 or not: PPC64 splits
4048            them apart; PPC32 stuffs them together.  */
4049 #if defined(TARGET_PPC64)
4050 #define QEMU_NVRREG 34
4051 #else
4052 #define QEMU_NVRREG 33
4053 #endif
4054         ppc_avr_t altivec[QEMU_NVRREG];
4055 #undef QEMU_NVRREG
4056     } mc_vregs __attribute__((__aligned__(16)));
4057 };
4058
4059 struct target_ucontext {
4060     target_ulong tuc_flags;
4061     target_ulong tuc_link;    /* struct ucontext __user * */
4062     struct target_sigaltstack tuc_stack;
4063 #if !defined(TARGET_PPC64)
4064     int32_t tuc_pad[7];
4065     target_ulong tuc_regs;    /* struct mcontext __user *
4066                                 points to uc_mcontext field */
4067 #endif
4068     target_sigset_t tuc_sigmask;
4069 #if defined(TARGET_PPC64)
4070     target_sigset_t unused[15]; /* Allow for uc_sigmask growth */
4071     struct target_sigcontext tuc_mcontext;
4072 #else
4073     int32_t tuc_maskext[30];
4074     int32_t tuc_pad2[3];
4075     struct target_mcontext tuc_mcontext;
4076 #endif
4077 };
4078
4079 /* See arch/powerpc/kernel/signal_32.c.  */
4080 struct target_sigframe {
4081     struct target_sigcontext sctx;
4082     struct target_mcontext mctx;
4083     int32_t abigap[56];
4084 };
4085
4086 struct target_rt_sigframe {
4087     struct target_siginfo info;
4088     struct target_ucontext uc;
4089     int32_t abigap[56];
4090 };
4091
4092 /* We use the mc_pad field for the signal return trampoline.  */
4093 #define tramp mc_pad
4094
4095 /* See arch/powerpc/kernel/signal.c.  */
4096 static target_ulong get_sigframe(struct target_sigaction *ka,
4097                                  CPUState *env,
4098                                  int frame_size)
4099 {
4100     target_ulong oldsp, newsp;
4101
4102     oldsp = env->gpr[1];
4103
4104     if ((ka->sa_flags & TARGET_SA_ONSTACK) &&
4105         (sas_ss_flags(oldsp))) {
4106         oldsp = (target_sigaltstack_used.ss_sp
4107                  + target_sigaltstack_used.ss_size);
4108     }
4109
4110     newsp = (oldsp - frame_size) & ~0xFUL;
4111
4112     return newsp;
4113 }
4114
4115 static int save_user_regs(CPUState *env, struct target_mcontext *frame,
4116                           int sigret)
4117 {
4118     target_ulong msr = env->msr;
4119     int i;
4120     target_ulong ccr = 0;
4121
4122     /* In general, the kernel attempts to be intelligent about what it
4123        needs to save for Altivec/FP/SPE registers.  We don't care that
4124        much, so we just go ahead and save everything.  */
4125
4126     /* Save general registers.  */
4127     for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4128         if (__put_user(env->gpr[i], &frame->mc_gregs[i])) {
4129             return 1;
4130         }
4131     }
4132     if (__put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP])
4133         || __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR])
4134         || __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK])
4135         || __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]))
4136         return 1;
4137
4138     for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
4139         ccr |= env->crf[i] << (32 - ((i + 1) * 4));
4140     }
4141     if (__put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]))
4142         return 1;
4143
4144     /* Save Altivec registers if necessary.  */
4145     if (env->insns_flags & PPC_ALTIVEC) {
4146         for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
4147             ppc_avr_t *avr = &env->avr[i];
4148             ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
4149
4150             if (__put_user(avr->u64[0], &vreg->u64[0]) ||
4151                 __put_user(avr->u64[1], &vreg->u64[1])) {
4152                 return 1;
4153             }
4154         }
4155         /* Set MSR_VR in the saved MSR value to indicate that
4156            frame->mc_vregs contains valid data.  */
4157         msr |= MSR_VR;
4158         if (__put_user((uint32_t)env->spr[SPR_VRSAVE],
4159                        &frame->mc_vregs.altivec[32].u32[3]))
4160             return 1;
4161     }
4162
4163     /* Save floating point registers.  */
4164     if (env->insns_flags & PPC_FLOAT) {
4165         for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
4166             if (__put_user(env->fpr[i], &frame->mc_fregs[i])) {
4167                 return 1;
4168             }
4169         }
4170         if (__put_user((uint64_t) env->fpscr, &frame->mc_fregs[32]))
4171             return 1;
4172     }
4173
4174     /* Save SPE registers.  The kernel only saves the high half.  */
4175     if (env->insns_flags & PPC_SPE) {
4176 #if defined(TARGET_PPC64)
4177         for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4178             if (__put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i])) {
4179                 return 1;
4180             }
4181         }
4182 #else
4183         for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
4184             if (__put_user(env->gprh[i], &frame->mc_vregs.spe[i])) {
4185                 return 1;
4186             }
4187         }
4188 #endif
4189         /* Set MSR_SPE in the saved MSR value to indicate that
4190            frame->mc_vregs contains valid data.  */
4191         msr |= MSR_SPE;
4192         if (__put_user(env->spe_fscr, &frame->mc_vregs.spe[32]))
4193             return 1;
4194     }
4195
4196     /* Store MSR.  */
4197     if (__put_user(msr, &frame->mc_gregs[TARGET_PT_MSR]))
4198         return 1;
4199
4200     /* Set up the sigreturn trampoline: li r0,sigret; sc.  */
4201     if (sigret) {
4202         if (__put_user(0x38000000UL | sigret, &frame->tramp[0]) ||
4203             __put_user(0x44000002UL, &frame->tramp[1])) {
4204             return 1;
4205         }
4206     }
4207
4208     return 0;
4209 }
4210
4211 static int restore_user_regs(CPUState *env,
4212                              struct target_mcontext *frame, int sig)
4213 {
4214     target_ulong save_r2 = 0;
4215     target_ulong msr;
4216     target_ulong ccr;
4217
4218     int i;
4219
4220     if (!sig) {
4221         save_r2 = env->gpr[2];
4222     }
4223
4224     /* Restore general registers.  */
4225     for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4226         if (__get_user(env->gpr[i], &frame->mc_gregs[i])) {
4227             return 1;
4228         }
4229     }
4230     if (__get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP])
4231         || __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR])
4232         || __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK])
4233         || __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]))
4234         return 1;
4235     if (__get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]))
4236         return 1;
4237
4238     for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
4239         env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf;
4240     }
4241
4242     if (!sig) {
4243         env->gpr[2] = save_r2;
4244     }
4245     /* Restore MSR.  */
4246     if (__get_user(msr, &frame->mc_gregs[TARGET_PT_MSR]))
4247         return 1;
4248
4249     /* If doing signal return, restore the previous little-endian mode.  */
4250     if (sig)
4251         env->msr = (env->msr & ~MSR_LE) | (msr & MSR_LE);
4252
4253     /* Restore Altivec registers if necessary.  */
4254     if (env->insns_flags & PPC_ALTIVEC) {
4255         for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
4256             ppc_avr_t *avr = &env->avr[i];
4257             ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
4258
4259             if (__get_user(avr->u64[0], &vreg->u64[0]) ||
4260                 __get_user(avr->u64[1], &vreg->u64[1])) {
4261                 return 1;
4262             }
4263         }
4264         /* Set MSR_VEC in the saved MSR value to indicate that
4265            frame->mc_vregs contains valid data.  */
4266         if (__get_user(env->spr[SPR_VRSAVE],
4267                        (target_ulong *)(&frame->mc_vregs.altivec[32].u32[3])))
4268             return 1;
4269     }
4270
4271     /* Restore floating point registers.  */
4272     if (env->insns_flags & PPC_FLOAT) {
4273         uint64_t fpscr;
4274         for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
4275             if (__get_user(env->fpr[i], &frame->mc_fregs[i])) {
4276                 return 1;
4277             }
4278         }
4279         if (__get_user(fpscr, &frame->mc_fregs[32]))
4280             return 1;
4281         env->fpscr = (uint32_t) fpscr;
4282     }
4283
4284     /* Save SPE registers.  The kernel only saves the high half.  */
4285     if (env->insns_flags & PPC_SPE) {
4286 #if defined(TARGET_PPC64)
4287         for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4288             uint32_t hi;
4289
4290             if (__get_user(hi, &frame->mc_vregs.spe[i])) {
4291                 return 1;
4292             }
4293             env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]);
4294         }
4295 #else
4296         for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
4297             if (__get_user(env->gprh[i], &frame->mc_vregs.spe[i])) {
4298                 return 1;
4299             }
4300         }
4301 #endif
4302         if (__get_user(env->spe_fscr, &frame->mc_vregs.spe[32]))
4303             return 1;
4304     }
4305
4306     return 0;
4307 }
4308
4309 static void setup_frame(int sig, struct target_sigaction *ka,
4310                         target_sigset_t *set, CPUState *env)
4311 {
4312     struct target_sigframe *frame;
4313     struct target_sigcontext *sc;
4314     target_ulong frame_addr, newsp;
4315     int err = 0;
4316     int signal;
4317
4318     frame_addr = get_sigframe(ka, env, sizeof(*frame));
4319     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
4320         goto sigsegv;
4321     sc = &frame->sctx;
4322
4323     signal = current_exec_domain_sig(sig);
4324
4325     err |= __put_user(h2g(ka->_sa_handler), &sc->handler);
4326     err |= __put_user(set->sig[0], &sc->oldmask);
4327 #if defined(TARGET_PPC64)
4328     err |= __put_user(set->sig[0] >> 32, &sc->_unused[3]);
4329 #else
4330     err |= __put_user(set->sig[1], &sc->_unused[3]);
4331 #endif
4332     err |= __put_user(h2g(&frame->mctx), &sc->regs);
4333     err |= __put_user(sig, &sc->signal);
4334
4335     /* Save user regs.  */
4336     err |= save_user_regs(env, &frame->mctx, TARGET_NR_sigreturn);
4337
4338     /* The kernel checks for the presence of a VDSO here.  We don't
4339        emulate a vdso, so use a sigreturn system call.  */
4340     env->lr = (target_ulong) h2g(frame->mctx.tramp);
4341
4342     /* Turn off all fp exceptions.  */
4343     env->fpscr = 0;
4344
4345     /* Create a stack frame for the caller of the handler.  */
4346     newsp = frame_addr - SIGNAL_FRAMESIZE;
4347     err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp);
4348
4349     if (err)
4350         goto sigsegv;
4351
4352     /* Set up registers for signal handler.  */
4353     env->gpr[1] = newsp;
4354     env->gpr[3] = signal;
4355     env->gpr[4] = (target_ulong) h2g(sc);
4356     env->nip = (target_ulong) ka->_sa_handler;
4357     /* Signal handlers are entered in big-endian mode.  */
4358     env->msr &= ~MSR_LE;
4359
4360     unlock_user_struct(frame, frame_addr, 1);
4361     return;
4362
4363 sigsegv:
4364     unlock_user_struct(frame, frame_addr, 1);
4365     if (logfile)
4366         fprintf (logfile, "segfaulting from setup_frame\n");
4367     force_sig(TARGET_SIGSEGV);
4368 }
4369
4370 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4371                            target_siginfo_t *info,
4372                            target_sigset_t *set, CPUState *env)
4373 {
4374     struct target_rt_sigframe *rt_sf;
4375     struct target_mcontext *frame;
4376     target_ulong rt_sf_addr, newsp = 0;
4377     int i, err = 0;
4378     int signal;
4379
4380     rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf));
4381     if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1))
4382         goto sigsegv;
4383
4384     signal = current_exec_domain_sig(sig);
4385
4386     err |= copy_siginfo_to_user(&rt_sf->info, info);
4387
4388     err |= __put_user(0, &rt_sf->uc.tuc_flags);
4389     err |= __put_user(0, &rt_sf->uc.tuc_link);
4390     err |= __put_user((target_ulong)target_sigaltstack_used.ss_sp,
4391                       &rt_sf->uc.tuc_stack.ss_sp);
4392     err |= __put_user(sas_ss_flags(env->gpr[1]),
4393                       &rt_sf->uc.tuc_stack.ss_flags);
4394     err |= __put_user(target_sigaltstack_used.ss_size,
4395                       &rt_sf->uc.tuc_stack.ss_size);
4396     err |= __put_user(h2g (&rt_sf->uc.tuc_mcontext),
4397                       &rt_sf->uc.tuc_regs);
4398     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
4399         err |= __put_user(set->sig[i], &rt_sf->uc.tuc_sigmask.sig[i]);
4400     }
4401
4402     frame = &rt_sf->uc.tuc_mcontext;
4403     err |= save_user_regs(env, frame, TARGET_NR_rt_sigreturn);
4404
4405     /* The kernel checks for the presence of a VDSO here.  We don't
4406        emulate a vdso, so use a sigreturn system call.  */
4407     env->lr = (target_ulong) h2g(frame->tramp);
4408
4409     /* Turn off all fp exceptions.  */
4410     env->fpscr = 0;
4411
4412     /* Create a stack frame for the caller of the handler.  */
4413     newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16);
4414     err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp);
4415
4416     if (err)
4417         goto sigsegv;
4418
4419     /* Set up registers for signal handler.  */
4420     env->gpr[1] = newsp;
4421     env->gpr[3] = (target_ulong) signal;
4422     env->gpr[4] = (target_ulong) h2g(&rt_sf->info);
4423     env->gpr[5] = (target_ulong) h2g(&rt_sf->uc);
4424     env->gpr[6] = (target_ulong) h2g(rt_sf);
4425     env->nip = (target_ulong) ka->_sa_handler;
4426     /* Signal handlers are entered in big-endian mode.  */
4427     env->msr &= ~MSR_LE;
4428
4429     unlock_user_struct(rt_sf, rt_sf_addr, 1);
4430     return;
4431
4432 sigsegv:
4433     unlock_user_struct(rt_sf, rt_sf_addr, 1);
4434     if (logfile)
4435         fprintf (logfile, "segfaulting from setup_rt_frame\n");
4436     force_sig(TARGET_SIGSEGV);
4437
4438 }
4439
4440 long do_sigreturn(CPUState *env)
4441 {
4442     struct target_sigcontext *sc = NULL;
4443     struct target_mcontext *sr = NULL;
4444     target_ulong sr_addr, sc_addr;
4445     sigset_t blocked;
4446     target_sigset_t set;
4447
4448     sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE;
4449     if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1))
4450         goto sigsegv;
4451
4452 #if defined(TARGET_PPC64)
4453     set.sig[0] = sc->oldmask + ((long)(sc->_unused[3]) << 32);
4454 #else
4455     if(__get_user(set.sig[0], &sc->oldmask) ||
4456        __get_user(set.sig[1], &sc->_unused[3]))
4457        goto sigsegv;
4458 #endif
4459     target_to_host_sigset_internal(&blocked, &set);
4460     sigprocmask(SIG_SETMASK, &blocked, NULL);
4461
4462     if (__get_user(sr_addr, &sc->regs))
4463         goto sigsegv;
4464     if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1))
4465         goto sigsegv;
4466     if (restore_user_regs(env, sr, 1))
4467         goto sigsegv;
4468
4469     unlock_user_struct(sr, sr_addr, 1);
4470     unlock_user_struct(sc, sc_addr, 1);
4471     return -TARGET_QEMU_ESIGRETURN;
4472
4473 sigsegv:
4474     unlock_user_struct(sr, sr_addr, 1);
4475     unlock_user_struct(sc, sc_addr, 1);
4476     if (logfile)
4477         fprintf (logfile, "segfaulting from do_sigreturn\n");
4478     force_sig(TARGET_SIGSEGV);
4479     return 0;
4480 }
4481
4482 /* See arch/powerpc/kernel/signal_32.c.  */
4483 static int do_setcontext(struct target_ucontext *ucp, CPUState *env, int sig)
4484 {
4485     struct target_mcontext *mcp;
4486     target_ulong mcp_addr;
4487     sigset_t blocked;
4488     target_sigset_t set;
4489
4490     if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, tuc_sigmask),
4491                        sizeof (set)))
4492         return 1;
4493
4494 #if defined(TARGET_PPC64)
4495     fprintf (stderr, "do_setcontext: not implemented\n");
4496     return 0;
4497 #else
4498     if (__get_user(mcp_addr, &ucp->tuc_regs))
4499         return 1;
4500
4501     if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1))
4502         return 1;
4503
4504     target_to_host_sigset_internal(&blocked, &set);
4505     sigprocmask(SIG_SETMASK, &blocked, NULL);
4506     if (restore_user_regs(env, mcp, sig))
4507         goto sigsegv;
4508
4509     unlock_user_struct(mcp, mcp_addr, 1);
4510     return 0;
4511
4512 sigsegv:
4513     unlock_user_struct(mcp, mcp_addr, 1);
4514     return 1;
4515 #endif
4516 }
4517
4518 long do_rt_sigreturn(CPUState *env)
4519 {
4520     struct target_rt_sigframe *rt_sf = NULL;
4521     target_ulong rt_sf_addr;
4522
4523     rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16;
4524     if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1))
4525         goto sigsegv;
4526
4527     if (do_setcontext(&rt_sf->uc, env, 1))
4528         goto sigsegv;
4529
4530     do_sigaltstack(rt_sf_addr
4531                    + offsetof(struct target_rt_sigframe, uc.tuc_stack),
4532                    0, env->gpr[1]);
4533
4534     unlock_user_struct(rt_sf, rt_sf_addr, 1);
4535     return -TARGET_QEMU_ESIGRETURN;
4536
4537 sigsegv:
4538     unlock_user_struct(rt_sf, rt_sf_addr, 1);
4539     if (logfile)
4540         fprintf (logfile, "segfaulting from do_rt_sigreturn\n");
4541     force_sig(TARGET_SIGSEGV);
4542     return 0;
4543 }
4544
4545 #elif defined(TARGET_M68K)
4546
4547 struct target_sigcontext {
4548     abi_ulong  sc_mask;
4549     abi_ulong  sc_usp;
4550     abi_ulong  sc_d0;
4551     abi_ulong  sc_d1;
4552     abi_ulong  sc_a0;
4553     abi_ulong  sc_a1;
4554     unsigned short sc_sr;
4555     abi_ulong  sc_pc;
4556 };
4557
4558 struct target_sigframe
4559 {
4560     abi_ulong pretcode;
4561     int sig;
4562     int code;
4563     abi_ulong psc;
4564     char retcode[8];
4565     abi_ulong extramask[TARGET_NSIG_WORDS-1];
4566     struct target_sigcontext sc;
4567 };
4568  
4569 typedef int target_greg_t;
4570 #define TARGET_NGREG 18
4571 typedef target_greg_t target_gregset_t[TARGET_NGREG];
4572
4573 typedef struct target_fpregset {
4574     int f_fpcntl[3];
4575     int f_fpregs[8*3];
4576 } target_fpregset_t;
4577
4578 struct target_mcontext {
4579     int version;
4580     target_gregset_t gregs;
4581     target_fpregset_t fpregs;
4582 };
4583
4584 #define TARGET_MCONTEXT_VERSION 2
4585
4586 struct target_ucontext {
4587     abi_ulong tuc_flags;
4588     abi_ulong tuc_link;
4589     target_stack_t tuc_stack;
4590     struct target_mcontext tuc_mcontext;
4591     abi_long tuc_filler[80];
4592     target_sigset_t tuc_sigmask;
4593 };
4594
4595 struct target_rt_sigframe
4596 {
4597     abi_ulong pretcode;
4598     int sig;
4599     abi_ulong pinfo;
4600     abi_ulong puc;
4601     char retcode[8];
4602     struct target_siginfo info;
4603     struct target_ucontext uc;
4604 };
4605
4606 static int
4607 setup_sigcontext(struct target_sigcontext *sc, CPUState *env, abi_ulong mask)
4608 {
4609     int err = 0;
4610
4611     err |= __put_user(mask, &sc->sc_mask);
4612     err |= __put_user(env->aregs[7], &sc->sc_usp);
4613     err |= __put_user(env->dregs[0], &sc->sc_d0);
4614     err |= __put_user(env->dregs[1], &sc->sc_d1);
4615     err |= __put_user(env->aregs[0], &sc->sc_a0);
4616     err |= __put_user(env->aregs[1], &sc->sc_a1);
4617     err |= __put_user(env->sr, &sc->sc_sr);
4618     err |= __put_user(env->pc, &sc->sc_pc);
4619
4620     return err;
4621 }
4622
4623 static int
4624 restore_sigcontext(CPUState *env, struct target_sigcontext *sc, int *pd0)
4625 {
4626     int err = 0;
4627     int temp;
4628
4629     err |= __get_user(env->aregs[7], &sc->sc_usp);
4630     err |= __get_user(env->dregs[1], &sc->sc_d1);
4631     err |= __get_user(env->aregs[0], &sc->sc_a0);
4632     err |= __get_user(env->aregs[1], &sc->sc_a1);
4633     err |= __get_user(env->pc, &sc->sc_pc);
4634     err |= __get_user(temp, &sc->sc_sr);
4635     env->sr = (env->sr & 0xff00) | (temp & 0xff);
4636
4637     *pd0 = tswapl(sc->sc_d0);
4638
4639     return err;
4640 }
4641
4642 /*
4643  * Determine which stack to use..
4644  */
4645 static inline abi_ulong
4646 get_sigframe(struct target_sigaction *ka, CPUState *regs, size_t frame_size)
4647 {
4648     unsigned long sp;
4649
4650     sp = regs->aregs[7];
4651
4652     /* This is the X/Open sanctioned signal stack switching.  */
4653     if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
4654         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
4655     }
4656
4657     return ((sp - frame_size) & -8UL);
4658 }
4659
4660 static void setup_frame(int sig, struct target_sigaction *ka,
4661                         target_sigset_t *set, CPUState *env)
4662 {
4663     struct target_sigframe *frame;
4664     abi_ulong frame_addr;
4665     abi_ulong retcode_addr;
4666     abi_ulong sc_addr;
4667     int err = 0;
4668     int i;
4669
4670     frame_addr = get_sigframe(ka, env, sizeof *frame);
4671     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
4672         goto give_sigsegv;
4673
4674     err |= __put_user(sig, &frame->sig);
4675
4676     sc_addr = frame_addr + offsetof(struct target_sigframe, sc);
4677     err |= __put_user(sc_addr, &frame->psc);
4678
4679     err |= setup_sigcontext(&frame->sc, env, set->sig[0]);
4680     if (err)
4681         goto give_sigsegv;
4682
4683     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
4684         if (__put_user(set->sig[i], &frame->extramask[i - 1]))
4685             goto give_sigsegv;
4686     }
4687
4688     /* Set up to return from userspace.  */
4689
4690     retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
4691     err |= __put_user(retcode_addr, &frame->pretcode);
4692
4693     /* moveq #,d0; trap #0 */
4694
4695     err |= __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16),
4696                       (long *)(frame->retcode));
4697
4698     if (err)
4699         goto give_sigsegv;
4700
4701     /* Set up to return from userspace */
4702
4703     env->aregs[7] = frame_addr;
4704     env->pc = ka->_sa_handler;
4705
4706     unlock_user_struct(frame, frame_addr, 1);
4707     return;
4708
4709 give_sigsegv:
4710     unlock_user_struct(frame, frame_addr, 1);
4711     force_sig(TARGET_SIGSEGV);
4712 }
4713
4714 static inline int target_rt_setup_ucontext(struct target_ucontext *uc,
4715                                            CPUState *env)
4716 {
4717     target_greg_t *gregs = uc->tuc_mcontext.gregs;
4718     int err;
4719
4720     err = __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
4721     err |= __put_user(env->dregs[0], &gregs[0]);
4722     err |= __put_user(env->dregs[1], &gregs[1]);
4723     err |= __put_user(env->dregs[2], &gregs[2]);
4724     err |= __put_user(env->dregs[3], &gregs[3]);
4725     err |= __put_user(env->dregs[4], &gregs[4]);
4726     err |= __put_user(env->dregs[5], &gregs[5]);
4727     err |= __put_user(env->dregs[6], &gregs[6]);
4728     err |= __put_user(env->dregs[7], &gregs[7]);
4729     err |= __put_user(env->aregs[0], &gregs[8]);
4730     err |= __put_user(env->aregs[1], &gregs[9]);
4731     err |= __put_user(env->aregs[2], &gregs[10]);
4732     err |= __put_user(env->aregs[3], &gregs[11]);
4733     err |= __put_user(env->aregs[4], &gregs[12]);
4734     err |= __put_user(env->aregs[5], &gregs[13]);
4735     err |= __put_user(env->aregs[6], &gregs[14]);
4736     err |= __put_user(env->aregs[7], &gregs[15]);
4737     err |= __put_user(env->pc, &gregs[16]);
4738     err |= __put_user(env->sr, &gregs[17]);
4739
4740     return err;
4741 }
4742  
4743 static inline int target_rt_restore_ucontext(CPUState *env,
4744                                              struct target_ucontext *uc,
4745                                              int *pd0)
4746 {
4747     int temp;
4748     int err;
4749     target_greg_t *gregs = uc->tuc_mcontext.gregs;
4750     
4751     err = __get_user(temp, &uc->tuc_mcontext.version);
4752     if (temp != TARGET_MCONTEXT_VERSION)
4753         goto badframe;
4754
4755     /* restore passed registers */
4756     err |= __get_user(env->dregs[0], &gregs[0]);
4757     err |= __get_user(env->dregs[1], &gregs[1]);
4758     err |= __get_user(env->dregs[2], &gregs[2]);
4759     err |= __get_user(env->dregs[3], &gregs[3]);
4760     err |= __get_user(env->dregs[4], &gregs[4]);
4761     err |= __get_user(env->dregs[5], &gregs[5]);
4762     err |= __get_user(env->dregs[6], &gregs[6]);
4763     err |= __get_user(env->dregs[7], &gregs[7]);
4764     err |= __get_user(env->aregs[0], &gregs[8]);
4765     err |= __get_user(env->aregs[1], &gregs[9]);
4766     err |= __get_user(env->aregs[2], &gregs[10]);
4767     err |= __get_user(env->aregs[3], &gregs[11]);
4768     err |= __get_user(env->aregs[4], &gregs[12]);
4769     err |= __get_user(env->aregs[5], &gregs[13]);
4770     err |= __get_user(env->aregs[6], &gregs[14]);
4771     err |= __get_user(env->aregs[7], &gregs[15]);
4772     err |= __get_user(env->pc, &gregs[16]);
4773     err |= __get_user(temp, &gregs[17]);
4774     env->sr = (env->sr & 0xff00) | (temp & 0xff);
4775
4776     *pd0 = env->dregs[0];
4777     return err;
4778
4779 badframe:
4780     return 1;
4781 }
4782
4783 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4784                            target_siginfo_t *info,
4785                            target_sigset_t *set, CPUState *env)
4786 {
4787     struct target_rt_sigframe *frame;
4788     abi_ulong frame_addr;
4789     abi_ulong retcode_addr;
4790     abi_ulong info_addr;
4791     abi_ulong uc_addr;
4792     int err = 0;
4793     int i;
4794
4795     frame_addr = get_sigframe(ka, env, sizeof *frame);
4796     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
4797         goto give_sigsegv;
4798
4799     err |= __put_user(sig, &frame->sig);
4800
4801     info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
4802     err |= __put_user(info_addr, &frame->pinfo);
4803
4804     uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
4805     err |= __put_user(uc_addr, &frame->puc);
4806
4807     err |= copy_siginfo_to_user(&frame->info, info);
4808
4809     /* Create the ucontext */
4810
4811     err |= __put_user(0, &frame->uc.tuc_flags);
4812     err |= __put_user(0, &frame->uc.tuc_link);
4813     err |= __put_user(target_sigaltstack_used.ss_sp,
4814                       &frame->uc.tuc_stack.ss_sp);
4815     err |= __put_user(sas_ss_flags(env->aregs[7]),
4816                       &frame->uc.tuc_stack.ss_flags);
4817     err |= __put_user(target_sigaltstack_used.ss_size,
4818                       &frame->uc.tuc_stack.ss_size);
4819     err |= target_rt_setup_ucontext(&frame->uc, env);
4820
4821     if (err)
4822             goto give_sigsegv;
4823
4824     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
4825         if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
4826             goto give_sigsegv;
4827     }
4828
4829     /* Set up to return from userspace.  */
4830
4831     retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
4832     err |= __put_user(retcode_addr, &frame->pretcode);
4833
4834     /* moveq #,d0; notb d0; trap #0 */
4835
4836     err |= __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16),
4837                       (long *)(frame->retcode + 0));
4838     err |= __put_user(0x4e40, (short *)(frame->retcode + 4));
4839
4840     if (err)
4841         goto give_sigsegv;
4842
4843     /* Set up to return from userspace */
4844
4845     env->aregs[7] = frame_addr;
4846     env->pc = ka->_sa_handler;
4847
4848     unlock_user_struct(frame, frame_addr, 1);
4849     return;
4850
4851 give_sigsegv:
4852     unlock_user_struct(frame, frame_addr, 1);
4853     force_sig(TARGET_SIGSEGV);
4854 }
4855
4856 long do_sigreturn(CPUState *env)
4857 {
4858     struct target_sigframe *frame;
4859     abi_ulong frame_addr = env->aregs[7] - 4;
4860     target_sigset_t target_set;
4861     sigset_t set;
4862     int d0, i;
4863
4864     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
4865         goto badframe;
4866
4867     /* set blocked signals */
4868
4869     if (__get_user(target_set.sig[0], &frame->sc.sc_mask))
4870         goto badframe;
4871
4872     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
4873         if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
4874             goto badframe;
4875     }
4876
4877     target_to_host_sigset_internal(&set, &target_set);
4878     sigprocmask(SIG_SETMASK, &set, NULL);
4879
4880     /* restore registers */
4881
4882     if (restore_sigcontext(env, &frame->sc, &d0))
4883         goto badframe;
4884
4885     unlock_user_struct(frame, frame_addr, 0);
4886     return d0;
4887
4888 badframe:
4889     unlock_user_struct(frame, frame_addr, 0);
4890     force_sig(TARGET_SIGSEGV);
4891     return 0;
4892 }
4893
4894 long do_rt_sigreturn(CPUState *env)
4895 {
4896     struct target_rt_sigframe *frame;
4897     abi_ulong frame_addr = env->aregs[7] - 4;
4898     target_sigset_t target_set;
4899     sigset_t set;
4900     int d0;
4901
4902     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
4903         goto badframe;
4904
4905     target_to_host_sigset_internal(&set, &target_set);
4906     sigprocmask(SIG_SETMASK, &set, NULL);
4907
4908     /* restore registers */
4909
4910     if (target_rt_restore_ucontext(env, &frame->uc, &d0))
4911         goto badframe;
4912
4913     if (do_sigaltstack(frame_addr +
4914                        offsetof(struct target_rt_sigframe, uc.tuc_stack),
4915                        0, get_sp_from_cpustate(env)) == -EFAULT)
4916         goto badframe;
4917
4918     unlock_user_struct(frame, frame_addr, 0);
4919     return d0;
4920
4921 badframe:
4922     unlock_user_struct(frame, frame_addr, 0);
4923     force_sig(TARGET_SIGSEGV);
4924     return 0;
4925 }
4926
4927 #elif defined(TARGET_ALPHA)
4928
4929 struct target_sigcontext {
4930     abi_long sc_onstack;
4931     abi_long sc_mask;
4932     abi_long sc_pc;
4933     abi_long sc_ps;
4934     abi_long sc_regs[32];
4935     abi_long sc_ownedfp;
4936     abi_long sc_fpregs[32];
4937     abi_ulong sc_fpcr;
4938     abi_ulong sc_fp_control;
4939     abi_ulong sc_reserved1;
4940     abi_ulong sc_reserved2;
4941     abi_ulong sc_ssize;
4942     abi_ulong sc_sbase;
4943     abi_ulong sc_traparg_a0;
4944     abi_ulong sc_traparg_a1;
4945     abi_ulong sc_traparg_a2;
4946     abi_ulong sc_fp_trap_pc;
4947     abi_ulong sc_fp_trigger_sum;
4948     abi_ulong sc_fp_trigger_inst;
4949 };
4950
4951 struct target_ucontext {
4952     abi_ulong tuc_flags;
4953     abi_ulong tuc_link;
4954     abi_ulong tuc_osf_sigmask;
4955     target_stack_t tuc_stack;
4956     struct target_sigcontext tuc_mcontext;
4957     target_sigset_t tuc_sigmask;
4958 };
4959
4960 struct target_sigframe {
4961     struct target_sigcontext sc;
4962     unsigned int retcode[3];
4963 };
4964
4965 struct target_rt_sigframe {
4966     target_siginfo_t info;
4967     struct target_ucontext uc;
4968     unsigned int retcode[3];
4969 };
4970
4971 #define INSN_MOV_R30_R16        0x47fe0410
4972 #define INSN_LDI_R0             0x201f0000
4973 #define INSN_CALLSYS            0x00000083
4974
4975 static int setup_sigcontext(struct target_sigcontext *sc, CPUState *env,
4976                             abi_ulong frame_addr, target_sigset_t *set)
4977 {
4978     int i, err = 0;
4979
4980     err |= __put_user(on_sig_stack(frame_addr), &sc->sc_onstack);
4981     err |= __put_user(set->sig[0], &sc->sc_mask);
4982     err |= __put_user(env->pc, &sc->sc_pc);
4983     err |= __put_user(8, &sc->sc_ps);
4984
4985     for (i = 0; i < 31; ++i) {
4986         err |= __put_user(env->ir[i], &sc->sc_regs[i]);
4987     }
4988     err |= __put_user(0, &sc->sc_regs[31]);
4989
4990     for (i = 0; i < 31; ++i) {
4991         err |= __put_user(env->fir[i], &sc->sc_fpregs[i]);
4992     }
4993     err |= __put_user(0, &sc->sc_fpregs[31]);
4994     err |= __put_user(cpu_alpha_load_fpcr(env), &sc->sc_fpcr);
4995
4996     err |= __put_user(0, &sc->sc_traparg_a0); /* FIXME */
4997     err |= __put_user(0, &sc->sc_traparg_a1); /* FIXME */
4998     err |= __put_user(0, &sc->sc_traparg_a2); /* FIXME */
4999
5000     return err;
5001 }
5002
5003 static int restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
5004 {
5005     uint64_t fpcr;
5006     int i, err = 0;
5007
5008     err |= __get_user(env->pc, &sc->sc_pc);
5009
5010     for (i = 0; i < 31; ++i) {
5011         err |= __get_user(env->ir[i], &sc->sc_regs[i]);
5012     }
5013     for (i = 0; i < 31; ++i) {
5014         err |= __get_user(env->fir[i], &sc->sc_fpregs[i]);
5015     }
5016
5017     err |= __get_user(fpcr, &sc->sc_fpcr);
5018     cpu_alpha_store_fpcr(env, fpcr);
5019
5020     return err;
5021 }
5022
5023 static inline abi_ulong get_sigframe(struct target_sigaction *sa,
5024                                      CPUState *env, unsigned long framesize)
5025 {
5026     abi_ulong sp = env->ir[IR_SP];
5027
5028     /* This is the X/Open sanctioned signal stack switching.  */
5029     if ((sa->sa_flags & TARGET_SA_ONSTACK) != 0 && !sas_ss_flags(sp)) {
5030         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5031     }
5032     return (sp - framesize) & -32;
5033 }
5034
5035 static void setup_frame(int sig, struct target_sigaction *ka,
5036                         target_sigset_t *set, CPUState *env)
5037 {
5038     abi_ulong frame_addr, r26;
5039     struct target_sigframe *frame;
5040     int err = 0;
5041
5042     frame_addr = get_sigframe(ka, env, sizeof(*frame));
5043     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5044         goto give_sigsegv;
5045     }
5046
5047     err |= setup_sigcontext(&frame->sc, env, frame_addr, set);
5048
5049     if (ka->sa_restorer) {
5050         r26 = ka->sa_restorer;
5051     } else {
5052         err |= __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
5053         err |= __put_user(INSN_LDI_R0 + TARGET_NR_sigreturn,
5054                           &frame->retcode[1]);
5055         err |= __put_user(INSN_CALLSYS, &frame->retcode[2]);
5056         /* imb() */
5057         r26 = frame_addr;
5058     }
5059
5060     unlock_user_struct(frame, frame_addr, 1);
5061
5062     if (err) {
5063     give_sigsegv:
5064         if (sig == TARGET_SIGSEGV) {
5065             ka->_sa_handler = TARGET_SIG_DFL;
5066         }
5067         force_sig(TARGET_SIGSEGV);
5068     }
5069
5070     env->ir[IR_RA] = r26;
5071     env->ir[IR_PV] = env->pc = ka->_sa_handler;
5072     env->ir[IR_A0] = sig;
5073     env->ir[IR_A1] = 0;
5074     env->ir[IR_A2] = frame_addr + offsetof(struct target_sigframe, sc);
5075     env->ir[IR_SP] = frame_addr;
5076 }
5077
5078 static void setup_rt_frame(int sig, struct target_sigaction *ka,
5079                            target_siginfo_t *info,
5080                            target_sigset_t *set, CPUState *env)
5081 {
5082     abi_ulong frame_addr, r26;
5083     struct target_rt_sigframe *frame;
5084     int i, err = 0;
5085
5086     frame_addr = get_sigframe(ka, env, sizeof(*frame));
5087     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5088         goto give_sigsegv;
5089     }
5090
5091     err |= copy_siginfo_to_user(&frame->info, info);
5092
5093     err |= __put_user(0, &frame->uc.tuc_flags);
5094     err |= __put_user(0, &frame->uc.tuc_link);
5095     err |= __put_user(set->sig[0], &frame->uc.tuc_osf_sigmask);
5096     err |= __put_user(target_sigaltstack_used.ss_sp,
5097                       &frame->uc.tuc_stack.ss_sp);
5098     err |= __put_user(sas_ss_flags(env->ir[IR_SP]),
5099                       &frame->uc.tuc_stack.ss_flags);
5100     err |= __put_user(target_sigaltstack_used.ss_size,
5101                       &frame->uc.tuc_stack.ss_size);
5102     err |= setup_sigcontext(&frame->uc.tuc_mcontext, env, frame_addr, set);
5103     for (i = 0; i < TARGET_NSIG_WORDS; ++i) {
5104         err |= __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
5105     }
5106
5107     if (ka->sa_restorer) {
5108         r26 = ka->sa_restorer;
5109     } else {
5110         err |= __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
5111         err |= __put_user(INSN_LDI_R0 + TARGET_NR_rt_sigreturn,
5112                           &frame->retcode[1]);
5113         err |= __put_user(INSN_CALLSYS, &frame->retcode[2]);
5114         /* imb(); */
5115         r26 = frame_addr;
5116     }
5117
5118     if (err) {
5119     give_sigsegv:
5120        if (sig == TARGET_SIGSEGV) {
5121             ka->_sa_handler = TARGET_SIG_DFL;
5122         }
5123         force_sig(TARGET_SIGSEGV);
5124     }
5125
5126     env->ir[IR_RA] = r26;
5127     env->ir[IR_PV] = env->pc = ka->_sa_handler;
5128     env->ir[IR_A0] = sig;
5129     env->ir[IR_A1] = frame_addr + offsetof(struct target_rt_sigframe, info);
5130     env->ir[IR_A2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
5131     env->ir[IR_SP] = frame_addr;
5132 }
5133
5134 long do_sigreturn(CPUState *env)
5135 {
5136     struct target_sigcontext *sc;
5137     abi_ulong sc_addr = env->ir[IR_A0];
5138     target_sigset_t target_set;
5139     sigset_t set;
5140
5141     if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) {
5142         goto badframe;
5143     }
5144
5145     target_sigemptyset(&target_set);
5146     if (__get_user(target_set.sig[0], &sc->sc_mask)) {
5147         goto badframe;
5148     }
5149
5150     target_to_host_sigset_internal(&set, &target_set);
5151     sigprocmask(SIG_SETMASK, &set, NULL);
5152
5153     if (restore_sigcontext(env, sc)) {
5154         goto badframe;
5155     }
5156     unlock_user_struct(sc, sc_addr, 0);
5157     return env->ir[IR_V0];
5158
5159  badframe:
5160     unlock_user_struct(sc, sc_addr, 0);
5161     force_sig(TARGET_SIGSEGV);
5162 }
5163
5164 long do_rt_sigreturn(CPUState *env)
5165 {
5166     abi_ulong frame_addr = env->ir[IR_A0];
5167     struct target_rt_sigframe *frame;
5168     sigset_t set;
5169
5170     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
5171         goto badframe;
5172     }
5173     target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
5174     sigprocmask(SIG_SETMASK, &set, NULL);
5175
5176     if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) {
5177         goto badframe;
5178     }
5179     if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
5180                                              uc.tuc_stack),
5181                        0, env->ir[IR_SP]) == -EFAULT) {
5182         goto badframe;
5183     }
5184
5185     unlock_user_struct(frame, frame_addr, 0);
5186     return env->ir[IR_V0];
5187
5188
5189  badframe:
5190     unlock_user_struct(frame, frame_addr, 0);
5191     force_sig(TARGET_SIGSEGV);
5192 }
5193
5194 #else
5195
5196 static void setup_frame(int sig, struct target_sigaction *ka,
5197                         target_sigset_t *set, CPUState *env)
5198 {
5199     fprintf(stderr, "setup_frame: not implemented\n");
5200 }
5201
5202 static void setup_rt_frame(int sig, struct target_sigaction *ka,
5203                            target_siginfo_t *info,
5204                            target_sigset_t *set, CPUState *env)
5205 {
5206     fprintf(stderr, "setup_rt_frame: not implemented\n");
5207 }
5208
5209 long do_sigreturn(CPUState *env)
5210 {
5211     fprintf(stderr, "do_sigreturn: not implemented\n");
5212     return -TARGET_ENOSYS;
5213 }
5214
5215 long do_rt_sigreturn(CPUState *env)
5216 {
5217     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
5218     return -TARGET_ENOSYS;
5219 }
5220
5221 #endif
5222
5223 void process_pending_signals(CPUState *cpu_env)
5224 {
5225     int sig;
5226     abi_ulong handler;
5227     sigset_t set, old_set;
5228     target_sigset_t target_old_set;
5229     struct emulated_sigtable *k;
5230     struct target_sigaction *sa;
5231     struct sigqueue *q;
5232     TaskState *ts = cpu_env->opaque;
5233
5234     if (!ts->signal_pending)
5235         return;
5236
5237     /* FIXME: This is not threadsafe.  */
5238     k = ts->sigtab;
5239     for(sig = 1; sig <= TARGET_NSIG; sig++) {
5240         if (k->pending)
5241             goto handle_signal;
5242         k++;
5243     }
5244     /* if no signal is pending, just return */
5245     ts->signal_pending = 0;
5246     return;
5247
5248  handle_signal:
5249 #ifdef DEBUG_SIGNAL
5250     fprintf(stderr, "qemu: process signal %d\n", sig);
5251 #endif
5252     /* dequeue signal */
5253     q = k->first;
5254     k->first = q->next;
5255     if (!k->first)
5256         k->pending = 0;
5257
5258     sig = gdb_handlesig (cpu_env, sig);
5259     if (!sig) {
5260         sa = NULL;
5261         handler = TARGET_SIG_IGN;
5262     } else {
5263         sa = &sigact_table[sig - 1];
5264         handler = sa->_sa_handler;
5265     }
5266
5267     if (handler == TARGET_SIG_DFL) {
5268         /* default handler : ignore some signal. The other are job control or fatal */
5269         if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
5270             kill(getpid(),SIGSTOP);
5271         } else if (sig != TARGET_SIGCHLD &&
5272                    sig != TARGET_SIGURG &&
5273                    sig != TARGET_SIGWINCH &&
5274                    sig != TARGET_SIGCONT) {
5275             force_sig(sig);
5276         }
5277     } else if (handler == TARGET_SIG_IGN) {
5278         /* ignore sig */
5279     } else if (handler == TARGET_SIG_ERR) {
5280         force_sig(sig);
5281     } else {
5282         /* compute the blocked signals during the handler execution */
5283         target_to_host_sigset(&set, &sa->sa_mask);
5284         /* SA_NODEFER indicates that the current signal should not be
5285            blocked during the handler */
5286         if (!(sa->sa_flags & TARGET_SA_NODEFER))
5287             sigaddset(&set, target_to_host_signal(sig));
5288
5289         /* block signals in the handler using Linux */
5290         sigprocmask(SIG_BLOCK, &set, &old_set);
5291         /* save the previous blocked signal state to restore it at the
5292            end of the signal execution (see do_sigreturn) */
5293         host_to_target_sigset_internal(&target_old_set, &old_set);
5294
5295         /* if the CPU is in VM86 mode, we restore the 32 bit values */
5296 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
5297         {
5298             CPUX86State *env = cpu_env;
5299             if (env->eflags & VM_MASK)
5300                 save_v86_state(env);
5301         }
5302 #endif
5303         /* prepare the stack frame of the virtual CPU */
5304         if (sa->sa_flags & TARGET_SA_SIGINFO)
5305             setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
5306         else
5307             setup_frame(sig, sa, &target_old_set, cpu_env);
5308         if (sa->sa_flags & TARGET_SA_RESETHAND)
5309             sa->_sa_handler = TARGET_SIG_DFL;
5310     }
5311     if (q != &k->info)
5312         free_sigqueue(cpu_env, q);
5313 }
This page took 0.336686 seconds and 4 git commands to generate.