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 "qemu/osdep.h"
  20 #include "qemu/bitops.h"
  21 #include <sys/ucontext.h>
  22 #include <sys/resource.h>
  23
  24 #include "qemu.h"
  25 #include "qemu-common.h"
  26 #include "target_signal.h"
  27 #include "trace.h"
  28
  29 static struct target_sigaltstack target_sigaltstack_used = {
  30     .ss_sp = 0,
  31     .ss_size = 0,
  32     .ss_flags = TARGET_SS_DISABLE,
  33 };
  34
  35 static struct target_sigaction sigact_table[TARGET_NSIG];
  36
  37 static void host_signal_handler(int host_signum, siginfo_t *info,
  38                                 void *puc);
  39
  40 static uint8_t host_to_target_signal_table[_NSIG] = {
  41     [SIGHUP] = TARGET_SIGHUP,
  42     [SIGINT] = TARGET_SIGINT,
  43     [SIGQUIT] = TARGET_SIGQUIT,
  44     [SIGILL] = TARGET_SIGILL,
  45     [SIGTRAP] = TARGET_SIGTRAP,
  46     [SIGABRT] = TARGET_SIGABRT,
  47 /*    [SIGIOT] = TARGET_SIGIOT,*/
  48     [SIGBUS] = TARGET_SIGBUS,
  49     [SIGFPE] = TARGET_SIGFPE,
  50     [SIGKILL] = TARGET_SIGKILL,
  51     [SIGUSR1] = TARGET_SIGUSR1,
  52     [SIGSEGV] = TARGET_SIGSEGV,
  53     [SIGUSR2] = TARGET_SIGUSR2,
  54     [SIGPIPE] = TARGET_SIGPIPE,
  55     [SIGALRM] = TARGET_SIGALRM,
  56     [SIGTERM] = TARGET_SIGTERM,
  57 #ifdef SIGSTKFLT
  58     [SIGSTKFLT] = TARGET_SIGSTKFLT,
  59 #endif
  60     [SIGCHLD] = TARGET_SIGCHLD,
  61     [SIGCONT] = TARGET_SIGCONT,
  62     [SIGSTOP] = TARGET_SIGSTOP,
  63     [SIGTSTP] = TARGET_SIGTSTP,
  64     [SIGTTIN] = TARGET_SIGTTIN,
  65     [SIGTTOU] = TARGET_SIGTTOU,
  66     [SIGURG] = TARGET_SIGURG,
  67     [SIGXCPU] = TARGET_SIGXCPU,
  68     [SIGXFSZ] = TARGET_SIGXFSZ,
  69     [SIGVTALRM] = TARGET_SIGVTALRM,
  70     [SIGPROF] = TARGET_SIGPROF,
  71     [SIGWINCH] = TARGET_SIGWINCH,
  72     [SIGIO] = TARGET_SIGIO,
  73     [SIGPWR] = TARGET_SIGPWR,
  74     [SIGSYS] = TARGET_SIGSYS,
  75     /* next signals stay the same */
  76     /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with
  77        host libpthread signals.  This assumes no one actually uses SIGRTMAX :-/
  78        To fix this properly we need to do manual signal delivery multiplexed
  79        over a single host signal.  */
  80     [__SIGRTMIN] = __SIGRTMAX,
  81     [__SIGRTMAX] = __SIGRTMIN,
  82 };
  83 static uint8_t target_to_host_signal_table[_NSIG];
  84
  85 static inline int on_sig_stack(unsigned long sp)
  86 {
  87     return (sp - target_sigaltstack_used.ss_sp
  88             < target_sigaltstack_used.ss_size);
  89 }
  90
  91 static inline int sas_ss_flags(unsigned long sp)
  92 {
  93     return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE
  94             : on_sig_stack(sp) ? SS_ONSTACK : 0);
  95 }
  96
  97 int host_to_target_signal(int sig)
  98 {
  99     if (sig < 0 || sig >= _NSIG)
 100         return sig;
 101     return host_to_target_signal_table[sig];
 102 }
 103
 104 int target_to_host_signal(int sig)
 105 {
 106     if (sig < 0 || sig >= _NSIG)
 107         return sig;
 108     return target_to_host_signal_table[sig];
 109 }
 110
 111 static inline void target_sigemptyset(target_sigset_t *set)
 112 {
 113     memset(set, 0, sizeof(*set));
 114 }
 115
 116 static inline void target_sigaddset(target_sigset_t *set, int signum)
 117 {
 118     signum--;
 119     abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
 120     set->sig[signum / TARGET_NSIG_BPW] |= mask;
 121 }
 122
 123 static inline int target_sigismember(const target_sigset_t *set, int signum)
 124 {
 125     signum--;
 126     abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
 127     return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0);
 128 }
 129
 130 static void host_to_target_sigset_internal(target_sigset_t *d,
 131                                            const sigset_t *s)
 132 {
 133     int i;
 134     target_sigemptyset(d);
 135     for (i = 1; i <= TARGET_NSIG; i++) {
 136         if (sigismember(s, i)) {
 137             target_sigaddset(d, host_to_target_signal(i));
 138         }
 139     }
 140 }
 141
 142 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
 143 {
 144     target_sigset_t d1;
 145     int i;
 146
 147     host_to_target_sigset_internal(&d1, s);
 148     for(i = 0;i < TARGET_NSIG_WORDS; i++)
 149         d->sig[i] = tswapal(d1.sig[i]);
 150 }
 151
 152 static void target_to_host_sigset_internal(sigset_t *d,
 153                                            const target_sigset_t *s)
 154 {
 155     int i;
 156     sigemptyset(d);
 157     for (i = 1; i <= TARGET_NSIG; i++) {
 158         if (target_sigismember(s, i)) {
 159             sigaddset(d, target_to_host_signal(i));
 160         }
 161     }
 162 }
 163
 164 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
 165 {
 166     target_sigset_t s1;
 167     int i;
 168
 169     for(i = 0;i < TARGET_NSIG_WORDS; i++)
 170         s1.sig[i] = tswapal(s->sig[i]);
 171     target_to_host_sigset_internal(d, &s1);
 172 }
 173
 174 void host_to_target_old_sigset(abi_ulong *old_sigset,
 175                                const sigset_t *sigset)
 176 {
 177     target_sigset_t d;
 178     host_to_target_sigset(&d, sigset);
 179     *old_sigset = d.sig[0];
 180 }
 181
 182 void target_to_host_old_sigset(sigset_t *sigset,
 183                                const abi_ulong *old_sigset)
 184 {
 185     target_sigset_t d;
 186     int i;
 187
 188     d.sig[0] = *old_sigset;
 189     for(i = 1;i < TARGET_NSIG_WORDS; i++)
 190         d.sig[i] = 0;
 191     target_to_host_sigset(sigset, &d);
 192 }
 193
 194 int block_signals(void)
 195 {
 196     TaskState *ts = (TaskState *)thread_cpu->opaque;
 197     sigset_t set;
 198
 199     /* It's OK to block everything including SIGSEGV, because we won't
 200      * run any further guest code before unblocking signals in
 201      * process_pending_signals().
 202      */
 203     sigfillset(&set);
 204     sigprocmask(SIG_SETMASK, &set, 0);
 205
 206     return atomic_xchg(&ts->signal_pending, 1);
 207 }
 208
 209 /* Wrapper for sigprocmask function
 210  * Emulates a sigprocmask in a safe way for the guest. Note that set and oldset
 211  * are host signal set, not guest ones. Returns -TARGET_ERESTARTSYS if
 212  * a signal was already pending and the syscall must be restarted, or
 213  * 0 on success.
 214  * If set is NULL, this is guaranteed not to fail.
 215  */
 216 int do_sigprocmask(int how, const sigset_t *set, sigset_t *oldset)
 217 {
 218     TaskState *ts = (TaskState *)thread_cpu->opaque;
 219
 220     if (oldset) {
 221         *oldset = ts->signal_mask;
 222     }
 223
 224     if (set) {
 225         int i;
 226
 227         if (block_signals()) {
 228             return -TARGET_ERESTARTSYS;
 229         }
 230
 231         switch (how) {
 232         case SIG_BLOCK:
 233             sigorset(&ts->signal_mask, &ts->signal_mask, set);
 234             break;
 235         case SIG_UNBLOCK:
 236             for (i = 1; i <= NSIG; ++i) {
 237                 if (sigismember(set, i)) {
 238                     sigdelset(&ts->signal_mask, i);
 239                 }
 240             }
 241             break;
 242         case SIG_SETMASK:
 243             ts->signal_mask = *set;
 244             break;
 245         default:
 246             g_assert_not_reached();
 247         }
 248
 249         /* Silently ignore attempts to change blocking status of KILL or STOP */
 250         sigdelset(&ts->signal_mask, SIGKILL);
 251         sigdelset(&ts->signal_mask, SIGSTOP);
 252     }
 253     return 0;
 254 }
 255
 256 #if !defined(TARGET_OPENRISC) && !defined(TARGET_UNICORE32) && \
 257     !defined(TARGET_NIOS2)
 258 /* Just set the guest's signal mask to the specified value; the
 259  * caller is assumed to have called block_signals() already.
 260  */
 261 static void set_sigmask(const sigset_t *set)
 262 {
 263     TaskState *ts = (TaskState *)thread_cpu->opaque;
 264
 265     ts->signal_mask = *set;
 266 }
 267 #endif
 268
 269 /* siginfo conversion */
 270
 271 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
 272                                                  const siginfo_t *info)
 273 {
 274     int sig = host_to_target_signal(info->si_signo);
 275     int si_code = info->si_code;
 276     int si_type;
 277     tinfo->si_signo = sig;
 278     tinfo->si_errno = 0;
 279     tinfo->si_code = info->si_code;
 280
 281     /* This memset serves two purposes:
 282      * (1) ensure we don't leak random junk to the guest later
 283      * (2) placate false positives from gcc about fields
 284      *     being used uninitialized if it chooses to inline both this
 285      *     function and tswap_siginfo() into host_to_target_siginfo().
 286      */
 287     memset(tinfo->_sifields._pad, 0, sizeof(tinfo->_sifields._pad));
 288
 289     /* This is awkward, because we have to use a combination of
 290      * the si_code and si_signo to figure out which of the union's
 291      * members are valid. (Within the host kernel it is always possible
 292      * to tell, but the kernel carefully avoids giving userspace the
 293      * high 16 bits of si_code, so we don't have the information to
 294      * do this the easy way...) We therefore make our best guess,
 295      * bearing in mind that a guest can spoof most of the si_codes
 296      * via rt_sigqueueinfo() if it likes.
 297      *
 298      * Once we have made our guess, we record it in the top 16 bits of
 299      * the si_code, so that tswap_siginfo() later can use it.
 300      * tswap_siginfo() will strip these top bits out before writing
 301      * si_code to the guest (sign-extending the lower bits).
 302      */
 303
 304     switch (si_code) {
 305     case SI_USER:
 306     case SI_TKILL:
 307     case SI_KERNEL:
 308         /* Sent via kill(), tkill() or tgkill(), or direct from the kernel.
 309          * These are the only unspoofable si_code values.
 310          */
 311         tinfo->_sifields._kill._pid = info->si_pid;
 312         tinfo->_sifields._kill._uid = info->si_uid;
 313         si_type = QEMU_SI_KILL;
 314         break;
 315     default:
 316         /* Everything else is spoofable. Make best guess based on signal */
 317         switch (sig) {
 318         case TARGET_SIGCHLD:
 319             tinfo->_sifields._sigchld._pid = info->si_pid;
 320             tinfo->_sifields._sigchld._uid = info->si_uid;
 321             tinfo->_sifields._sigchld._status
 322                 = host_to_target_waitstatus(info->si_status);
 323             tinfo->_sifields._sigchld._utime = info->si_utime;
 324             tinfo->_sifields._sigchld._stime = info->si_stime;
 325             si_type = QEMU_SI_CHLD;
 326             break;
 327         case TARGET_SIGIO:
 328             tinfo->_sifields._sigpoll._band = info->si_band;
 329             tinfo->_sifields._sigpoll._fd = info->si_fd;
 330             si_type = QEMU_SI_POLL;
 331             break;
 332         default:
 333             /* Assume a sigqueue()/mq_notify()/rt_sigqueueinfo() source. */
 334             tinfo->_sifields._rt._pid = info->si_pid;
 335             tinfo->_sifields._rt._uid = info->si_uid;
 336             /* XXX: potential problem if 64 bit */
 337             tinfo->_sifields._rt._sigval.sival_ptr
 338                 = (abi_ulong)(unsigned long)info->si_value.sival_ptr;
 339             si_type = QEMU_SI_RT;
 340             break;
 341         }
 342         break;
 343     }
 344
 345     tinfo->si_code = deposit32(si_code, 16, 16, si_type);
 346 }
 347
 348 static void tswap_siginfo(target_siginfo_t *tinfo,
 349                           const target_siginfo_t *info)
 350 {
 351     int si_type = extract32(info->si_code, 16, 16);
 352     int si_code = sextract32(info->si_code, 0, 16);
 353
 354     __put_user(info->si_signo, &tinfo->si_signo);
 355     __put_user(info->si_errno, &tinfo->si_errno);
 356     __put_user(si_code, &tinfo->si_code);
 357
 358     /* We can use our internal marker of which fields in the structure
 359      * are valid, rather than duplicating the guesswork of
 360      * host_to_target_siginfo_noswap() here.
 361      */
 362     switch (si_type) {
 363     case QEMU_SI_KILL:
 364         __put_user(info->_sifields._kill._pid, &tinfo->_sifields._kill._pid);
 365         __put_user(info->_sifields._kill._uid, &tinfo->_sifields._kill._uid);
 366         break;
 367     case QEMU_SI_TIMER:
 368         __put_user(info->_sifields._timer._timer1,
 369                    &tinfo->_sifields._timer._timer1);
 370         __put_user(info->_sifields._timer._timer2,
 371                    &tinfo->_sifields._timer._timer2);
 372         break;
 373     case QEMU_SI_POLL:
 374         __put_user(info->_sifields._sigpoll._band,
 375                    &tinfo->_sifields._sigpoll._band);
 376         __put_user(info->_sifields._sigpoll._fd,
 377                    &tinfo->_sifields._sigpoll._fd);
 378         break;
 379     case QEMU_SI_FAULT:
 380         __put_user(info->_sifields._sigfault._addr,
 381                    &tinfo->_sifields._sigfault._addr);
 382         break;
 383     case QEMU_SI_CHLD:
 384         __put_user(info->_sifields._sigchld._pid,
 385                    &tinfo->_sifields._sigchld._pid);
 386         __put_user(info->_sifields._sigchld._uid,
 387                    &tinfo->_sifields._sigchld._uid);
 388         __put_user(info->_sifields._sigchld._status,
 389                    &tinfo->_sifields._sigchld._status);
 390         __put_user(info->_sifields._sigchld._utime,
 391                    &tinfo->_sifields._sigchld._utime);
 392         __put_user(info->_sifields._sigchld._stime,
 393                    &tinfo->_sifields._sigchld._stime);
 394         break;
 395     case QEMU_SI_RT:
 396         __put_user(info->_sifields._rt._pid, &tinfo->_sifields._rt._pid);
 397         __put_user(info->_sifields._rt._uid, &tinfo->_sifields._rt._uid);
 398         __put_user(info->_sifields._rt._sigval.sival_ptr,
 399                    &tinfo->_sifields._rt._sigval.sival_ptr);
 400         break;
 401     default:
 402         g_assert_not_reached();
 403     }
 404 }
 405
 406 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
 407 {
 408     target_siginfo_t tgt_tmp;
 409     host_to_target_siginfo_noswap(&tgt_tmp, info);
 410     tswap_siginfo(tinfo, &tgt_tmp);
 411 }
 412
 413 /* XXX: we support only POSIX RT signals are used. */
 414 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
 415 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
 416 {
 417     /* This conversion is used only for the rt_sigqueueinfo syscall,
 418      * and so we know that the _rt fields are the valid ones.
 419      */
 420     abi_ulong sival_ptr;
 421
 422     __get_user(info->si_signo, &tinfo->si_signo);
 423     __get_user(info->si_errno, &tinfo->si_errno);
 424     __get_user(info->si_code, &tinfo->si_code);
 425     __get_user(info->si_pid, &tinfo->_sifields._rt._pid);
 426     __get_user(info->si_uid, &tinfo->_sifields._rt._uid);
 427     __get_user(sival_ptr, &tinfo->_sifields._rt._sigval.sival_ptr);
 428     info->si_value.sival_ptr = (void *)(long)sival_ptr;
 429 }
 430
 431 static int fatal_signal (int sig)
 432 {
 433     switch (sig) {
 434     case TARGET_SIGCHLD:
 435     case TARGET_SIGURG:
 436     case TARGET_SIGWINCH:
 437         /* Ignored by default.  */
 438         return 0;
 439     case TARGET_SIGCONT:
 440     case TARGET_SIGSTOP:
 441     case TARGET_SIGTSTP:
 442     case TARGET_SIGTTIN:
 443     case TARGET_SIGTTOU:
 444         /* Job control signals.  */
 445         return 0;
 446     default:
 447         return 1;
 448     }
 449 }
 450
 451 /* returns 1 if given signal should dump core if not handled */
 452 static int core_dump_signal(int sig)
 453 {
 454     switch (sig) {
 455     case TARGET_SIGABRT:
 456     case TARGET_SIGFPE:
 457     case TARGET_SIGILL:
 458     case TARGET_SIGQUIT:
 459     case TARGET_SIGSEGV:
 460     case TARGET_SIGTRAP:
 461     case TARGET_SIGBUS:
 462         return (1);
 463     default:
 464         return (0);
 465     }
 466 }
 467
 468 void signal_init(void)
 469 {
 470     TaskState *ts = (TaskState *)thread_cpu->opaque;
 471     struct sigaction act;
 472     struct sigaction oact;
 473     int i, j;
 474     int host_sig;
 475
 476     /* generate signal conversion tables */
 477     for(i = 1; i < _NSIG; i++) {
 478         if (host_to_target_signal_table[i] == 0)
 479             host_to_target_signal_table[i] = i;
 480     }
 481     for(i = 1; i < _NSIG; i++) {
 482         j = host_to_target_signal_table[i];
 483         target_to_host_signal_table[j] = i;
 484     }
 485
 486     /* Set the signal mask from the host mask. */
 487     sigprocmask(0, 0, &ts->signal_mask);
 488
 489     /* set all host signal handlers. ALL signals are blocked during
 490        the handlers to serialize them. */
 491     memset(sigact_table, 0, sizeof(sigact_table));
 492
 493     sigfillset(&act.sa_mask);
 494     act.sa_flags = SA_SIGINFO;
 495     act.sa_sigaction = host_signal_handler;
 496     for(i = 1; i <= TARGET_NSIG; i++) {
 497         host_sig = target_to_host_signal(i);
 498         sigaction(host_sig, NULL, &oact);
 499         if (oact.sa_sigaction == (void *)SIG_IGN) {
 500             sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;
 501         } else if (oact.sa_sigaction == (void *)SIG_DFL) {
 502             sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;
 503         }
 504         /* If there's already a handler installed then something has
 505            gone horribly wrong, so don't even try to handle that case.  */
 506         /* Install some handlers for our own use.  We need at least
 507            SIGSEGV and SIGBUS, to detect exceptions.  We can not just
 508            trap all signals because it affects syscall interrupt
 509            behavior.  But do trap all default-fatal signals.  */
 510         if (fatal_signal (i))
 511             sigaction(host_sig, &act, NULL);
 512     }
 513 }
 514
 515 #ifndef TARGET_UNICORE32
 516 /* Force a synchronously taken signal. The kernel force_sig() function
 517  * also forces the signal to "not blocked, not ignored", but for QEMU
 518  * that work is done in process_pending_signals().
 519  */
 520 static void force_sig(int sig)
 521 {
 522     CPUState *cpu = thread_cpu;
 523     CPUArchState *env = cpu->env_ptr;
 524     target_siginfo_t info;
 525
 526     info.si_signo = sig;
 527     info.si_errno = 0;
 528     info.si_code = TARGET_SI_KERNEL;
 529     info._sifields._kill._pid = 0;
 530     info._sifields._kill._uid = 0;
 531     queue_signal(env, info.si_signo, QEMU_SI_KILL, &info);
 532 }
 533
 534 /* Force a SIGSEGV if we couldn't write to memory trying to set
 535  * up the signal frame. oldsig is the signal we were trying to handle
 536  * at the point of failure.
 537  */
 538 #if !defined(TARGET_RISCV)
 539 static void force_sigsegv(int oldsig)
 540 {
 541     if (oldsig == SIGSEGV) {
 542         /* Make sure we don't try to deliver the signal again; this will
 543          * end up with handle_pending_signal() calling dump_core_and_abort().
 544          */
 545         sigact_table[oldsig - 1]._sa_handler = TARGET_SIG_DFL;
 546     }
 547     force_sig(TARGET_SIGSEGV);
 548 }
 549 #endif
 550
 551 #endif
 552
 553 /* abort execution with signal */
 554 static void QEMU_NORETURN dump_core_and_abort(int target_sig)
 555 {
 556     CPUState *cpu = thread_cpu;
 557     CPUArchState *env = cpu->env_ptr;
 558     TaskState *ts = (TaskState *)cpu->opaque;
 559     int host_sig, core_dumped = 0;
 560     struct sigaction act;
 561
 562     host_sig = target_to_host_signal(target_sig);
 563     trace_user_force_sig(env, target_sig, host_sig);
 564     gdb_signalled(env, target_sig);
 565
 566     /* dump core if supported by target binary format */
 567     if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) {
 568         stop_all_tasks();
 569         core_dumped =
 570             ((*ts->bprm->core_dump)(target_sig, env) == 0);
 571     }
 572     if (core_dumped) {
 573         /* we already dumped the core of target process, we don't want
 574          * a coredump of qemu itself */
 575         struct rlimit nodump;
 576         getrlimit(RLIMIT_CORE, &nodump);
 577         nodump.rlim_cur=0;
 578         setrlimit(RLIMIT_CORE, &nodump);
 579         (void) fprintf(stderr, "qemu: uncaught target signal %d (%s) - %s\n",
 580             target_sig, strsignal(host_sig), "core dumped" );
 581     }
 582
 583     /* The proper exit code for dying from an uncaught signal is
 584      * -<signal>.  The kernel doesn't allow exit() or _exit() to pass
 585      * a negative value.  To get the proper exit code we need to
 586      * actually die from an uncaught signal.  Here the default signal
 587      * handler is installed, we send ourself a signal and we wait for
 588      * it to arrive. */
 589     sigfillset(&act.sa_mask);
 590     act.sa_handler = SIG_DFL;
 591     act.sa_flags = 0;
 592     sigaction(host_sig, &act, NULL);
 593
 594     /* For some reason raise(host_sig) doesn't send the signal when
 595      * statically linked on x86-64. */
 596     kill(getpid(), host_sig);
 597
 598     /* Make sure the signal isn't masked (just reuse the mask inside
 599     of act) */
 600     sigdelset(&act.sa_mask, host_sig);
 601     sigsuspend(&act.sa_mask);
 602
 603     /* unreachable */
 604     abort();
 605 }
 606
 607 /* queue a signal so that it will be send to the virtual CPU as soon
 608    as possible */
 609 int queue_signal(CPUArchState *env, int sig, int si_type,
 610                  target_siginfo_t *info)
 611 {
 612     CPUState *cpu = ENV_GET_CPU(env);
 613     TaskState *ts = cpu->opaque;
 614
 615     trace_user_queue_signal(env, sig);
 616
 617     info->si_code = deposit32(info->si_code, 16, 16, si_type);
 618
 619     ts->sync_signal.info = *info;
 620     ts->sync_signal.pending = sig;
 621     /* signal that a new signal is pending */
 622     atomic_set(&ts->signal_pending, 1);
 623     return 1; /* indicates that the signal was queued */
 624 }
 625
 626 #ifndef HAVE_SAFE_SYSCALL
 627 static inline void rewind_if_in_safe_syscall(void *puc)
 628 {
 629     /* Default version: never rewind */
 630 }
 631 #endif
 632
 633 static void host_signal_handler(int host_signum, siginfo_t *info,
 634                                 void *puc)
 635 {
 636     CPUArchState *env = thread_cpu->env_ptr;
 637     CPUState *cpu = ENV_GET_CPU(env);
 638     TaskState *ts = cpu->opaque;
 639
 640     int sig;
 641     target_siginfo_t tinfo;
 642     ucontext_t *uc = puc;
 643     struct emulated_sigtable *k;
 644
 645     /* the CPU emulator uses some host signals to detect exceptions,
 646        we forward to it some signals */
 647     if ((host_signum == SIGSEGV || host_signum == SIGBUS)
 648         && info->si_code > 0) {
 649         if (cpu_signal_handler(host_signum, info, puc))
 650             return;
 651     }
 652
 653     /* get target signal number */
 654     sig = host_to_target_signal(host_signum);
 655     if (sig < 1 || sig > TARGET_NSIG)
 656         return;
 657     trace_user_host_signal(env, host_signum, sig);
 658
 659     rewind_if_in_safe_syscall(puc);
 660
 661     host_to_target_siginfo_noswap(&tinfo, info);
 662     k = &ts->sigtab[sig - 1];
 663     k->info = tinfo;
 664     k->pending = sig;
 665     ts->signal_pending = 1;
 666
 667     /* Block host signals until target signal handler entered. We
 668      * can't block SIGSEGV or SIGBUS while we're executing guest
 669      * code in case the guest code provokes one in the window between
 670      * now and it getting out to the main loop. Signals will be
 671      * unblocked again in process_pending_signals().
 672      *
 673      * WARNING: we cannot use sigfillset() here because the uc_sigmask
 674      * field is a kernel sigset_t, which is much smaller than the
 675      * libc sigset_t which sigfillset() operates on. Using sigfillset()
 676      * would write 0xff bytes off the end of the structure and trash
 677      * data on the struct.
 678      * We can't use sizeof(uc->uc_sigmask) either, because the libc
 679      * headers define the struct field with the wrong (too large) type.
 680      */
 681     memset(&uc->uc_sigmask, 0xff, SIGSET_T_SIZE);
 682     sigdelset(&uc->uc_sigmask, SIGSEGV);
 683     sigdelset(&uc->uc_sigmask, SIGBUS);
 684
 685     /* interrupt the virtual CPU as soon as possible */
 686     cpu_exit(thread_cpu);
 687 }
 688
 689 /* do_sigaltstack() returns target values and errnos. */
 690 /* compare linux/kernel/signal.c:do_sigaltstack() */
 691 abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp)
 692 {
 693     int ret;
 694     struct target_sigaltstack oss;
 695
 696     /* XXX: test errors */
 697     if(uoss_addr)
 698     {
 699         __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp);
 700         __put_user(target_sigaltstack_used.ss_size, &oss.ss_size);
 701         __put_user(sas_ss_flags(sp), &oss.ss_flags);
 702     }
 703
 704     if(uss_addr)
 705     {
 706         struct target_sigaltstack *uss;
 707         struct target_sigaltstack ss;
 708         size_t minstacksize = TARGET_MINSIGSTKSZ;
 709
 710 #if defined(TARGET_PPC64)
 711         /* ELF V2 for PPC64 has a 4K minimum stack size for signal handlers */
 712         struct image_info *image = ((TaskState *)thread_cpu->opaque)->info;
 713         if (get_ppc64_abi(image) > 1) {
 714             minstacksize = 4096;
 715         }
 716 #endif
 717
 718         ret = -TARGET_EFAULT;
 719         if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)) {
 720             goto out;
 721         }
 722         __get_user(ss.ss_sp, &uss->ss_sp);
 723         __get_user(ss.ss_size, &uss->ss_size);
 724         __get_user(ss.ss_flags, &uss->ss_flags);
 725         unlock_user_struct(uss, uss_addr, 0);
 726
 727         ret = -TARGET_EPERM;
 728         if (on_sig_stack(sp))
 729             goto out;
 730
 731         ret = -TARGET_EINVAL;
 732         if (ss.ss_flags != TARGET_SS_DISABLE
 733             && ss.ss_flags != TARGET_SS_ONSTACK
 734             && ss.ss_flags != 0)
 735             goto out;
 736
 737         if (ss.ss_flags == TARGET_SS_DISABLE) {
 738             ss.ss_size = 0;
 739             ss.ss_sp = 0;
 740         } else {
 741             ret = -TARGET_ENOMEM;
 742             if (ss.ss_size < minstacksize) {
 743                 goto out;
 744             }
 745         }
 746
 747         target_sigaltstack_used.ss_sp = ss.ss_sp;
 748         target_sigaltstack_used.ss_size = ss.ss_size;
 749     }
 750
 751     if (uoss_addr) {
 752         ret = -TARGET_EFAULT;
 753         if (copy_to_user(uoss_addr, &oss, sizeof(oss)))
 754             goto out;
 755     }
 756
 757     ret = 0;
 758 out:
 759     return ret;
 760 }
 761
 762 /* do_sigaction() return target values and host errnos */
 763 int do_sigaction(int sig, const struct target_sigaction *act,
 764                  struct target_sigaction *oact)
 765 {
 766     struct target_sigaction *k;
 767     struct sigaction act1;
 768     int host_sig;
 769     int ret = 0;
 770
 771     if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP) {
 772         return -TARGET_EINVAL;
 773     }
 774
 775     if (block_signals()) {
 776         return -TARGET_ERESTARTSYS;
 777     }
 778
 779     k = &sigact_table[sig - 1];
 780     if (oact) {
 781         __put_user(k->_sa_handler, &oact->_sa_handler);
 782         __put_user(k->sa_flags, &oact->sa_flags);
 783 #ifdef TARGET_ARCH_HAS_SA_RESTORER
 784         __put_user(k->sa_restorer, &oact->sa_restorer);
 785 #endif
 786         /* Not swapped.  */
 787         oact->sa_mask = k->sa_mask;
 788     }
 789     if (act) {
 790         /* FIXME: This is not threadsafe.  */
 791         __get_user(k->_sa_handler, &act->_sa_handler);
 792         __get_user(k->sa_flags, &act->sa_flags);
 793 #ifdef TARGET_ARCH_HAS_SA_RESTORER
 794         __get_user(k->sa_restorer, &act->sa_restorer);
 795 #endif
 796         /* To be swapped in target_to_host_sigset.  */
 797         k->sa_mask = act->sa_mask;
 798
 799         /* we update the host linux signal state */
 800         host_sig = target_to_host_signal(sig);
 801         if (host_sig != SIGSEGV && host_sig != SIGBUS) {
 802             sigfillset(&act1.sa_mask);
 803             act1.sa_flags = SA_SIGINFO;
 804             if (k->sa_flags & TARGET_SA_RESTART)
 805                 act1.sa_flags |= SA_RESTART;
 806             /* NOTE: it is important to update the host kernel signal
 807                ignore state to avoid getting unexpected interrupted
 808                syscalls */
 809             if (k->_sa_handler == TARGET_SIG_IGN) {
 810                 act1.sa_sigaction = (void *)SIG_IGN;
 811             } else if (k->_sa_handler == TARGET_SIG_DFL) {
 812                 if (fatal_signal (sig))
 813                     act1.sa_sigaction = host_signal_handler;
 814                 else
 815                     act1.sa_sigaction = (void *)SIG_DFL;
 816             } else {
 817                 act1.sa_sigaction = host_signal_handler;
 818             }
 819             ret = sigaction(host_sig, &act1, NULL);
 820         }
 821     }
 822     return ret;
 823 }
 824
 825 #if defined(TARGET_I386)
 826 /* from the Linux kernel - /arch/x86/include/uapi/asm/sigcontext.h */
 827
 828 struct target_fpreg {
 829     uint16_t significand[4];
 830     uint16_t exponent;
 831 };
 832
 833 struct target_fpxreg {
 834     uint16_t significand[4];
 835     uint16_t exponent;
 836     uint16_t padding[3];
 837 };
 838
 839 struct target_xmmreg {
 840     uint32_t element[4];
 841 };
 842
 843 struct target_fpstate_32 {
 844     /* Regular FPU environment */
 845     uint32_t cw;
 846     uint32_t sw;
 847     uint32_t tag;
 848     uint32_t ipoff;
 849     uint32_t cssel;
 850     uint32_t dataoff;
 851     uint32_t datasel;
 852     struct target_fpreg st[8];
 853     uint16_t  status;
 854     uint16_t  magic;          /* 0xffff = regular FPU data only */
 855
 856     /* FXSR FPU environment */
 857     uint32_t _fxsr_env[6];   /* FXSR FPU env is ignored */
 858     uint32_t mxcsr;
 859     uint32_t reserved;
 860     struct target_fpxreg fxsr_st[8]; /* FXSR FPU reg data is ignored */
 861     struct target_xmmreg xmm[8];
 862     uint32_t padding[56];
 863 };
 864
 865 struct target_fpstate_64 {
 866     /* FXSAVE format */
 867     uint16_t cw;
 868     uint16_t sw;
 869     uint16_t twd;
 870     uint16_t fop;
 871     uint64_t rip;
 872     uint64_t rdp;
 873     uint32_t mxcsr;
 874     uint32_t mxcsr_mask;
 875     uint32_t st_space[32];
 876     uint32_t xmm_space[64];
 877     uint32_t reserved[24];
 878 };
 879
 880 #ifndef TARGET_X86_64
 881 # define target_fpstate target_fpstate_32
 882 #else
 883 # define target_fpstate target_fpstate_64
 884 #endif
 885
 886 struct target_sigcontext_32 {
 887     uint16_t gs, __gsh;
 888     uint16_t fs, __fsh;
 889     uint16_t es, __esh;
 890     uint16_t ds, __dsh;
 891     uint32_t edi;
 892     uint32_t esi;
 893     uint32_t ebp;
 894     uint32_t esp;
 895     uint32_t ebx;
 896     uint32_t edx;
 897     uint32_t ecx;
 898     uint32_t eax;
 899     uint32_t trapno;
 900     uint32_t err;
 901     uint32_t eip;
 902     uint16_t cs, __csh;
 903     uint32_t eflags;
 904     uint32_t esp_at_signal;
 905     uint16_t ss, __ssh;
 906     uint32_t fpstate; /* pointer */
 907     uint32_t oldmask;
 908     uint32_t cr2;
 909 };
 910
 911 struct target_sigcontext_64 {
 912     uint64_t r8;
 913     uint64_t r9;
 914     uint64_t r10;
 915     uint64_t r11;
 916     uint64_t r12;
 917     uint64_t r13;
 918     uint64_t r14;
 919     uint64_t r15;
 920
 921     uint64_t rdi;
 922     uint64_t rsi;
 923     uint64_t rbp;
 924     uint64_t rbx;
 925     uint64_t rdx;
 926     uint64_t rax;
 927     uint64_t rcx;
 928     uint64_t rsp;
 929     uint64_t rip;
 930
 931     uint64_t eflags;
 932
 933     uint16_t cs;
 934     uint16_t gs;
 935     uint16_t fs;
 936     uint16_t ss;
 937
 938     uint64_t err;
 939     uint64_t trapno;
 940     uint64_t oldmask;
 941     uint64_t cr2;
 942
 943     uint64_t fpstate; /* pointer */
 944     uint64_t padding[8];
 945 };
 946
 947 #ifndef TARGET_X86_64
 948 # define target_sigcontext target_sigcontext_32
 949 #else
 950 # define target_sigcontext target_sigcontext_64
 951 #endif
 952
 953 /* see Linux/include/uapi/asm-generic/ucontext.h */
 954 struct target_ucontext {
 955     abi_ulong         tuc_flags;
 956     abi_ulong         tuc_link;
 957     target_stack_t    tuc_stack;
 958     struct target_sigcontext tuc_mcontext;
 959     target_sigset_t   tuc_sigmask;  /* mask last for extensibility */
 960 };
 961
 962 #ifndef TARGET_X86_64
 963 struct sigframe {
 964     abi_ulong pretcode;
 965     int sig;
 966     struct target_sigcontext sc;
 967     struct target_fpstate fpstate;
 968     abi_ulong extramask[TARGET_NSIG_WORDS-1];
 969     char retcode[8];
 970 };
 971
 972 struct rt_sigframe {
 973     abi_ulong pretcode;
 974     int sig;
 975     abi_ulong pinfo;
 976     abi_ulong puc;
 977     struct target_siginfo info;
 978     struct target_ucontext uc;
 979     struct target_fpstate fpstate;
 980     char retcode[8];
 981 };
 982
 983 #else
 984
 985 struct rt_sigframe {
 986     abi_ulong pretcode;
 987     struct target_ucontext uc;
 988     struct target_siginfo info;
 989     struct target_fpstate fpstate;
 990 };
 991
 992 #endif
 993
 994 /*
 995  * Set up a signal frame.
 996  */
 997
 998 /* XXX: save x87 state */
 999 static void setup_sigcontext(struct target_sigcontext *sc,
1000         struct target_fpstate *fpstate, CPUX86State *env, abi_ulong mask,
1001         abi_ulong fpstate_addr)
1002 {
1003     CPUState *cs = CPU(x86_env_get_cpu(env));
1004 #ifndef TARGET_X86_64
1005     uint16_t magic;
1006
1007     /* already locked in setup_frame() */
1008     __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
1009     __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
1010     __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
1011     __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
1012     __put_user(env->regs[R_EDI], &sc->edi);
1013     __put_user(env->regs[R_ESI], &sc->esi);
1014     __put_user(env->regs[R_EBP], &sc->ebp);
1015     __put_user(env->regs[R_ESP], &sc->esp);
1016     __put_user(env->regs[R_EBX], &sc->ebx);
1017     __put_user(env->regs[R_EDX], &sc->edx);
1018     __put_user(env->regs[R_ECX], &sc->ecx);
1019     __put_user(env->regs[R_EAX], &sc->eax);
1020     __put_user(cs->exception_index, &sc->trapno);
1021     __put_user(env->error_code, &sc->err);
1022     __put_user(env->eip, &sc->eip);
1023     __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
1024     __put_user(env->eflags, &sc->eflags);
1025     __put_user(env->regs[R_ESP], &sc->esp_at_signal);
1026     __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
1027
1028     cpu_x86_fsave(env, fpstate_addr, 1);
1029     fpstate->status = fpstate->sw;
1030     magic = 0xffff;
1031     __put_user(magic, &fpstate->magic);
1032     __put_user(fpstate_addr, &sc->fpstate);
1033
1034     /* non-iBCS2 extensions.. */
1035     __put_user(mask, &sc->oldmask);
1036     __put_user(env->cr[2], &sc->cr2);
1037 #else
1038     __put_user(env->regs[R_EDI], &sc->rdi);
1039     __put_user(env->regs[R_ESI], &sc->rsi);
1040     __put_user(env->regs[R_EBP], &sc->rbp);
1041     __put_user(env->regs[R_ESP], &sc->rsp);
1042     __put_user(env->regs[R_EBX], &sc->rbx);
1043     __put_user(env->regs[R_EDX], &sc->rdx);
1044     __put_user(env->regs[R_ECX], &sc->rcx);
1045     __put_user(env->regs[R_EAX], &sc->rax);
1046
1047     __put_user(env->regs[8], &sc->r8);
1048     __put_user(env->regs[9], &sc->r9);
1049     __put_user(env->regs[10], &sc->r10);
1050     __put_user(env->regs[11], &sc->r11);
1051     __put_user(env->regs[12], &sc->r12);
1052     __put_user(env->regs[13], &sc->r13);
1053     __put_user(env->regs[14], &sc->r14);
1054     __put_user(env->regs[15], &sc->r15);
1055
1056     __put_user(cs->exception_index, &sc->trapno);
1057     __put_user(env->error_code, &sc->err);
1058     __put_user(env->eip, &sc->rip);
1059
1060     __put_user(env->eflags, &sc->eflags);
1061     __put_user(env->segs[R_CS].selector, &sc->cs);
1062     __put_user((uint16_t)0, &sc->gs);
1063     __put_user((uint16_t)0, &sc->fs);
1064     __put_user(env->segs[R_SS].selector, &sc->ss);
1065
1066     __put_user(mask, &sc->oldmask);
1067     __put_user(env->cr[2], &sc->cr2);
1068
1069     /* fpstate_addr must be 16 byte aligned for fxsave */
1070     assert(!(fpstate_addr & 0xf));
1071
1072     cpu_x86_fxsave(env, fpstate_addr);
1073     __put_user(fpstate_addr, &sc->fpstate);
1074 #endif
1075 }
1076
1077 /*
1078  * Determine which stack to use..
1079  */
1080
1081 static inline abi_ulong
1082 get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size)
1083 {
1084     unsigned long esp;
1085
1086     /* Default to using normal stack */
1087     esp = env->regs[R_ESP];
1088 #ifdef TARGET_X86_64
1089     esp -= 128; /* this is the redzone */
1090 #endif
1091
1092     /* This is the X/Open sanctioned signal stack switching.  */
1093     if (ka->sa_flags & TARGET_SA_ONSTACK) {
1094         if (sas_ss_flags(esp) == 0) {
1095             esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1096         }
1097     } else {
1098 #ifndef TARGET_X86_64
1099         /* This is the legacy signal stack switching. */
1100         if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
1101                 !(ka->sa_flags & TARGET_SA_RESTORER) &&
1102                 ka->sa_restorer) {
1103             esp = (unsigned long) ka->sa_restorer;
1104         }
1105 #endif
1106     }
1107
1108 #ifndef TARGET_X86_64
1109     return (esp - frame_size) & -8ul;
1110 #else
1111     return ((esp - frame_size) & (~15ul)) - 8;
1112 #endif
1113 }
1114
1115 #ifndef TARGET_X86_64
1116 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */
1117 static void setup_frame(int sig, struct target_sigaction *ka,
1118                         target_sigset_t *set, CPUX86State *env)
1119 {
1120     abi_ulong frame_addr;
1121     struct sigframe *frame;
1122     int i;
1123
1124     frame_addr = get_sigframe(ka, env, sizeof(*frame));
1125     trace_user_setup_frame(env, frame_addr);
1126
1127     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1128         goto give_sigsegv;
1129
1130     __put_user(sig, &frame->sig);
1131
1132     setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0],
1133             frame_addr + offsetof(struct sigframe, fpstate));
1134
1135     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1136         __put_user(set->sig[i], &frame->extramask[i - 1]);
1137     }
1138
1139     /* Set up to return from userspace.  If provided, use a stub
1140        already in userspace.  */
1141     if (ka->sa_flags & TARGET_SA_RESTORER) {
1142         __put_user(ka->sa_restorer, &frame->pretcode);
1143     } else {
1144         uint16_t val16;
1145         abi_ulong retcode_addr;
1146         retcode_addr = frame_addr + offsetof(struct sigframe, retcode);
1147         __put_user(retcode_addr, &frame->pretcode);
1148         /* This is popl %eax ; movl $,%eax ; int $0x80 */
1149         val16 = 0xb858;
1150         __put_user(val16, (uint16_t *)(frame->retcode+0));
1151         __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
1152         val16 = 0x80cd;
1153         __put_user(val16, (uint16_t *)(frame->retcode+6));
1154     }
1155
1156     /* Set up registers for signal handler */
1157     env->regs[R_ESP] = frame_addr;
1158     env->eip = ka->_sa_handler;
1159
1160     cpu_x86_load_seg(env, R_DS, __USER_DS);
1161     cpu_x86_load_seg(env, R_ES, __USER_DS);
1162     cpu_x86_load_seg(env, R_SS, __USER_DS);
1163     cpu_x86_load_seg(env, R_CS, __USER_CS);
1164     env->eflags &= ~TF_MASK;
1165
1166     unlock_user_struct(frame, frame_addr, 1);
1167
1168     return;
1169
1170 give_sigsegv:
1171     force_sigsegv(sig);
1172 }
1173 #endif
1174
1175 /* compare linux/arch/x86/kernel/signal.c:setup_rt_frame() */
1176 static void setup_rt_frame(int sig, struct target_sigaction *ka,
1177                            target_siginfo_t *info,
1178                            target_sigset_t *set, CPUX86State *env)
1179 {
1180     abi_ulong frame_addr;
1181 #ifndef TARGET_X86_64
1182     abi_ulong addr;
1183 #endif
1184     struct rt_sigframe *frame;
1185     int i;
1186
1187     frame_addr = get_sigframe(ka, env, sizeof(*frame));
1188     trace_user_setup_rt_frame(env, frame_addr);
1189
1190     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1191         goto give_sigsegv;
1192
1193     /* These fields are only in rt_sigframe on 32 bit */
1194 #ifndef TARGET_X86_64
1195     __put_user(sig, &frame->sig);
1196     addr = frame_addr + offsetof(struct rt_sigframe, info);
1197     __put_user(addr, &frame->pinfo);
1198     addr = frame_addr + offsetof(struct rt_sigframe, uc);
1199     __put_user(addr, &frame->puc);
1200 #endif
1201     if (ka->sa_flags & TARGET_SA_SIGINFO) {
1202         tswap_siginfo(&frame->info, info);
1203     }
1204
1205     /* Create the ucontext.  */
1206     __put_user(0, &frame->uc.tuc_flags);
1207     __put_user(0, &frame->uc.tuc_link);
1208     __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
1209     __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
1210                &frame->uc.tuc_stack.ss_flags);
1211     __put_user(target_sigaltstack_used.ss_size,
1212                &frame->uc.tuc_stack.ss_size);
1213     setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate, env,
1214             set->sig[0], frame_addr + offsetof(struct rt_sigframe, fpstate));
1215
1216     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1217         __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
1218     }
1219
1220     /* Set up to return from userspace.  If provided, use a stub
1221        already in userspace.  */
1222 #ifndef TARGET_X86_64
1223     if (ka->sa_flags & TARGET_SA_RESTORER) {
1224         __put_user(ka->sa_restorer, &frame->pretcode);
1225     } else {
1226         uint16_t val16;
1227         addr = frame_addr + offsetof(struct rt_sigframe, retcode);
1228         __put_user(addr, &frame->pretcode);
1229         /* This is movl $,%eax ; int $0x80 */
1230         __put_user(0xb8, (char *)(frame->retcode+0));
1231         __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
1232         val16 = 0x80cd;
1233         __put_user(val16, (uint16_t *)(frame->retcode+5));
1234     }
1235 #else
1236     /* XXX: Would be slightly better to return -EFAULT here if test fails
1237        assert(ka->sa_flags & TARGET_SA_RESTORER); */
1238     __put_user(ka->sa_restorer, &frame->pretcode);
1239 #endif
1240
1241     /* Set up registers for signal handler */
1242     env->regs[R_ESP] = frame_addr;
1243     env->eip = ka->_sa_handler;
1244
1245 #ifndef TARGET_X86_64
1246     env->regs[R_EAX] = sig;
1247     env->regs[R_EDX] = (unsigned long)&frame->info;
1248     env->regs[R_ECX] = (unsigned long)&frame->uc;
1249 #else
1250     env->regs[R_EAX] = 0;
1251     env->regs[R_EDI] = sig;
1252     env->regs[R_ESI] = (unsigned long)&frame->info;
1253     env->regs[R_EDX] = (unsigned long)&frame->uc;
1254 #endif
1255
1256     cpu_x86_load_seg(env, R_DS, __USER_DS);
1257     cpu_x86_load_seg(env, R_ES, __USER_DS);
1258     cpu_x86_load_seg(env, R_CS, __USER_CS);
1259     cpu_x86_load_seg(env, R_SS, __USER_DS);
1260     env->eflags &= ~TF_MASK;
1261
1262     unlock_user_struct(frame, frame_addr, 1);
1263
1264     return;
1265
1266 give_sigsegv:
1267     force_sigsegv(sig);
1268 }
1269
1270 static int
1271 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc)
1272 {
1273     unsigned int err = 0;
1274     abi_ulong fpstate_addr;
1275     unsigned int tmpflags;
1276
1277 #ifndef TARGET_X86_64
1278     cpu_x86_load_seg(env, R_GS, tswap16(sc->gs));
1279     cpu_x86_load_seg(env, R_FS, tswap16(sc->fs));
1280     cpu_x86_load_seg(env, R_ES, tswap16(sc->es));
1281     cpu_x86_load_seg(env, R_DS, tswap16(sc->ds));
1282
1283     env->regs[R_EDI] = tswapl(sc->edi);
1284     env->regs[R_ESI] = tswapl(sc->esi);
1285     env->regs[R_EBP] = tswapl(sc->ebp);
1286     env->regs[R_ESP] = tswapl(sc->esp);
1287     env->regs[R_EBX] = tswapl(sc->ebx);
1288     env->regs[R_EDX] = tswapl(sc->edx);
1289     env->regs[R_ECX] = tswapl(sc->ecx);
1290     env->regs[R_EAX] = tswapl(sc->eax);
1291
1292     env->eip = tswapl(sc->eip);
1293 #else
1294     env->regs[8] = tswapl(sc->r8);
1295     env->regs[9] = tswapl(sc->r9);
1296     env->regs[10] = tswapl(sc->r10);
1297     env->regs[11] = tswapl(sc->r11);
1298     env->regs[12] = tswapl(sc->r12);
1299     env->regs[13] = tswapl(sc->r13);
1300     env->regs[14] = tswapl(sc->r14);
1301     env->regs[15] = tswapl(sc->r15);
1302
1303     env->regs[R_EDI] = tswapl(sc->rdi);
1304     env->regs[R_ESI] = tswapl(sc->rsi);
1305     env->regs[R_EBP] = tswapl(sc->rbp);
1306     env->regs[R_EBX] = tswapl(sc->rbx);
1307     env->regs[R_EDX] = tswapl(sc->rdx);
1308     env->regs[R_EAX] = tswapl(sc->rax);
1309     env->regs[R_ECX] = tswapl(sc->rcx);
1310     env->regs[R_ESP] = tswapl(sc->rsp);
1311
1312     env->eip = tswapl(sc->rip);
1313 #endif
1314
1315     cpu_x86_load_seg(env, R_CS, lduw_p(&sc->cs) | 3);
1316     cpu_x86_load_seg(env, R_SS, lduw_p(&sc->ss) | 3);
1317
1318     tmpflags = tswapl(sc->eflags);
1319     env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
1320     //          regs->orig_eax = -1;            /* disable syscall checks */
1321
1322     fpstate_addr = tswapl(sc->fpstate);
1323     if (fpstate_addr != 0) {
1324         if (!access_ok(VERIFY_READ, fpstate_addr,
1325                        sizeof(struct target_fpstate)))
1326             goto badframe;
1327 #ifndef TARGET_X86_64
1328         cpu_x86_frstor(env, fpstate_addr, 1);
1329 #else
1330         cpu_x86_fxrstor(env, fpstate_addr);
1331 #endif
1332     }
1333
1334     return err;
1335 badframe:
1336     return 1;
1337 }
1338
1339 /* Note: there is no sigreturn on x86_64, there is only rt_sigreturn */
1340 #ifndef TARGET_X86_64
1341 long do_sigreturn(CPUX86State *env)
1342 {
1343     struct sigframe *frame;
1344     abi_ulong frame_addr = env->regs[R_ESP] - 8;
1345     target_sigset_t target_set;
1346     sigset_t set;
1347     int i;
1348
1349     trace_user_do_sigreturn(env, frame_addr);
1350     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1351         goto badframe;
1352     /* set blocked signals */
1353     __get_user(target_set.sig[0], &frame->sc.oldmask);
1354     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1355         __get_user(target_set.sig[i], &frame->extramask[i - 1]);
1356     }
1357
1358     target_to_host_sigset_internal(&set, &target_set);
1359     set_sigmask(&set);
1360
1361     /* restore registers */
1362     if (restore_sigcontext(env, &frame->sc))
1363         goto badframe;
1364     unlock_user_struct(frame, frame_addr, 0);
1365     return -TARGET_QEMU_ESIGRETURN;
1366
1367 badframe:
1368     unlock_user_struct(frame, frame_addr, 0);
1369     force_sig(TARGET_SIGSEGV);
1370     return -TARGET_QEMU_ESIGRETURN;
1371 }
1372 #endif
1373
1374 long do_rt_sigreturn(CPUX86State *env)
1375 {
1376     abi_ulong frame_addr;
1377     struct rt_sigframe *frame;
1378     sigset_t set;
1379
1380     frame_addr = env->regs[R_ESP] - sizeof(abi_ulong);
1381     trace_user_do_rt_sigreturn(env, frame_addr);
1382     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1383         goto badframe;
1384     target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
1385     set_sigmask(&set);
1386
1387     if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) {
1388         goto badframe;
1389     }
1390
1391     if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0,
1392                        get_sp_from_cpustate(env)) == -EFAULT) {
1393         goto badframe;
1394     }
1395
1396     unlock_user_struct(frame, frame_addr, 0);
1397     return -TARGET_QEMU_ESIGRETURN;
1398
1399 badframe:
1400     unlock_user_struct(frame, frame_addr, 0);
1401     force_sig(TARGET_SIGSEGV);
1402     return -TARGET_QEMU_ESIGRETURN;
1403 }
1404
1405 #elif defined(TARGET_AARCH64)
1406
1407 struct target_sigcontext {
1408     uint64_t fault_address;
1409     /* AArch64 registers */
1410     uint64_t regs[31];
1411     uint64_t sp;
1412     uint64_t pc;
1413     uint64_t pstate;
1414     /* 4K reserved for FP/SIMD state and future expansion */
1415     char __reserved[4096] __attribute__((__aligned__(16)));
1416 };
1417
1418 struct target_ucontext {
1419     abi_ulong tuc_flags;
1420     abi_ulong tuc_link;
1421     target_stack_t tuc_stack;
1422     target_sigset_t tuc_sigmask;
1423     /* glibc uses a 1024-bit sigset_t */
1424     char __unused[1024 / 8 - sizeof(target_sigset_t)];
1425     /* last for future expansion */
1426     struct target_sigcontext tuc_mcontext;
1427 };
1428
1429 /*
1430  * Header to be used at the beginning of structures extending the user
1431  * context. Such structures must be placed after the rt_sigframe on the stack
1432  * and be 16-byte aligned. The last structure must be a dummy one with the
1433  * magic and size set to 0.
1434  */
1435 struct target_aarch64_ctx {
1436     uint32_t magic;
1437     uint32_t size;
1438 };
1439
1440 #define TARGET_FPSIMD_MAGIC 0x46508001
1441
1442 struct target_fpsimd_context {
1443     struct target_aarch64_ctx head;
1444     uint32_t fpsr;
1445     uint32_t fpcr;
1446     uint64_t vregs[32 * 2]; /* really uint128_t vregs[32] */
1447 };
1448
1449 /*
1450  * Auxiliary context saved in the sigcontext.__reserved array. Not exported to
1451  * user space as it will change with the addition of new context. User space
1452  * should check the magic/size information.
1453  */
1454 struct target_aux_context {
1455     struct target_fpsimd_context fpsimd;
1456     /* additional context to be added before "end" */
1457     struct target_aarch64_ctx end;
1458 };
1459
1460 struct target_rt_sigframe {
1461     struct target_siginfo info;
1462     struct target_ucontext uc;
1463     uint64_t fp;
1464     uint64_t lr;
1465     uint32_t tramp[2];
1466 };
1467
1468 static int target_setup_sigframe(struct target_rt_sigframe *sf,
1469                                  CPUARMState *env, target_sigset_t *set)
1470 {
1471     int i;
1472     struct target_aux_context *aux =
1473         (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved;
1474
1475     /* set up the stack frame for unwinding */
1476     __put_user(env->xregs[29], &sf->fp);
1477     __put_user(env->xregs[30], &sf->lr);
1478
1479     for (i = 0; i < 31; i++) {
1480         __put_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
1481     }
1482     __put_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
1483     __put_user(env->pc, &sf->uc.tuc_mcontext.pc);
1484     __put_user(pstate_read(env), &sf->uc.tuc_mcontext.pstate);
1485
1486     __put_user(env->exception.vaddress, &sf->uc.tuc_mcontext.fault_address);
1487
1488     for (i = 0; i < TARGET_NSIG_WORDS; i++) {
1489         __put_user(set->sig[i], &sf->uc.tuc_sigmask.sig[i]);
1490     }
1491
1492     for (i = 0; i < 32; i++) {
1493         uint64_t *q = aa64_vfp_qreg(env, i);
1494 #ifdef TARGET_WORDS_BIGENDIAN
1495         __put_user(q[0], &aux->fpsimd.vregs[i * 2 + 1]);
1496         __put_user(q[1], &aux->fpsimd.vregs[i * 2]);
1497 #else
1498         __put_user(q[0], &aux->fpsimd.vregs[i * 2]);
1499         __put_user(q[1], &aux->fpsimd.vregs[i * 2 + 1]);
1500 #endif
1501     }
1502     __put_user(vfp_get_fpsr(env), &aux->fpsimd.fpsr);
1503     __put_user(vfp_get_fpcr(env), &aux->fpsimd.fpcr);
1504     __put_user(TARGET_FPSIMD_MAGIC, &aux->fpsimd.head.magic);
1505     __put_user(sizeof(struct target_fpsimd_context),
1506             &aux->fpsimd.head.size);
1507
1508     /* set the "end" magic */
1509     __put_user(0, &aux->end.magic);
1510     __put_user(0, &aux->end.size);
1511
1512     return 0;
1513 }
1514
1515 static int target_restore_sigframe(CPUARMState *env,
1516                                    struct target_rt_sigframe *sf)
1517 {
1518     sigset_t set;
1519     int i;
1520     struct target_aux_context *aux =
1521         (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved;
1522     uint32_t magic, size, fpsr, fpcr;
1523     uint64_t pstate;
1524
1525     target_to_host_sigset(&set, &sf->uc.tuc_sigmask);
1526     set_sigmask(&set);
1527
1528     for (i = 0; i < 31; i++) {
1529         __get_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
1530     }
1531
1532     __get_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
1533     __get_user(env->pc, &sf->uc.tuc_mcontext.pc);
1534     __get_user(pstate, &sf->uc.tuc_mcontext.pstate);
1535     pstate_write(env, pstate);
1536
1537     __get_user(magic, &aux->fpsimd.head.magic);
1538     __get_user(size, &aux->fpsimd.head.size);
1539
1540     if (magic != TARGET_FPSIMD_MAGIC
1541         || size != sizeof(struct target_fpsimd_context)) {
1542         return 1;
1543     }
1544
1545     for (i = 0; i < 32; i++) {
1546         uint64_t *q = aa64_vfp_qreg(env, i);
1547 #ifdef TARGET_WORDS_BIGENDIAN
1548         __get_user(q[0], &aux->fpsimd.vregs[i * 2 + 1]);
1549         __get_user(q[1], &aux->fpsimd.vregs[i * 2]);
1550 #else
1551         __get_user(q[0], &aux->fpsimd.vregs[i * 2]);
1552         __get_user(q[1], &aux->fpsimd.vregs[i * 2 + 1]);
1553 #endif
1554     }
1555     __get_user(fpsr, &aux->fpsimd.fpsr);
1556     vfp_set_fpsr(env, fpsr);
1557     __get_user(fpcr, &aux->fpsimd.fpcr);
1558     vfp_set_fpcr(env, fpcr);
1559
1560     return 0;
1561 }
1562
1563 static abi_ulong get_sigframe(struct target_sigaction *ka, CPUARMState *env)
1564 {
1565     abi_ulong sp;
1566
1567     sp = env->xregs[31];
1568
1569     /*
1570      * This is the X/Open sanctioned signal stack switching.
1571      */
1572     if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) {
1573         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1574     }
1575
1576     sp = (sp - sizeof(struct target_rt_sigframe)) & ~15;
1577
1578     return sp;
1579 }
1580
1581 static void target_setup_frame(int usig, struct target_sigaction *ka,
1582                                target_siginfo_t *info, target_sigset_t *set,
1583                                CPUARMState *env)
1584 {
1585     struct target_rt_sigframe *frame;
1586     abi_ulong frame_addr, return_addr;
1587
1588     frame_addr = get_sigframe(ka, env);
1589     trace_user_setup_frame(env, frame_addr);
1590     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
1591         goto give_sigsegv;
1592     }
1593
1594     __put_user(0, &frame->uc.tuc_flags);
1595     __put_user(0, &frame->uc.tuc_link);
1596
1597     __put_user(target_sigaltstack_used.ss_sp,
1598                       &frame->uc.tuc_stack.ss_sp);
1599     __put_user(sas_ss_flags(env->xregs[31]),
1600                       &frame->uc.tuc_stack.ss_flags);
1601     __put_user(target_sigaltstack_used.ss_size,
1602                       &frame->uc.tuc_stack.ss_size);
1603     target_setup_sigframe(frame, env, set);
1604     if (ka->sa_flags & TARGET_SA_RESTORER) {
1605         return_addr = ka->sa_restorer;
1606     } else {
1607         /*
1608          * mov x8,#__NR_rt_sigreturn; svc #0
1609          * Since these are instructions they need to be put as little-endian
1610          * regardless of target default or current CPU endianness.
1611          */
1612         __put_user_e(0xd2801168, &frame->tramp[0], le);
1613         __put_user_e(0xd4000001, &frame->tramp[1], le);
1614         return_addr = frame_addr + offsetof(struct target_rt_sigframe, tramp);
1615     }
1616     env->xregs[0] = usig;
1617     env->xregs[31] = frame_addr;
1618     env->xregs[29] = env->xregs[31] + offsetof(struct target_rt_sigframe, fp);
1619     env->pc = ka->_sa_handler;
1620     env->xregs[30] = return_addr;
1621     if (info) {
1622         tswap_siginfo(&frame->info, info);
1623         env->xregs[1] = frame_addr + offsetof(struct target_rt_sigframe, info);
1624         env->xregs[2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
1625     }
1626
1627     unlock_user_struct(frame, frame_addr, 1);
1628     return;
1629
1630  give_sigsegv:
1631     unlock_user_struct(frame, frame_addr, 1);
1632     force_sigsegv(usig);
1633 }
1634
1635 static void setup_rt_frame(int sig, struct target_sigaction *ka,
1636                            target_siginfo_t *info, target_sigset_t *set,
1637                            CPUARMState *env)
1638 {
1639     target_setup_frame(sig, ka, info, set, env);
1640 }
1641
1642 static void setup_frame(int sig, struct target_sigaction *ka,
1643                         target_sigset_t *set, CPUARMState *env)
1644 {
1645     target_setup_frame(sig, ka, 0, set, env);
1646 }
1647
1648 long do_rt_sigreturn(CPUARMState *env)
1649 {
1650     struct target_rt_sigframe *frame = NULL;
1651     abi_ulong frame_addr = env->xregs[31];
1652
1653     trace_user_do_rt_sigreturn(env, frame_addr);
1654     if (frame_addr & 15) {
1655         goto badframe;
1656     }
1657
1658     if  (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
1659         goto badframe;
1660     }
1661
1662     if (target_restore_sigframe(env, frame)) {
1663         goto badframe;
1664     }
1665
1666     if (do_sigaltstack(frame_addr +
1667             offsetof(struct target_rt_sigframe, uc.tuc_stack),
1668             0, get_sp_from_cpustate(env)) == -EFAULT) {
1669         goto badframe;
1670     }
1671
1672     unlock_user_struct(frame, frame_addr, 0);
1673     return -TARGET_QEMU_ESIGRETURN;
1674
1675  badframe:
1676     unlock_user_struct(frame, frame_addr, 0);
1677     force_sig(TARGET_SIGSEGV);
1678     return -TARGET_QEMU_ESIGRETURN;
1679 }
1680
1681 long do_sigreturn(CPUARMState *env)
1682 {
1683     return do_rt_sigreturn(env);
1684 }
1685
1686 #elif defined(TARGET_ARM)
1687
1688 struct target_sigcontext {
1689     abi_ulong trap_no;
1690     abi_ulong error_code;
1691     abi_ulong oldmask;
1692     abi_ulong arm_r0;
1693     abi_ulong arm_r1;
1694     abi_ulong arm_r2;
1695     abi_ulong arm_r3;
1696     abi_ulong arm_r4;
1697     abi_ulong arm_r5;
1698     abi_ulong arm_r6;
1699     abi_ulong arm_r7;
1700     abi_ulong arm_r8;
1701     abi_ulong arm_r9;
1702     abi_ulong arm_r10;
1703     abi_ulong arm_fp;
1704     abi_ulong arm_ip;
1705     abi_ulong arm_sp;
1706     abi_ulong arm_lr;
1707     abi_ulong arm_pc;
1708     abi_ulong arm_cpsr;
1709     abi_ulong fault_address;
1710 };
1711
1712 struct target_ucontext_v1 {
1713     abi_ulong tuc_flags;
1714     abi_ulong tuc_link;
1715     target_stack_t tuc_stack;
1716     struct target_sigcontext tuc_mcontext;
1717     target_sigset_t  tuc_sigmask;       /* mask last for extensibility */
1718 };
1719
1720 struct target_ucontext_v2 {
1721     abi_ulong tuc_flags;
1722     abi_ulong tuc_link;
1723     target_stack_t tuc_stack;
1724     struct target_sigcontext tuc_mcontext;
1725     target_sigset_t  tuc_sigmask;       /* mask last for extensibility */
1726     char __unused[128 - sizeof(target_sigset_t)];
1727     abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
1728 };
1729
1730 struct target_user_vfp {
1731     uint64_t fpregs[32];
1732     abi_ulong fpscr;
1733 };
1734
1735 struct target_user_vfp_exc {
1736     abi_ulong fpexc;
1737     abi_ulong fpinst;
1738     abi_ulong fpinst2;
1739 };
1740
1741 struct target_vfp_sigframe {
1742     abi_ulong magic;
1743     abi_ulong size;
1744     struct target_user_vfp ufp;
1745     struct target_user_vfp_exc ufp_exc;
1746 } __attribute__((__aligned__(8)));
1747
1748 struct target_iwmmxt_sigframe {
1749     abi_ulong magic;
1750     abi_ulong size;
1751     uint64_t regs[16];
1752     /* Note that not all the coprocessor control registers are stored here */
1753     uint32_t wcssf;
1754     uint32_t wcasf;
1755     uint32_t wcgr0;
1756     uint32_t wcgr1;
1757     uint32_t wcgr2;
1758     uint32_t wcgr3;
1759 } __attribute__((__aligned__(8)));
1760
1761 #define TARGET_VFP_MAGIC 0x56465001
1762 #define TARGET_IWMMXT_MAGIC 0x12ef842a
1763
1764 struct sigframe_v1
1765 {
1766     struct target_sigcontext sc;
1767     abi_ulong extramask[TARGET_NSIG_WORDS-1];
1768     abi_ulong retcode;
1769 };
1770
1771 struct sigframe_v2
1772 {
1773     struct target_ucontext_v2 uc;
1774     abi_ulong retcode;
1775 };
1776
1777 struct rt_sigframe_v1
1778 {
1779     abi_ulong pinfo;
1780     abi_ulong puc;
1781     struct target_siginfo info;
1782     struct target_ucontext_v1 uc;
1783     abi_ulong retcode;
1784 };
1785
1786 struct rt_sigframe_v2
1787 {
1788     struct target_siginfo info;
1789     struct target_ucontext_v2 uc;
1790     abi_ulong retcode;
1791 };
1792
1793 #define TARGET_CONFIG_CPU_32 1
1794
1795 /*
1796  * For ARM syscalls, we encode the syscall number into the instruction.
1797  */
1798 #define SWI_SYS_SIGRETURN       (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1799 #define SWI_SYS_RT_SIGRETURN    (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1800
1801 /*
1802  * For Thumb syscalls, we pass the syscall number via r7.  We therefore
1803  * need two 16-bit instructions.
1804  */
1805 #define SWI_THUMB_SIGRETURN     (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1806 #define SWI_THUMB_RT_SIGRETURN  (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1807
1808 static const abi_ulong retcodes[4] = {
1809         SWI_SYS_SIGRETURN,      SWI_THUMB_SIGRETURN,
1810         SWI_SYS_RT_SIGRETURN,   SWI_THUMB_RT_SIGRETURN
1811 };
1812
1813
1814 static inline int valid_user_regs(CPUARMState *regs)
1815 {
1816     return 1;
1817 }
1818
1819 static void
1820 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1821                  CPUARMState *env, abi_ulong mask)
1822 {
1823     __put_user(env->regs[0], &sc->arm_r0);
1824     __put_user(env->regs[1], &sc->arm_r1);
1825     __put_user(env->regs[2], &sc->arm_r2);
1826     __put_user(env->regs[3], &sc->arm_r3);
1827     __put_user(env->regs[4], &sc->arm_r4);
1828     __put_user(env->regs[5], &sc->arm_r5);
1829     __put_user(env->regs[6], &sc->arm_r6);
1830     __put_user(env->regs[7], &sc->arm_r7);
1831     __put_user(env->regs[8], &sc->arm_r8);
1832     __put_user(env->regs[9], &sc->arm_r9);
1833     __put_user(env->regs[10], &sc->arm_r10);
1834     __put_user(env->regs[11], &sc->arm_fp);
1835     __put_user(env->regs[12], &sc->arm_ip);
1836     __put_user(env->regs[13], &sc->arm_sp);
1837     __put_user(env->regs[14], &sc->arm_lr);
1838     __put_user(env->regs[15], &sc->arm_pc);
1839 #ifdef TARGET_CONFIG_CPU_32
1840     __put_user(cpsr_read(env), &sc->arm_cpsr);
1841 #endif
1842
1843     __put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
1844     __put_user(/* current->thread.error_code */ 0, &sc->error_code);
1845     __put_user(/* current->thread.address */ 0, &sc->fault_address);
1846     __put_user(mask, &sc->oldmask);
1847 }
1848
1849 static inline abi_ulong
1850 get_sigframe(struct target_sigaction *ka, CPUARMState *regs, int framesize)
1851 {
1852     unsigned long sp = regs->regs[13];
1853
1854     /*
1855      * This is the X/Open sanctioned signal stack switching.
1856      */
1857     if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) {
1858         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1859     }
1860     /*
1861      * ATPCS B01 mandates 8-byte alignment
1862      */
1863     return (sp - framesize) & ~7;
1864 }
1865
1866 static void
1867 setup_return(CPUARMState *env, struct target_sigaction *ka,
1868              abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr)
1869 {
1870     abi_ulong handler = ka->_sa_handler;
1871     abi_ulong retcode;
1872     int thumb = handler & 1;
1873     uint32_t cpsr = cpsr_read(env);
1874
1875     cpsr &= ~CPSR_IT;
1876     if (thumb) {
1877         cpsr |= CPSR_T;
1878     } else {
1879         cpsr &= ~CPSR_T;
1880     }
1881
1882     if (ka->sa_flags & TARGET_SA_RESTORER) {
1883         retcode = ka->sa_restorer;
1884     } else {
1885         unsigned int idx = thumb;
1886
1887         if (ka->sa_flags & TARGET_SA_SIGINFO) {
1888             idx += 2;
1889         }
1890
1891         __put_user(retcodes[idx], rc);
1892
1893         retcode = rc_addr + thumb;
1894     }
1895
1896     env->regs[0] = usig;
1897     env->regs[13] = frame_addr;
1898     env->regs[14] = retcode;
1899     env->regs[15] = handler & (thumb ? ~1 : ~3);
1900     cpsr_write(env, cpsr, CPSR_IT | CPSR_T, CPSRWriteByInstr);
1901 }
1902
1903 static abi_ulong *setup_sigframe_v2_vfp(abi_ulong *regspace, CPUARMState *env)
1904 {
1905     int i;
1906     struct target_vfp_sigframe *vfpframe;
1907     vfpframe = (struct target_vfp_sigframe *)regspace;
1908     __put_user(TARGET_VFP_MAGIC, &vfpframe->magic);
1909     __put_user(sizeof(*vfpframe), &vfpframe->size);
1910     for (i = 0; i < 32; i++) {
1911         __put_user(*aa32_vfp_dreg(env, i), &vfpframe->ufp.fpregs[i]);
1912     }
1913     __put_user(vfp_get_fpscr(env), &vfpframe->ufp.fpscr);
1914     __put_user(env->vfp.xregs[ARM_VFP_FPEXC], &vfpframe->ufp_exc.fpexc);
1915     __put_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1916     __put_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1917     return (abi_ulong*)(vfpframe+1);
1918 }
1919
1920 static abi_ulong *setup_sigframe_v2_iwmmxt(abi_ulong *regspace,
1921                                            CPUARMState *env)
1922 {
1923     int i;
1924     struct target_iwmmxt_sigframe *iwmmxtframe;
1925     iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1926     __put_user(TARGET_IWMMXT_MAGIC, &iwmmxtframe->magic);
1927     __put_user(sizeof(*iwmmxtframe), &iwmmxtframe->size);
1928     for (i = 0; i < 16; i++) {
1929         __put_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1930     }
1931     __put_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1932     __put_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1933     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1934     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1935     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1936     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1937     return (abi_ulong*)(iwmmxtframe+1);
1938 }
1939
1940 static void setup_sigframe_v2(struct target_ucontext_v2 *uc,
1941                               target_sigset_t *set, CPUARMState *env)
1942 {
1943     struct target_sigaltstack stack;
1944     int i;
1945     abi_ulong *regspace;
1946
1947     /* Clear all the bits of the ucontext we don't use.  */
1948     memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext));
1949
1950     memset(&stack, 0, sizeof(stack));
1951     __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1952     __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1953     __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1954     memcpy(&uc->tuc_stack, &stack, sizeof(stack));
1955
1956     setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
1957     /* Save coprocessor signal frame.  */
1958     regspace = uc->tuc_regspace;
1959     if (arm_feature(env, ARM_FEATURE_VFP)) {
1960         regspace = setup_sigframe_v2_vfp(regspace, env);
1961     }
1962     if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
1963         regspace = setup_sigframe_v2_iwmmxt(regspace, env);
1964     }
1965
1966     /* Write terminating magic word */
1967     __put_user(0, regspace);
1968
1969     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1970         __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
1971     }
1972 }
1973
1974 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */
1975 static void setup_frame_v1(int usig, struct target_sigaction *ka,
1976                            target_sigset_t *set, CPUARMState *regs)
1977 {
1978     struct sigframe_v1 *frame;
1979     abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1980     int i;
1981
1982     trace_user_setup_frame(regs, frame_addr);
1983     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
1984         goto sigsegv;
1985     }
1986
1987     setup_sigcontext(&frame->sc, regs, set->sig[0]);
1988
1989     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1990         __put_user(set->sig[i], &frame->extramask[i - 1]);
1991     }
1992
1993     setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1994                  frame_addr + offsetof(struct sigframe_v1, retcode));
1995
1996     unlock_user_struct(frame, frame_addr, 1);
1997     return;
1998 sigsegv:
1999     force_sigsegv(usig);
2000 }
2001
2002 static void setup_frame_v2(int usig, struct target_sigaction *ka,
2003                            target_sigset_t *set, CPUARMState *regs)
2004 {
2005     struct sigframe_v2 *frame;
2006     abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
2007
2008     trace_user_setup_frame(regs, frame_addr);
2009     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
2010         goto sigsegv;
2011     }
2012
2013     setup_sigframe_v2(&frame->uc, set, regs);
2014
2015     setup_return(regs, ka, &frame->retcode, frame_addr, usig,
2016                  frame_addr + offsetof(struct sigframe_v2, retcode));
2017
2018     unlock_user_struct(frame, frame_addr, 1);
2019     return;
2020 sigsegv:
2021     force_sigsegv(usig);
2022 }
2023
2024 static void setup_frame(int usig, struct target_sigaction *ka,
2025                         target_sigset_t *set, CPUARMState *regs)
2026 {
2027     if (get_osversion() >= 0x020612) {
2028         setup_frame_v2(usig, ka, set, regs);
2029     } else {
2030         setup_frame_v1(usig, ka, set, regs);
2031     }
2032 }
2033
2034 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
2035 static void setup_rt_frame_v1(int usig, struct target_sigaction *ka,
2036                               target_siginfo_t *info,
2037                               target_sigset_t *set, CPUARMState *env)
2038 {
2039     struct rt_sigframe_v1 *frame;
2040     abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
2041     struct target_sigaltstack stack;
2042     int i;
2043     abi_ulong info_addr, uc_addr;
2044
2045     trace_user_setup_rt_frame(env, frame_addr);
2046     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
2047         goto sigsegv;
2048     }
2049
2050     info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info);
2051     __put_user(info_addr, &frame->pinfo);
2052     uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);
2053     __put_user(uc_addr, &frame->puc);
2054     tswap_siginfo(&frame->info, info);
2055
2056     /* Clear all the bits of the ucontext we don't use.  */
2057     memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));
2058
2059     memset(&stack, 0, sizeof(stack));
2060     __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
2061     __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
2062     __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
2063     memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
2064
2065     setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]);
2066     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2067         __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
2068     }
2069
2070     setup_return(env, ka, &frame->retcode, frame_addr, usig,
2071                  frame_addr + offsetof(struct rt_sigframe_v1, retcode));
2072
2073     env->regs[1] = info_addr;
2074     env->regs[2] = uc_addr;
2075
2076     unlock_user_struct(frame, frame_addr, 1);
2077     return;
2078 sigsegv:
2079     force_sigsegv(usig);
2080 }
2081
2082 static void setup_rt_frame_v2(int usig, struct target_sigaction *ka,
2083                               target_siginfo_t *info,
2084                               target_sigset_t *set, CPUARMState *env)
2085 {
2086     struct rt_sigframe_v2 *frame;
2087     abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
2088     abi_ulong info_addr, uc_addr;
2089
2090     trace_user_setup_rt_frame(env, frame_addr);
2091     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
2092         goto sigsegv;
2093     }
2094
2095     info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info);
2096     uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc);
2097     tswap_siginfo(&frame->info, info);
2098
2099     setup_sigframe_v2(&frame->uc, set, env);
2100
2101     setup_return(env, ka, &frame->retcode, frame_addr, usig,
2102                  frame_addr + offsetof(struct rt_sigframe_v2, retcode));
2103
2104     env->regs[1] = info_addr;
2105     env->regs[2] = uc_addr;
2106
2107     unlock_user_struct(frame, frame_addr, 1);
2108     return;
2109 sigsegv:
2110     force_sigsegv(usig);
2111 }
2112
2113 static void setup_rt_frame(int usig, struct target_sigaction *ka,
2114                            target_siginfo_t *info,
2115                            target_sigset_t *set, CPUARMState *env)
2116 {
2117     if (get_osversion() >= 0x020612) {
2118         setup_rt_frame_v2(usig, ka, info, set, env);
2119     } else {
2120         setup_rt_frame_v1(usig, ka, info, set, env);
2121     }
2122 }
2123
2124 static int
2125 restore_sigcontext(CPUARMState *env, struct target_sigcontext *sc)
2126 {
2127     int err = 0;
2128     uint32_t cpsr;
2129
2130     __get_user(env->regs[0], &sc->arm_r0);
2131     __get_user(env->regs[1], &sc->arm_r1);
2132     __get_user(env->regs[2], &sc->arm_r2);
2133     __get_user(env->regs[3], &sc->arm_r3);
2134     __get_user(env->regs[4], &sc->arm_r4);
2135     __get_user(env->regs[5], &sc->arm_r5);
2136     __get_user(env->regs[6], &sc->arm_r6);
2137     __get_user(env->regs[7], &sc->arm_r7);
2138     __get_user(env->regs[8], &sc->arm_r8);
2139     __get_user(env->regs[9], &sc->arm_r9);
2140     __get_user(env->regs[10], &sc->arm_r10);
2141     __get_user(env->regs[11], &sc->arm_fp);
2142     __get_user(env->regs[12], &sc->arm_ip);
2143     __get_user(env->regs[13], &sc->arm_sp);
2144     __get_user(env->regs[14], &sc->arm_lr);
2145     __get_user(env->regs[15], &sc->arm_pc);
2146 #ifdef TARGET_CONFIG_CPU_32
2147     __get_user(cpsr, &sc->arm_cpsr);
2148     cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC, CPSRWriteByInstr);
2149 #endif
2150
2151     err |= !valid_user_regs(env);
2152
2153     return err;
2154 }
2155
2156 static long do_sigreturn_v1(CPUARMState *env)
2157 {
2158     abi_ulong frame_addr;
2159     struct sigframe_v1 *frame = NULL;
2160     target_sigset_t set;
2161     sigset_t host_set;
2162     int i;
2163
2164     /*
2165      * Since we stacked the signal on a 64-bit boundary,
2166      * then 'sp' should be word aligned here.  If it's
2167      * not, then the user is trying to mess with us.
2168      */
2169     frame_addr = env->regs[13];
2170     trace_user_do_sigreturn(env, frame_addr);
2171     if (frame_addr & 7) {
2172         goto badframe;
2173     }
2174
2175     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
2176         goto badframe;
2177     }
2178
2179     __get_user(set.sig[0], &frame->sc.oldmask);
2180     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
2181         __get_user(set.sig[i], &frame->extramask[i - 1]);
2182     }
2183
2184     target_to_host_sigset_internal(&host_set, &set);
2185     set_sigmask(&host_set);
2186
2187     if (restore_sigcontext(env, &frame->sc)) {
2188         goto badframe;
2189     }
2190
2191 #if 0
2192     /* Send SIGTRAP if we're single-stepping */
2193     if (ptrace_cancel_bpt(current))
2194         send_sig(SIGTRAP, current, 1);
2195 #endif
2196     unlock_user_struct(frame, frame_addr, 0);
2197     return -TARGET_QEMU_ESIGRETURN;
2198
2199 badframe:
2200     force_sig(TARGET_SIGSEGV);
2201     return -TARGET_QEMU_ESIGRETURN;
2202 }
2203
2204 static abi_ulong *restore_sigframe_v2_vfp(CPUARMState *env, abi_ulong *regspace)
2205 {
2206     int i;
2207     abi_ulong magic, sz;
2208     uint32_t fpscr, fpexc;
2209     struct target_vfp_sigframe *vfpframe;
2210     vfpframe = (struct target_vfp_sigframe *)regspace;
2211
2212     __get_user(magic, &vfpframe->magic);
2213     __get_user(sz, &vfpframe->size);
2214     if (magic != TARGET_VFP_MAGIC || sz != sizeof(*vfpframe)) {
2215         return 0;
2216     }
2217     for (i = 0; i < 32; i++) {
2218         __get_user(*aa32_vfp_dreg(env, i), &vfpframe->ufp.fpregs[i]);
2219     }
2220     __get_user(fpscr, &vfpframe->ufp.fpscr);
2221     vfp_set_fpscr(env, fpscr);
2222     __get_user(fpexc, &vfpframe->ufp_exc.fpexc);
2223     /* Sanitise FPEXC: ensure VFP is enabled, FPINST2 is invalid
2224      * and the exception flag is cleared
2225      */
2226     fpexc |= (1 << 30);
2227     fpexc &= ~((1 << 31) | (1 << 28));
2228     env->vfp.xregs[ARM_VFP_FPEXC] = fpexc;
2229     __get_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
2230     __get_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
2231     return (abi_ulong*)(vfpframe + 1);
2232 }
2233
2234 static abi_ulong *restore_sigframe_v2_iwmmxt(CPUARMState *env,
2235                                              abi_ulong *regspace)
2236 {
2237     int i;
2238     abi_ulong magic, sz;
2239     struct target_iwmmxt_sigframe *iwmmxtframe;
2240     iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
2241
2242     __get_user(magic, &iwmmxtframe->magic);
2243     __get_user(sz, &iwmmxtframe->size);
2244     if (magic != TARGET_IWMMXT_MAGIC || sz != sizeof(*iwmmxtframe)) {
2245         return 0;
2246     }
2247     for (i = 0; i < 16; i++) {
2248         __get_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
2249     }
2250     __get_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
2251     __get_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
2252     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
2253     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
2254     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
2255     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
2256     return (abi_ulong*)(iwmmxtframe + 1);
2257 }
2258
2259 static int do_sigframe_return_v2(CPUARMState *env,
2260                                  target_ulong context_addr,
2261                                  struct target_ucontext_v2 *uc)
2262 {
2263     sigset_t host_set;
2264     abi_ulong *regspace;
2265
2266     target_to_host_sigset(&host_set, &uc->tuc_sigmask);
2267     set_sigmask(&host_set);
2268
2269     if (restore_sigcontext(env, &uc->tuc_mcontext))
2270         return 1;
2271
2272     /* Restore coprocessor signal frame */
2273     regspace = uc->tuc_regspace;
2274     if (arm_feature(env, ARM_FEATURE_VFP)) {
2275         regspace = restore_sigframe_v2_vfp(env, regspace);
2276         if (!regspace) {
2277             return 1;
2278         }
2279     }
2280     if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
2281         regspace = restore_sigframe_v2_iwmmxt(env, regspace);
2282         if (!regspace) {
2283             return 1;
2284         }
2285     }
2286
2287     if (do_sigaltstack(context_addr
2288                        + offsetof(struct target_ucontext_v2, tuc_stack),
2289                        0, get_sp_from_cpustate(env)) == -EFAULT) {
2290         return 1;
2291     }
2292
2293 #if 0
2294     /* Send SIGTRAP if we're single-stepping */
2295     if (ptrace_cancel_bpt(current))
2296         send_sig(SIGTRAP, current, 1);
2297 #endif
2298
2299     return 0;
2300 }
2301
2302 static long do_sigreturn_v2(CPUARMState *env)
2303 {
2304     abi_ulong frame_addr;
2305     struct sigframe_v2 *frame = NULL;
2306
2307     /*
2308      * Since we stacked the signal on a 64-bit boundary,
2309      * then 'sp' should be word aligned here.  If it's
2310      * not, then the user is trying to mess with us.
2311      */
2312     frame_addr = env->regs[13];
2313     trace_user_do_sigreturn(env, frame_addr);
2314     if (frame_addr & 7) {
2315         goto badframe;
2316     }
2317
2318     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
2319         goto badframe;
2320     }
2321
2322     if (do_sigframe_return_v2(env,
2323                               frame_addr
2324                               + offsetof(struct sigframe_v2, uc),
2325                               &frame->uc)) {
2326         goto badframe;
2327     }
2328
2329     unlock_user_struct(frame, frame_addr, 0);
2330     return -TARGET_QEMU_ESIGRETURN;
2331
2332 badframe:
2333     unlock_user_struct(frame, frame_addr, 0);
2334     force_sig(TARGET_SIGSEGV);
2335     return -TARGET_QEMU_ESIGRETURN;
2336 }
2337
2338 long do_sigreturn(CPUARMState *env)
2339 {
2340     if (get_osversion() >= 0x020612) {
2341         return do_sigreturn_v2(env);
2342     } else {
2343         return do_sigreturn_v1(env);
2344     }
2345 }
2346
2347 static long do_rt_sigreturn_v1(CPUARMState *env)
2348 {
2349     abi_ulong frame_addr;
2350     struct rt_sigframe_v1 *frame = NULL;
2351     sigset_t host_set;
2352
2353     /*
2354      * Since we stacked the signal on a 64-bit boundary,
2355      * then 'sp' should be word aligned here.  If it's
2356      * not, then the user is trying to mess with us.
2357      */
2358     frame_addr = env->regs[13];
2359     trace_user_do_rt_sigreturn(env, frame_addr);
2360     if (frame_addr & 7) {
2361         goto badframe;
2362     }
2363
2364     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
2365         goto badframe;
2366     }
2367
2368     target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
2369     set_sigmask(&host_set);
2370
2371     if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) {
2372         goto badframe;
2373     }
2374
2375     if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
2376         goto badframe;
2377
2378 #if 0
2379     /* Send SIGTRAP if we're single-stepping */
2380     if (ptrace_cancel_bpt(current))
2381         send_sig(SIGTRAP, current, 1);
2382 #endif
2383     unlock_user_struct(frame, frame_addr, 0);
2384     return -TARGET_QEMU_ESIGRETURN;
2385
2386 badframe:
2387     unlock_user_struct(frame, frame_addr, 0);
2388     force_sig(TARGET_SIGSEGV);
2389     return -TARGET_QEMU_ESIGRETURN;
2390 }
2391
2392 static long do_rt_sigreturn_v2(CPUARMState *env)
2393 {
2394     abi_ulong frame_addr;
2395     struct rt_sigframe_v2 *frame = NULL;
2396
2397     /*
2398      * Since we stacked the signal on a 64-bit boundary,
2399      * then 'sp' should be word aligned here.  If it's
2400      * not, then the user is trying to mess with us.
2401      */
2402     frame_addr = env->regs[13];
2403     trace_user_do_rt_sigreturn(env, frame_addr);
2404     if (frame_addr & 7) {
2405         goto badframe;
2406     }
2407
2408     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
2409         goto badframe;
2410     }
2411
2412     if (do_sigframe_return_v2(env,
2413                               frame_addr
2414                               + offsetof(struct rt_sigframe_v2, uc),
2415                               &frame->uc)) {
2416         goto badframe;
2417     }
2418
2419     unlock_user_struct(frame, frame_addr, 0);
2420     return -TARGET_QEMU_ESIGRETURN;
2421
2422 badframe:
2423     unlock_user_struct(frame, frame_addr, 0);
2424     force_sig(TARGET_SIGSEGV);
2425     return -TARGET_QEMU_ESIGRETURN;
2426 }
2427
2428 long do_rt_sigreturn(CPUARMState *env)
2429 {
2430     if (get_osversion() >= 0x020612) {
2431         return do_rt_sigreturn_v2(env);
2432     } else {
2433         return do_rt_sigreturn_v1(env);
2434     }
2435 }
2436
2437 #elif defined(TARGET_SPARC)
2438
2439 #define __SUNOS_MAXWIN   31
2440
2441 /* This is what SunOS does, so shall I. */
2442 struct target_sigcontext {
2443     abi_ulong sigc_onstack;      /* state to restore */
2444
2445     abi_ulong sigc_mask;         /* sigmask to restore */
2446     abi_ulong sigc_sp;           /* stack pointer */
2447     abi_ulong sigc_pc;           /* program counter */
2448     abi_ulong sigc_npc;          /* next program counter */
2449     abi_ulong sigc_psr;          /* for condition codes etc */
2450     abi_ulong sigc_g1;           /* User uses these two registers */
2451     abi_ulong sigc_o0;           /* within the trampoline code. */
2452
2453     /* Now comes information regarding the users window set
2454          * at the time of the signal.
2455          */
2456     abi_ulong sigc_oswins;       /* outstanding windows */
2457
2458     /* stack ptrs for each regwin buf */
2459     char *sigc_spbuf[__SUNOS_MAXWIN];
2460
2461     /* Windows to restore after signal */
2462     struct {
2463         abi_ulong locals[8];
2464         abi_ulong ins[8];
2465     } sigc_wbuf[__SUNOS_MAXWIN];
2466 };
2467 /* A Sparc stack frame */
2468 struct sparc_stackf {
2469     abi_ulong locals[8];
2470     abi_ulong ins[8];
2471     /* It's simpler to treat fp and callers_pc as elements of ins[]
2472          * since we never need to access them ourselves.
2473          */
2474     char *structptr;
2475     abi_ulong xargs[6];
2476     abi_ulong xxargs[1];
2477 };
2478
2479 typedef struct {
2480     struct {
2481         abi_ulong psr;
2482         abi_ulong pc;
2483         abi_ulong npc;
2484         abi_ulong y;
2485         abi_ulong u_regs[16]; /* globals and ins */
2486     }               si_regs;
2487     int             si_mask;
2488 } __siginfo_t;
2489
2490 typedef struct {
2491     abi_ulong  si_float_regs[32];
2492     unsigned   long si_fsr;
2493     unsigned   long si_fpqdepth;
2494     struct {
2495         unsigned long *insn_addr;
2496         unsigned long insn;
2497     } si_fpqueue [16];
2498 } qemu_siginfo_fpu_t;
2499
2500
2501 struct target_signal_frame {
2502     struct sparc_stackf ss;
2503     __siginfo_t         info;
2504     abi_ulong           fpu_save;
2505     abi_ulong           insns[2] __attribute__ ((aligned (8)));
2506     abi_ulong           extramask[TARGET_NSIG_WORDS - 1];
2507     abi_ulong           extra_size; /* Should be 0 */
2508     qemu_siginfo_fpu_t fpu_state;
2509 };
2510 struct target_rt_signal_frame {
2511     struct sparc_stackf ss;
2512     siginfo_t           info;
2513     abi_ulong           regs[20];
2514     sigset_t            mask;
2515     abi_ulong           fpu_save;
2516     unsigned int        insns[2];
2517     stack_t             stack;
2518     unsigned int        extra_size; /* Should be 0 */
2519     qemu_siginfo_fpu_t  fpu_state;
2520 };
2521
2522 #define UREG_O0        16
2523 #define UREG_O6        22
2524 #define UREG_I0        0
2525 #define UREG_I1        1
2526 #define UREG_I2        2
2527 #define UREG_I3        3
2528 #define UREG_I4        4
2529 #define UREG_I5        5
2530 #define UREG_I6        6
2531 #define UREG_I7        7
2532 #define UREG_L0        8
2533 #define UREG_FP        UREG_I6
2534 #define UREG_SP        UREG_O6
2535
2536 static inline abi_ulong get_sigframe(struct target_sigaction *sa,
2537                                      CPUSPARCState *env,
2538                                      unsigned long framesize)
2539 {
2540     abi_ulong sp;
2541
2542     sp = env->regwptr[UREG_FP];
2543
2544     /* This is the X/Open sanctioned signal stack switching.  */
2545     if (sa->sa_flags & TARGET_SA_ONSTACK) {
2546         if (!on_sig_stack(sp)
2547                 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7)) {
2548             sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2549         }
2550     }
2551     return sp - framesize;
2552 }
2553
2554 static int
2555 setup___siginfo(__siginfo_t *si, CPUSPARCState *env, abi_ulong mask)
2556 {
2557     int err = 0, i;
2558
2559     __put_user(env->psr, &si->si_regs.psr);
2560     __put_user(env->pc, &si->si_regs.pc);
2561     __put_user(env->npc, &si->si_regs.npc);
2562     __put_user(env->y, &si->si_regs.y);
2563     for (i=0; i < 8; i++) {
2564         __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
2565     }
2566     for (i=0; i < 8; i++) {
2567         __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
2568     }
2569     __put_user(mask, &si->si_mask);
2570     return err;
2571 }
2572
2573 #if 0
2574 static int
2575 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
2576                  CPUSPARCState *env, unsigned long mask)
2577 {
2578     int err = 0;
2579
2580     __put_user(mask, &sc->sigc_mask);
2581     __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
2582     __put_user(env->pc, &sc->sigc_pc);
2583     __put_user(env->npc, &sc->sigc_npc);
2584     __put_user(env->psr, &sc->sigc_psr);
2585     __put_user(env->gregs[1], &sc->sigc_g1);
2586     __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
2587
2588     return err;
2589 }
2590 #endif
2591 #define NF_ALIGNEDSZ  (((sizeof(struct target_signal_frame) + 7) & (~7)))
2592
2593 static void setup_frame(int sig, struct target_sigaction *ka,
2594                         target_sigset_t *set, CPUSPARCState *env)
2595 {
2596     abi_ulong sf_addr;
2597     struct target_signal_frame *sf;
2598     int sigframe_size, err, i;
2599
2600     /* 1. Make sure everything is clean */
2601     //synchronize_user_stack();
2602
2603     sigframe_size = NF_ALIGNEDSZ;
2604     sf_addr = get_sigframe(ka, env, sigframe_size);
2605     trace_user_setup_frame(env, sf_addr);
2606
2607     sf = lock_user(VERIFY_WRITE, sf_addr,
2608                    sizeof(struct target_signal_frame), 0);
2609     if (!sf) {
2610         goto sigsegv;
2611     }
2612 #if 0
2613     if (invalid_frame_pointer(sf, sigframe_size))
2614         goto sigill_and_return;
2615 #endif
2616     /* 2. Save the current process state */
2617     err = setup___siginfo(&sf->info, env, set->sig[0]);
2618     __put_user(0, &sf->extra_size);
2619
2620     //save_fpu_state(regs, &sf->fpu_state);
2621     //__put_user(&sf->fpu_state, &sf->fpu_save);
2622
2623     __put_user(set->sig[0], &sf->info.si_mask);
2624     for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
2625         __put_user(set->sig[i + 1], &sf->extramask[i]);
2626     }
2627
2628     for (i = 0; i < 8; i++) {
2629         __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
2630     }
2631     for (i = 0; i < 8; i++) {
2632         __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
2633     }
2634     if (err)
2635         goto sigsegv;
2636
2637     /* 3. signal handler back-trampoline and parameters */
2638     env->regwptr[UREG_FP] = sf_addr;
2639     env->regwptr[UREG_I0] = sig;
2640     env->regwptr[UREG_I1] = sf_addr +
2641             offsetof(struct target_signal_frame, info);
2642     env->regwptr[UREG_I2] = sf_addr +
2643             offsetof(struct target_signal_frame, info);
2644
2645     /* 4. signal handler */
2646     env->pc = ka->_sa_handler;
2647     env->npc = (env->pc + 4);
2648     /* 5. return to kernel instructions */
2649     if (ka->sa_restorer) {
2650         env->regwptr[UREG_I7] = ka->sa_restorer;
2651     } else {
2652         uint32_t val32;
2653
2654         env->regwptr[UREG_I7] = sf_addr +
2655                 offsetof(struct target_signal_frame, insns) - 2 * 4;
2656
2657         /* mov __NR_sigreturn, %g1 */
2658         val32 = 0x821020d8;
2659         __put_user(val32, &sf->insns[0]);
2660
2661         /* t 0x10 */
2662         val32 = 0x91d02010;
2663         __put_user(val32, &sf->insns[1]);
2664         if (err)
2665             goto sigsegv;
2666
2667         /* Flush instruction space. */
2668         // flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
2669         // tb_flush(env);
2670     }
2671     unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
2672     return;
2673 #if 0
2674 sigill_and_return:
2675     force_sig(TARGET_SIGILL);
2676 #endif
2677 sigsegv:
2678     unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
2679     force_sigsegv(sig);
2680 }
2681
2682 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2683                            target_siginfo_t *info,
2684                            target_sigset_t *set, CPUSPARCState *env)
2685 {
2686     fprintf(stderr, "setup_rt_frame: not implemented\n");
2687 }
2688
2689 long do_sigreturn(CPUSPARCState *env)
2690 {
2691     abi_ulong sf_addr;
2692     struct target_signal_frame *sf;
2693     uint32_t up_psr, pc, npc;
2694     target_sigset_t set;
2695     sigset_t host_set;
2696     int err=0, i;
2697
2698     sf_addr = env->regwptr[UREG_FP];
2699     trace_user_do_sigreturn(env, sf_addr);
2700     if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1)) {
2701         goto segv_and_exit;
2702     }
2703
2704     /* 1. Make sure we are not getting garbage from the user */
2705
2706     if (sf_addr & 3)
2707         goto segv_and_exit;
2708
2709     __get_user(pc,  &sf->info.si_regs.pc);
2710     __get_user(npc, &sf->info.si_regs.npc);
2711
2712     if ((pc | npc) & 3) {
2713         goto segv_and_exit;
2714     }
2715
2716     /* 2. Restore the state */
2717     __get_user(up_psr, &sf->info.si_regs.psr);
2718
2719     /* User can only change condition codes and FPU enabling in %psr. */
2720     env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
2721             | (env->psr & ~(PSR_ICC /* | PSR_EF */));
2722
2723     env->pc = pc;
2724     env->npc = npc;
2725     __get_user(env->y, &sf->info.si_regs.y);
2726     for (i=0; i < 8; i++) {
2727         __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
2728     }
2729     for (i=0; i < 8; i++) {
2730         __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
2731     }
2732
2733     /* FIXME: implement FPU save/restore:
2734          * __get_user(fpu_save, &sf->fpu_save);
2735          * if (fpu_save)
2736          *        err |= restore_fpu_state(env, fpu_save);
2737          */
2738
2739     /* This is pretty much atomic, no amount locking would prevent
2740          * the races which exist anyways.
2741          */
2742     __get_user(set.sig[0], &sf->info.si_mask);
2743     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
2744         __get_user(set.sig[i], &sf->extramask[i - 1]);
2745     }
2746
2747     target_to_host_sigset_internal(&host_set, &set);
2748     set_sigmask(&host_set);
2749
2750     if (err) {
2751         goto segv_and_exit;
2752     }
2753     unlock_user_struct(sf, sf_addr, 0);
2754     return -TARGET_QEMU_ESIGRETURN;
2755
2756 segv_and_exit:
2757     unlock_user_struct(sf, sf_addr, 0);
2758     force_sig(TARGET_SIGSEGV);
2759     return -TARGET_QEMU_ESIGRETURN;
2760 }
2761
2762 long do_rt_sigreturn(CPUSPARCState *env)
2763 {
2764     trace_user_do_rt_sigreturn(env, 0);
2765     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2766     return -TARGET_ENOSYS;
2767 }
2768
2769 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
2770 #define SPARC_MC_TSTATE 0
2771 #define SPARC_MC_PC 1
2772 #define SPARC_MC_NPC 2
2773 #define SPARC_MC_Y 3
2774 #define SPARC_MC_G1 4
2775 #define SPARC_MC_G2 5
2776 #define SPARC_MC_G3 6
2777 #define SPARC_MC_G4 7
2778 #define SPARC_MC_G5 8
2779 #define SPARC_MC_G6 9
2780 #define SPARC_MC_G7 10
2781 #define SPARC_MC_O0 11
2782 #define SPARC_MC_O1 12
2783 #define SPARC_MC_O2 13
2784 #define SPARC_MC_O3 14
2785 #define SPARC_MC_O4 15
2786 #define SPARC_MC_O5 16
2787 #define SPARC_MC_O6 17
2788 #define SPARC_MC_O7 18
2789 #define SPARC_MC_NGREG 19
2790
2791 typedef abi_ulong target_mc_greg_t;
2792 typedef target_mc_greg_t target_mc_gregset_t[SPARC_MC_NGREG];
2793
2794 struct target_mc_fq {
2795     abi_ulong *mcfq_addr;
2796     uint32_t mcfq_insn;
2797 };
2798
2799 struct target_mc_fpu {
2800     union {
2801         uint32_t sregs[32];
2802         uint64_t dregs[32];
2803         //uint128_t qregs[16];
2804     } mcfpu_fregs;
2805     abi_ulong mcfpu_fsr;
2806     abi_ulong mcfpu_fprs;
2807     abi_ulong mcfpu_gsr;
2808     struct target_mc_fq *mcfpu_fq;
2809     unsigned char mcfpu_qcnt;
2810     unsigned char mcfpu_qentsz;
2811     unsigned char mcfpu_enab;
2812 };
2813 typedef struct target_mc_fpu target_mc_fpu_t;
2814
2815 typedef struct {
2816     target_mc_gregset_t mc_gregs;
2817     target_mc_greg_t mc_fp;
2818     target_mc_greg_t mc_i7;
2819     target_mc_fpu_t mc_fpregs;
2820 } target_mcontext_t;
2821
2822 struct target_ucontext {
2823     struct target_ucontext *tuc_link;
2824     abi_ulong tuc_flags;
2825     target_sigset_t tuc_sigmask;
2826     target_mcontext_t tuc_mcontext;
2827 };
2828
2829 /* A V9 register window */
2830 struct target_reg_window {
2831     abi_ulong locals[8];
2832     abi_ulong ins[8];
2833 };
2834
2835 #define TARGET_STACK_BIAS 2047
2836
2837 /* {set, get}context() needed for 64-bit SparcLinux userland. */
2838 void sparc64_set_context(CPUSPARCState *env)
2839 {
2840     abi_ulong ucp_addr;
2841     struct target_ucontext *ucp;
2842     target_mc_gregset_t *grp;
2843     abi_ulong pc, npc, tstate;
2844     abi_ulong fp, i7, w_addr;
2845     unsigned int i;
2846
2847     ucp_addr = env->regwptr[UREG_I0];
2848     if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1)) {
2849         goto do_sigsegv;
2850     }
2851     grp  = &ucp->tuc_mcontext.mc_gregs;
2852     __get_user(pc, &((*grp)[SPARC_MC_PC]));
2853     __get_user(npc, &((*grp)[SPARC_MC_NPC]));
2854     if ((pc | npc) & 3) {
2855         goto do_sigsegv;
2856     }
2857     if (env->regwptr[UREG_I1]) {
2858         target_sigset_t target_set;
2859         sigset_t set;
2860
2861         if (TARGET_NSIG_WORDS == 1) {
2862             __get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]);
2863         } else {
2864             abi_ulong *src, *dst;
2865             src = ucp->tuc_sigmask.sig;
2866             dst = target_set.sig;
2867             for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
2868                 __get_user(*dst, src);
2869             }
2870         }
2871         target_to_host_sigset_internal(&set, &target_set);
2872         set_sigmask(&set);
2873     }
2874     env->pc = pc;
2875     env->npc = npc;
2876     __get_user(env->y, &((*grp)[SPARC_MC_Y]));
2877     __get_user(tstate, &((*grp)[SPARC_MC_TSTATE]));
2878     env->asi = (tstate >> 24) & 0xff;
2879     cpu_put_ccr(env, tstate >> 32);
2880     cpu_put_cwp64(env, tstate & 0x1f);
2881     __get_user(env->gregs[1], (&(*grp)[SPARC_MC_G1]));
2882     __get_user(env->gregs[2], (&(*grp)[SPARC_MC_G2]));
2883     __get_user(env->gregs[3], (&(*grp)[SPARC_MC_G3]));
2884     __get_user(env->gregs[4], (&(*grp)[SPARC_MC_G4]));
2885     __get_user(env->gregs[5], (&(*grp)[SPARC_MC_G5]));
2886     __get_user(env->gregs[6], (&(*grp)[SPARC_MC_G6]));
2887     __get_user(env->gregs[7], (&(*grp)[SPARC_MC_G7]));
2888     __get_user(env->regwptr[UREG_I0], (&(*grp)[SPARC_MC_O0]));
2889     __get_user(env->regwptr[UREG_I1], (&(*grp)[SPARC_MC_O1]));
2890     __get_user(env->regwptr[UREG_I2], (&(*grp)[SPARC_MC_O2]));
2891     __get_user(env->regwptr[UREG_I3], (&(*grp)[SPARC_MC_O3]));
2892     __get_user(env->regwptr[UREG_I4], (&(*grp)[SPARC_MC_O4]));
2893     __get_user(env->regwptr[UREG_I5], (&(*grp)[SPARC_MC_O5]));
2894     __get_user(env->regwptr[UREG_I6], (&(*grp)[SPARC_MC_O6]));
2895     __get_user(env->regwptr[UREG_I7], (&(*grp)[SPARC_MC_O7]));
2896
2897     __get_user(fp, &(ucp->tuc_mcontext.mc_fp));
2898     __get_user(i7, &(ucp->tuc_mcontext.mc_i7));
2899
2900     w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2901     if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2902                  abi_ulong) != 0) {
2903         goto do_sigsegv;
2904     }
2905     if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2906                  abi_ulong) != 0) {
2907         goto do_sigsegv;
2908     }
2909     /* FIXME this does not match how the kernel handles the FPU in
2910      * its sparc64_set_context implementation. In particular the FPU
2911      * is only restored if fenab is non-zero in:
2912      *   __get_user(fenab, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_enab));
2913      */
2914     __get_user(env->fprs, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fprs));
2915     {
2916         uint32_t *src = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2917         for (i = 0; i < 64; i++, src++) {
2918             if (i & 1) {
2919                 __get_user(env->fpr[i/2].l.lower, src);
2920             } else {
2921                 __get_user(env->fpr[i/2].l.upper, src);
2922             }
2923         }
2924     }
2925     __get_user(env->fsr,
2926                &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fsr));
2927     __get_user(env->gsr,
2928                &(ucp->tuc_mcontext.mc_fpregs.mcfpu_gsr));
2929     unlock_user_struct(ucp, ucp_addr, 0);
2930     return;
2931 do_sigsegv:
2932     unlock_user_struct(ucp, ucp_addr, 0);
2933     force_sig(TARGET_SIGSEGV);
2934 }
2935
2936 void sparc64_get_context(CPUSPARCState *env)
2937 {
2938     abi_ulong ucp_addr;
2939     struct target_ucontext *ucp;
2940     target_mc_gregset_t *grp;
2941     target_mcontext_t *mcp;
2942     abi_ulong fp, i7, w_addr;
2943     int err;
2944     unsigned int i;
2945     target_sigset_t target_set;
2946     sigset_t set;
2947
2948     ucp_addr = env->regwptr[UREG_I0];
2949     if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0)) {
2950         goto do_sigsegv;
2951     }
2952
2953     mcp = &ucp->tuc_mcontext;
2954     grp = &mcp->mc_gregs;
2955
2956     /* Skip over the trap instruction, first. */
2957     env->pc = env->npc;
2958     env->npc += 4;
2959
2960     /* If we're only reading the signal mask then do_sigprocmask()
2961      * is guaranteed not to fail, which is important because we don't
2962      * have any way to signal a failure or restart this operation since
2963      * this is not a normal syscall.
2964      */
2965     err = do_sigprocmask(0, NULL, &set);
2966     assert(err == 0);
2967     host_to_target_sigset_internal(&target_set, &set);
2968     if (TARGET_NSIG_WORDS == 1) {
2969         __put_user(target_set.sig[0],
2970                    (abi_ulong *)&ucp->tuc_sigmask);
2971     } else {
2972         abi_ulong *src, *dst;
2973         src = target_set.sig;
2974         dst = ucp->tuc_sigmask.sig;
2975         for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
2976             __put_user(*src, dst);
2977         }
2978         if (err)
2979             goto do_sigsegv;
2980     }
2981
2982     /* XXX: tstate must be saved properly */
2983     //    __put_user(env->tstate, &((*grp)[SPARC_MC_TSTATE]));
2984     __put_user(env->pc, &((*grp)[SPARC_MC_PC]));
2985     __put_user(env->npc, &((*grp)[SPARC_MC_NPC]));
2986     __put_user(env->y, &((*grp)[SPARC_MC_Y]));
2987     __put_user(env->gregs[1], &((*grp)[SPARC_MC_G1]));
2988     __put_user(env->gregs[2], &((*grp)[SPARC_MC_G2]));
2989     __put_user(env->gregs[3], &((*grp)[SPARC_MC_G3]));
2990     __put_user(env->gregs[4], &((*grp)[SPARC_MC_G4]));
2991     __put_user(env->gregs[5], &((*grp)[SPARC_MC_G5]));
2992     __put_user(env->gregs[6], &((*grp)[SPARC_MC_G6]));
2993     __put_user(env->gregs[7], &((*grp)[SPARC_MC_G7]));
2994     __put_user(env->regwptr[UREG_I0], &((*grp)[SPARC_MC_O0]));
2995     __put_user(env->regwptr[UREG_I1], &((*grp)[SPARC_MC_O1]));
2996     __put_user(env->regwptr[UREG_I2], &((*grp)[SPARC_MC_O2]));
2997     __put_user(env->regwptr[UREG_I3], &((*grp)[SPARC_MC_O3]));
2998     __put_user(env->regwptr[UREG_I4], &((*grp)[SPARC_MC_O4]));
2999     __put_user(env->regwptr[UREG_I5], &((*grp)[SPARC_MC_O5]));
3000     __put_user(env->regwptr[UREG_I6], &((*grp)[SPARC_MC_O6]));
3001     __put_user(env->regwptr[UREG_I7], &((*grp)[SPARC_MC_O7]));
3002
3003     w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
3004     fp = i7 = 0;
3005     if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
3006                  abi_ulong) != 0) {
3007         goto do_sigsegv;
3008     }
3009     if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
3010                  abi_ulong) != 0) {
3011         goto do_sigsegv;
3012     }
3013     __put_user(fp, &(mcp->mc_fp));
3014     __put_user(i7, &(mcp->mc_i7));
3015
3016     {
3017         uint32_t *dst = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
3018         for (i = 0; i < 64; i++, dst++) {
3019             if (i & 1) {
3020                 __put_user(env->fpr[i/2].l.lower, dst);
3021             } else {
3022                 __put_user(env->fpr[i/2].l.upper, dst);
3023             }
3024         }
3025     }
3026     __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr));
3027     __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr));
3028     __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs));
3029
3030     if (err)
3031         goto do_sigsegv;
3032     unlock_user_struct(ucp, ucp_addr, 1);
3033     return;
3034 do_sigsegv:
3035     unlock_user_struct(ucp, ucp_addr, 1);
3036     force_sig(TARGET_SIGSEGV);
3037 }
3038 #endif
3039 #elif defined(TARGET_MIPS) || defined(TARGET_MIPS64)
3040
3041 # if defined(TARGET_ABI_MIPSO32)
3042 struct target_sigcontext {
3043     uint32_t   sc_regmask;     /* Unused */
3044     uint32_t   sc_status;
3045     uint64_t   sc_pc;
3046     uint64_t   sc_regs[32];
3047     uint64_t   sc_fpregs[32];
3048     uint32_t   sc_ownedfp;     /* Unused */
3049     uint32_t   sc_fpc_csr;
3050     uint32_t   sc_fpc_eir;     /* Unused */
3051     uint32_t   sc_used_math;
3052     uint32_t   sc_dsp;         /* dsp status, was sc_ssflags */
3053     uint32_t   pad0;
3054     uint64_t   sc_mdhi;
3055     uint64_t   sc_mdlo;
3056     target_ulong   sc_hi1;         /* Was sc_cause */
3057     target_ulong   sc_lo1;         /* Was sc_badvaddr */
3058     target_ulong   sc_hi2;         /* Was sc_sigset[4] */
3059     target_ulong   sc_lo2;
3060     target_ulong   sc_hi3;
3061     target_ulong   sc_lo3;
3062 };
3063 # else /* N32 || N64 */
3064 struct target_sigcontext {
3065     uint64_t sc_regs[32];
3066     uint64_t sc_fpregs[32];
3067     uint64_t sc_mdhi;
3068     uint64_t sc_hi1;
3069     uint64_t sc_hi2;
3070     uint64_t sc_hi3;
3071     uint64_t sc_mdlo;
3072     uint64_t sc_lo1;
3073     uint64_t sc_lo2;
3074     uint64_t sc_lo3;
3075     uint64_t sc_pc;
3076     uint32_t sc_fpc_csr;
3077     uint32_t sc_used_math;
3078     uint32_t sc_dsp;
3079     uint32_t sc_reserved;
3080 };
3081 # endif /* O32 */
3082
3083 struct sigframe {
3084     uint32_t sf_ass[4];                 /* argument save space for o32 */
3085     uint32_t sf_code[2];                        /* signal trampoline */
3086     struct target_sigcontext sf_sc;
3087     target_sigset_t sf_mask;
3088 };
3089
3090 struct target_ucontext {
3091     target_ulong tuc_flags;
3092     target_ulong tuc_link;
3093     target_stack_t tuc_stack;
3094     target_ulong pad0;
3095     struct target_sigcontext tuc_mcontext;
3096     target_sigset_t tuc_sigmask;
3097 };
3098
3099 struct target_rt_sigframe {
3100     uint32_t rs_ass[4];               /* argument save space for o32 */
3101     uint32_t rs_code[2];              /* signal trampoline */
3102     struct target_siginfo rs_info;
3103     struct target_ucontext rs_uc;
3104 };
3105
3106 /* Install trampoline to jump back from signal handler */
3107 static inline int install_sigtramp(unsigned int *tramp,   unsigned int syscall)
3108 {
3109     int err = 0;
3110
3111     /*
3112      * Set up the return code ...
3113      *
3114      *         li      v0, __NR__foo_sigreturn
3115      *         syscall
3116      */
3117
3118     __put_user(0x24020000 + syscall, tramp + 0);
3119     __put_user(0x0000000c          , tramp + 1);
3120     return err;
3121 }
3122
3123 static inline void setup_sigcontext(CPUMIPSState *regs,
3124                                     struct target_sigcontext *sc)
3125 {
3126     int i;
3127
3128     __put_user(exception_resume_pc(regs), &sc->sc_pc);
3129     regs->hflags &= ~MIPS_HFLAG_BMASK;
3130
3131     __put_user(0, &sc->sc_regs[0]);
3132     for (i = 1; i < 32; ++i) {
3133         __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);
3134     }
3135
3136     __put_user(regs->active_tc.HI[0], &sc->sc_mdhi);
3137     __put_user(regs->active_tc.LO[0], &sc->sc_mdlo);
3138
3139     /* Rather than checking for dsp existence, always copy.  The storage
3140        would just be garbage otherwise.  */
3141     __put_user(regs->active_tc.HI[1], &sc->sc_hi1);
3142     __put_user(regs->active_tc.HI[2], &sc->sc_hi2);
3143     __put_user(regs->active_tc.HI[3], &sc->sc_hi3);
3144     __put_user(regs->active_tc.LO[1], &sc->sc_lo1);
3145     __put_user(regs->active_tc.LO[2], &sc->sc_lo2);
3146     __put_user(regs->active_tc.LO[3], &sc->sc_lo3);
3147     {
3148         uint32_t dsp = cpu_rddsp(0x3ff, regs);
3149         __put_user(dsp, &sc->sc_dsp);
3150     }
3151
3152     __put_user(1, &sc->sc_used_math);
3153
3154     for (i = 0; i < 32; ++i) {
3155         __put_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]);
3156     }
3157 }
3158
3159 static inline void
3160 restore_sigcontext(CPUMIPSState *regs, struct target_sigcontext *sc)
3161 {
3162     int i;
3163
3164     __get_user(regs->CP0_EPC, &sc->sc_pc);
3165
3166     __get_user(regs->active_tc.HI[0], &sc->sc_mdhi);
3167     __get_user(regs->active_tc.LO[0], &sc->sc_mdlo);
3168
3169     for (i = 1; i < 32; ++i) {
3170         __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);
3171     }
3172
3173     __get_user(regs->active_tc.HI[1], &sc->sc_hi1);
3174     __get_user(regs->active_tc.HI[2], &sc->sc_hi2);
3175     __get_user(regs->active_tc.HI[3], &sc->sc_hi3);
3176     __get_user(regs->active_tc.LO[1], &sc->sc_lo1);
3177     __get_user(regs->active_tc.LO[2], &sc->sc_lo2);
3178     __get_user(regs->active_tc.LO[3], &sc->sc_lo3);
3179     {
3180         uint32_t dsp;
3181         __get_user(dsp, &sc->sc_dsp);
3182         cpu_wrdsp(dsp, 0x3ff, regs);
3183     }
3184
3185     for (i = 0; i < 32; ++i) {
3186         __get_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]);
3187     }
3188 }
3189
3190 /*
3191  * Determine which stack to use..
3192  */
3193 static inline abi_ulong
3194 get_sigframe(struct target_sigaction *ka, CPUMIPSState *regs, size_t frame_size)
3195 {
3196     unsigned long sp;
3197
3198     /* Default to using normal stack */
3199     sp = regs->active_tc.gpr[29];
3200
3201     /*
3202      * FPU emulator may have its own trampoline active just
3203      * above the user stack, 16-bytes before the next lowest
3204      * 16 byte boundary.  Try to avoid trashing it.
3205      */
3206     sp -= 32;
3207
3208     /* This is the X/Open sanctioned signal stack switching.  */
3209     if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
3210         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3211     }
3212
3213     return (sp - frame_size) & ~7;
3214 }
3215
3216 static void mips_set_hflags_isa_mode_from_pc(CPUMIPSState *env)
3217 {
3218     if (env->insn_flags & (ASE_MIPS16 | ASE_MICROMIPS)) {
3219         env->hflags &= ~MIPS_HFLAG_M16;
3220         env->hflags |= (env->active_tc.PC & 1) << MIPS_HFLAG_M16_SHIFT;
3221         env->active_tc.PC &= ~(target_ulong) 1;
3222     }
3223 }
3224
3225 # if defined(TARGET_ABI_MIPSO32)
3226 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */
3227 static void setup_frame(int sig, struct target_sigaction * ka,
3228                         target_sigset_t *set, CPUMIPSState *regs)
3229 {
3230     struct sigframe *frame;
3231     abi_ulong frame_addr;
3232     int i;
3233
3234     frame_addr = get_sigframe(ka, regs, sizeof(*frame));
3235     trace_user_setup_frame(regs, frame_addr);
3236     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3237         goto give_sigsegv;
3238     }
3239
3240     install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
3241
3242     setup_sigcontext(regs, &frame->sf_sc);
3243
3244     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3245         __put_user(set->sig[i], &frame->sf_mask.sig[i]);
3246     }
3247
3248     /*
3249     * Arguments to signal handler:
3250     *
3251     *   a0 = signal number
3252     *   a1 = 0 (should be cause)
3253     *   a2 = pointer to struct sigcontext
3254     *
3255     * $25 and PC point to the signal handler, $29 points to the
3256     * struct sigframe.
3257     */
3258     regs->active_tc.gpr[ 4] = sig;
3259     regs->active_tc.gpr[ 5] = 0;
3260     regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc);
3261     regs->active_tc.gpr[29] = frame_addr;
3262     regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code);
3263     /* The original kernel code sets CP0_EPC to the handler
3264     * since it returns to userland using eret
3265     * we cannot do this here, and we must set PC directly */
3266     regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler;
3267     mips_set_hflags_isa_mode_from_pc(regs);
3268     unlock_user_struct(frame, frame_addr, 1);
3269     return;
3270
3271 give_sigsegv:
3272     force_sigsegv(sig);
3273 }
3274
3275 long do_sigreturn(CPUMIPSState *regs)
3276 {
3277     struct sigframe *frame;
3278     abi_ulong frame_addr;
3279     sigset_t blocked;
3280     target_sigset_t target_set;
3281     int i;
3282
3283     frame_addr = regs->active_tc.gpr[29];
3284     trace_user_do_sigreturn(regs, frame_addr);
3285     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3286         goto badframe;
3287
3288     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3289         __get_user(target_set.sig[i], &frame->sf_mask.sig[i]);
3290     }
3291
3292     target_to_host_sigset_internal(&blocked, &target_set);
3293     set_sigmask(&blocked);
3294
3295     restore_sigcontext(regs, &frame->sf_sc);
3296
3297 #if 0
3298     /*
3299      * Don't let your children do this ...
3300      */
3301     __asm__ __volatile__(
3302         "move\t$29, %0\n\t"
3303         "j\tsyscall_exit"
3304         :/* no outputs */
3305         :"r" (&regs));
3306     /* Unreached */
3307 #endif
3308
3309     regs->active_tc.PC = regs->CP0_EPC;
3310     mips_set_hflags_isa_mode_from_pc(regs);
3311     /* I am not sure this is right, but it seems to work
3312     * maybe a problem with nested signals ? */
3313     regs->CP0_EPC = 0;
3314     return -TARGET_QEMU_ESIGRETURN;
3315
3316 badframe:
3317     force_sig(TARGET_SIGSEGV);
3318     return -TARGET_QEMU_ESIGRETURN;
3319 }
3320 # endif /* O32 */
3321
3322 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3323                            target_siginfo_t *info,
3324                            target_sigset_t *set, CPUMIPSState *env)
3325 {
3326     struct target_rt_sigframe *frame;
3327     abi_ulong frame_addr;
3328     int i;
3329
3330     frame_addr = get_sigframe(ka, env, sizeof(*frame));
3331     trace_user_setup_rt_frame(env, frame_addr);
3332     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3333         goto give_sigsegv;
3334     }
3335
3336     install_sigtramp(frame->rs_code, TARGET_NR_rt_sigreturn);
3337
3338     tswap_siginfo(&frame->rs_info, info);
3339
3340     __put_user(0, &frame->rs_uc.tuc_flags);
3341     __put_user(0, &frame->rs_uc.tuc_link);
3342     __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.tuc_stack.ss_sp);
3343     __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.tuc_stack.ss_size);
3344     __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
3345                &frame->rs_uc.tuc_stack.ss_flags);
3346
3347     setup_sigcontext(env, &frame->rs_uc.tuc_mcontext);
3348
3349     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3350         __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]);
3351     }
3352
3353     /*
3354     * Arguments to signal handler:
3355     *
3356     *   a0 = signal number
3357     *   a1 = pointer to siginfo_t
3358     *   a2 = pointer to ucontext_t
3359     *
3360     * $25 and PC point to the signal handler, $29 points to the
3361     * struct sigframe.
3362     */
3363     env->active_tc.gpr[ 4] = sig;
3364     env->active_tc.gpr[ 5] = frame_addr
3365                              + offsetof(struct target_rt_sigframe, rs_info);
3366     env->active_tc.gpr[ 6] = frame_addr
3367                              + offsetof(struct target_rt_sigframe, rs_uc);
3368     env->active_tc.gpr[29] = frame_addr;
3369     env->active_tc.gpr[31] = frame_addr
3370                              + offsetof(struct target_rt_sigframe, rs_code);
3371     /* The original kernel code sets CP0_EPC to the handler
3372     * since it returns to userland using eret
3373     * we cannot do this here, and we must set PC directly */
3374     env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler;
3375     mips_set_hflags_isa_mode_from_pc(env);
3376     unlock_user_struct(frame, frame_addr, 1);
3377     return;
3378
3379 give_sigsegv:
3380     unlock_user_struct(frame, frame_addr, 1);
3381     force_sigsegv(sig);
3382 }
3383
3384 long do_rt_sigreturn(CPUMIPSState *env)
3385 {
3386     struct target_rt_sigframe *frame;
3387     abi_ulong frame_addr;
3388     sigset_t blocked;
3389
3390     frame_addr = env->active_tc.gpr[29];
3391     trace_user_do_rt_sigreturn(env, frame_addr);
3392     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
3393         goto badframe;
3394     }
3395
3396     target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask);
3397     set_sigmask(&blocked);
3398
3399     restore_sigcontext(env, &frame->rs_uc.tuc_mcontext);
3400
3401     if (do_sigaltstack(frame_addr +
3402                        offsetof(struct target_rt_sigframe, rs_uc.tuc_stack),
3403                        0, get_sp_from_cpustate(env)) == -EFAULT)
3404         goto badframe;
3405
3406     env->active_tc.PC = env->CP0_EPC;
3407     mips_set_hflags_isa_mode_from_pc(env);
3408     /* I am not sure this is right, but it seems to work
3409     * maybe a problem with nested signals ? */
3410     env->CP0_EPC = 0;
3411     return -TARGET_QEMU_ESIGRETURN;
3412
3413 badframe:
3414     force_sig(TARGET_SIGSEGV);
3415     return -TARGET_QEMU_ESIGRETURN;
3416 }
3417
3418 #elif defined(TARGET_SH4)
3419
3420 /*
3421  * code and data structures from linux kernel:
3422  * include/asm-sh/sigcontext.h
3423  * arch/sh/kernel/signal.c
3424  */
3425
3426 struct target_sigcontext {
3427     target_ulong  oldmask;
3428
3429     /* CPU registers */
3430     target_ulong  sc_gregs[16];
3431     target_ulong  sc_pc;
3432     target_ulong  sc_pr;
3433     target_ulong  sc_sr;
3434     target_ulong  sc_gbr;
3435     target_ulong  sc_mach;
3436     target_ulong  sc_macl;
3437
3438     /* FPU registers */
3439     target_ulong  sc_fpregs[16];
3440     target_ulong  sc_xfpregs[16];
3441     unsigned int sc_fpscr;
3442     unsigned int sc_fpul;
3443     unsigned int sc_ownedfp;
3444 };
3445
3446 struct target_sigframe
3447 {
3448     struct target_sigcontext sc;
3449     target_ulong extramask[TARGET_NSIG_WORDS-1];
3450     uint16_t retcode[3];
3451 };
3452
3453
3454 struct target_ucontext {
3455     target_ulong tuc_flags;
3456     struct target_ucontext *tuc_link;
3457     target_stack_t tuc_stack;
3458     struct target_sigcontext tuc_mcontext;
3459     target_sigset_t tuc_sigmask;        /* mask last for extensibility */
3460 };
3461
3462 struct target_rt_sigframe
3463 {
3464     struct target_siginfo info;
3465     struct target_ucontext uc;
3466     uint16_t retcode[3];
3467 };
3468
3469
3470 #define MOVW(n)  (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
3471 #define TRAP_NOARG 0xc310         /* Syscall w/no args (NR in R3) SH3/4 */
3472
3473 static abi_ulong get_sigframe(struct target_sigaction *ka,
3474                               unsigned long sp, size_t frame_size)
3475 {
3476     if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) {
3477         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3478     }
3479
3480     return (sp - frame_size) & -8ul;
3481 }
3482
3483 /* Notice when we're in the middle of a gUSA region and reset.
3484    Note that this will only occur for !parallel_cpus, as we will
3485    translate such sequences differently in a parallel context.  */
3486 static void unwind_gusa(CPUSH4State *regs)
3487 {
3488     /* If the stack pointer is sufficiently negative, and we haven't
3489        completed the sequence, then reset to the entry to the region.  */
3490     /* ??? The SH4 kernel checks for and address above 0xC0000000.
3491        However, the page mappings in qemu linux-user aren't as restricted
3492        and we wind up with the normal stack mapped above 0xF0000000.
3493        That said, there is no reason why the kernel should be allowing
3494        a gUSA region that spans 1GB.  Use a tighter check here, for what
3495        can actually be enabled by the immediate move.  */
3496     if (regs->gregs[15] >= -128u && regs->pc < regs->gregs[0]) {
3497         /* Reset the PC to before the gUSA region, as computed from
3498            R0 = region end, SP = -(region size), plus one more for the
3499            insn that actually initializes SP to the region size.  */
3500         regs->pc = regs->gregs[0] + regs->gregs[15] - 2;
3501
3502         /* Reset the SP to the saved version in R1.  */
3503         regs->gregs[15] = regs->gregs[1];
3504     }
3505 }
3506
3507 static void setup_sigcontext(struct target_sigcontext *sc,
3508                              CPUSH4State *regs, unsigned long mask)
3509 {
3510     int i;
3511
3512 #define COPY(x)         __put_user(regs->x, &sc->sc_##x)
3513     COPY(gregs[0]); COPY(gregs[1]);
3514     COPY(gregs[2]); COPY(gregs[3]);
3515     COPY(gregs[4]); COPY(gregs[5]);
3516     COPY(gregs[6]); COPY(gregs[7]);
3517     COPY(gregs[8]); COPY(gregs[9]);
3518     COPY(gregs[10]); COPY(gregs[11]);
3519     COPY(gregs[12]); COPY(gregs[13]);
3520     COPY(gregs[14]); COPY(gregs[15]);
3521     COPY(gbr); COPY(mach);
3522     COPY(macl); COPY(pr);
3523     COPY(sr); COPY(pc);
3524 #undef COPY
3525
3526     for (i=0; i<16; i++) {
3527         __put_user(regs->fregs[i], &sc->sc_fpregs[i]);
3528     }
3529     __put_user(regs->fpscr, &sc->sc_fpscr);
3530     __put_user(regs->fpul, &sc->sc_fpul);
3531
3532     /* non-iBCS2 extensions.. */
3533     __put_user(mask, &sc->oldmask);
3534 }
3535
3536 static void restore_sigcontext(CPUSH4State *regs, struct target_sigcontext *sc)
3537 {
3538     int i;
3539
3540 #define COPY(x)         __get_user(regs->x, &sc->sc_##x)
3541     COPY(gregs[0]); COPY(gregs[1]);
3542     COPY(gregs[2]); COPY(gregs[3]);
3543     COPY(gregs[4]); COPY(gregs[5]);
3544     COPY(gregs[6]); COPY(gregs[7]);
3545     COPY(gregs[8]); COPY(gregs[9]);
3546     COPY(gregs[10]); COPY(gregs[11]);
3547     COPY(gregs[12]); COPY(gregs[13]);
3548     COPY(gregs[14]); COPY(gregs[15]);
3549     COPY(gbr); COPY(mach);
3550     COPY(macl); COPY(pr);
3551     COPY(sr); COPY(pc);
3552 #undef COPY
3553
3554     for (i=0; i<16; i++) {
3555         __get_user(regs->fregs[i], &sc->sc_fpregs[i]);
3556     }
3557     __get_user(regs->fpscr, &sc->sc_fpscr);
3558     __get_user(regs->fpul, &sc->sc_fpul);
3559
3560     regs->tra = -1;         /* disable syscall checks */
3561     regs->flags &= ~(DELAY_SLOT_MASK | GUSA_MASK);
3562 }
3563
3564 static void setup_frame(int sig, struct target_sigaction *ka,
3565                         target_sigset_t *set, CPUSH4State *regs)
3566 {
3567     struct target_sigframe *frame;
3568     abi_ulong frame_addr;
3569     int i;
3570
3571     unwind_gusa(regs);
3572
3573     frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3574     trace_user_setup_frame(regs, frame_addr);
3575     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3576         goto give_sigsegv;
3577     }
3578
3579     setup_sigcontext(&frame->sc, regs, set->sig[0]);
3580
3581     for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
3582         __put_user(set->sig[i + 1], &frame->extramask[i]);
3583     }
3584
3585     /* Set up to return from userspace.  If provided, use a stub
3586        already in userspace.  */
3587     if (ka->sa_flags & TARGET_SA_RESTORER) {
3588         regs->pr = (unsigned long) ka->sa_restorer;
3589     } else {
3590         /* Generate return code (system call to sigreturn) */
3591         abi_ulong retcode_addr = frame_addr +
3592                                  offsetof(struct target_sigframe, retcode);
3593         __put_user(MOVW(2), &frame->retcode[0]);
3594         __put_user(TRAP_NOARG, &frame->retcode[1]);
3595         __put_user((TARGET_NR_sigreturn), &frame->retcode[2]);
3596         regs->pr = (unsigned long) retcode_addr;
3597     }
3598
3599     /* Set up registers for signal handler */
3600     regs->gregs[15] = frame_addr;
3601     regs->gregs[4] = sig; /* Arg for signal handler */
3602     regs->gregs[5] = 0;
3603     regs->gregs[6] = frame_addr += offsetof(typeof(*frame), sc);
3604     regs->pc = (unsigned long) ka->_sa_handler;
3605     regs->flags &= ~(DELAY_SLOT_MASK | GUSA_MASK);
3606
3607     unlock_user_struct(frame, frame_addr, 1);
3608     return;
3609
3610 give_sigsegv:
3611     unlock_user_struct(frame, frame_addr, 1);
3612     force_sigsegv(sig);
3613 }
3614
3615 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3616                            target_siginfo_t *info,
3617                            target_sigset_t *set, CPUSH4State *regs)
3618 {
3619     struct target_rt_sigframe *frame;
3620     abi_ulong frame_addr;
3621     int i;
3622
3623     unwind_gusa(regs);
3624
3625     frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3626     trace_user_setup_rt_frame(regs, frame_addr);
3627     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3628         goto give_sigsegv;
3629     }
3630
3631     tswap_siginfo(&frame->info, info);
3632
3633     /* Create the ucontext.  */
3634     __put_user(0, &frame->uc.tuc_flags);
3635     __put_user(0, (unsigned long *)&frame->uc.tuc_link);
3636     __put_user((unsigned long)target_sigaltstack_used.ss_sp,
3637                &frame->uc.tuc_stack.ss_sp);
3638     __put_user(sas_ss_flags(regs->gregs[15]),
3639                &frame->uc.tuc_stack.ss_flags);
3640     __put_user(target_sigaltstack_used.ss_size,
3641                &frame->uc.tuc_stack.ss_size);
3642     setup_sigcontext(&frame->uc.tuc_mcontext,
3643                      regs, set->sig[0]);
3644     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3645         __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
3646     }
3647
3648     /* Set up to return from userspace.  If provided, use a stub
3649        already in userspace.  */
3650     if (ka->sa_flags & TARGET_SA_RESTORER) {
3651         regs->pr = (unsigned long) ka->sa_restorer;
3652     } else {
3653         /* Generate return code (system call to sigreturn) */
3654         abi_ulong retcode_addr = frame_addr +
3655                                  offsetof(struct target_rt_sigframe, retcode);
3656         __put_user(MOVW(2), &frame->retcode[0]);
3657         __put_user(TRAP_NOARG, &frame->retcode[1]);
3658         __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]);
3659         regs->pr = (unsigned long) retcode_addr;
3660     }
3661
3662     /* Set up registers for signal handler */
3663     regs->gregs[15] = frame_addr;
3664     regs->gregs[4] = sig; /* Arg for signal handler */
3665     regs->gregs[5] = frame_addr + offsetof(typeof(*frame), info);
3666     regs->gregs[6] = frame_addr + offsetof(typeof(*frame), uc);
3667     regs->pc = (unsigned long) ka->_sa_handler;
3668     regs->flags &= ~(DELAY_SLOT_MASK | GUSA_MASK);
3669
3670     unlock_user_struct(frame, frame_addr, 1);
3671     return;
3672
3673 give_sigsegv:
3674     unlock_user_struct(frame, frame_addr, 1);
3675     force_sigsegv(sig);
3676 }
3677
3678 long do_sigreturn(CPUSH4State *regs)
3679 {
3680     struct target_sigframe *frame;
3681     abi_ulong frame_addr;
3682     sigset_t blocked;
3683     target_sigset_t target_set;
3684     int i;
3685     int err = 0;
3686
3687     frame_addr = regs->gregs[15];
3688     trace_user_do_sigreturn(regs, frame_addr);
3689     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
3690         goto badframe;
3691     }
3692
3693     __get_user(target_set.sig[0], &frame->sc.oldmask);
3694     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3695         __get_user(target_set.sig[i], &frame->extramask[i - 1]);
3696     }
3697
3698     if (err)
3699         goto badframe;
3700
3701     target_to_host_sigset_internal(&blocked, &target_set);
3702     set_sigmask(&blocked);
3703
3704     restore_sigcontext(regs, &frame->sc);
3705
3706     unlock_user_struct(frame, frame_addr, 0);
3707     return -TARGET_QEMU_ESIGRETURN;
3708
3709 badframe:
3710     unlock_user_struct(frame, frame_addr, 0);
3711     force_sig(TARGET_SIGSEGV);
3712     return -TARGET_QEMU_ESIGRETURN;
3713 }
3714
3715 long do_rt_sigreturn(CPUSH4State *regs)
3716 {
3717     struct target_rt_sigframe *frame;
3718     abi_ulong frame_addr;
3719     sigset_t blocked;
3720
3721     frame_addr = regs->gregs[15];
3722     trace_user_do_rt_sigreturn(regs, frame_addr);
3723     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
3724         goto badframe;
3725     }
3726
3727     target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask);
3728     set_sigmask(&blocked);
3729
3730     restore_sigcontext(regs, &frame->uc.tuc_mcontext);
3731
3732     if (do_sigaltstack(frame_addr +
3733                        offsetof(struct target_rt_sigframe, uc.tuc_stack),
3734                        0, get_sp_from_cpustate(regs)) == -EFAULT) {
3735         goto badframe;
3736     }
3737
3738     unlock_user_struct(frame, frame_addr, 0);
3739     return -TARGET_QEMU_ESIGRETURN;
3740
3741 badframe:
3742     unlock_user_struct(frame, frame_addr, 0);
3743     force_sig(TARGET_SIGSEGV);
3744     return -TARGET_QEMU_ESIGRETURN;
3745 }
3746 #elif defined(TARGET_MICROBLAZE)
3747
3748 struct target_sigcontext {
3749     struct target_pt_regs regs;  /* needs to be first */
3750     uint32_t oldmask;
3751 };
3752
3753 struct target_stack_t {
3754     abi_ulong ss_sp;
3755     int ss_flags;
3756     unsigned int ss_size;
3757 };
3758
3759 struct target_ucontext {
3760     abi_ulong tuc_flags;
3761     abi_ulong tuc_link;
3762     struct target_stack_t tuc_stack;
3763     struct target_sigcontext tuc_mcontext;
3764     uint32_t tuc_extramask[TARGET_NSIG_WORDS - 1];
3765 };
3766
3767 /* Signal frames. */
3768 struct target_signal_frame {
3769     struct target_ucontext uc;
3770     uint32_t extramask[TARGET_NSIG_WORDS - 1];
3771     uint32_t tramp[2];
3772 };
3773
3774 struct rt_signal_frame {
3775     siginfo_t info;
3776     ucontext_t uc;
3777     uint32_t tramp[2];
3778 };
3779
3780 static void setup_sigcontext(struct target_sigcontext *sc, CPUMBState *env)
3781 {
3782     __put_user(env->regs[0], &sc->regs.r0);
3783     __put_user(env->regs[1], &sc->regs.r1);
3784     __put_user(env->regs[2], &sc->regs.r2);
3785     __put_user(env->regs[3], &sc->regs.r3);
3786     __put_user(env->regs[4], &sc->regs.r4);
3787     __put_user(env->regs[5], &sc->regs.r5);
3788     __put_user(env->regs[6], &sc->regs.r6);
3789     __put_user(env->regs[7], &sc->regs.r7);
3790     __put_user(env->regs[8], &sc->regs.r8);
3791     __put_user(env->regs[9], &sc->regs.r9);
3792     __put_user(env->regs[10], &sc->regs.r10);
3793     __put_user(env->regs[11], &sc->regs.r11);
3794     __put_user(env->regs[12], &sc->regs.r12);
3795     __put_user(env->regs[13], &sc->regs.r13);
3796     __put_user(env->regs[14], &sc->regs.r14);
3797     __put_user(env->regs[15], &sc->regs.r15);
3798     __put_user(env->regs[16], &sc->regs.r16);
3799     __put_user(env->regs[17], &sc->regs.r17);
3800     __put_user(env->regs[18], &sc->regs.r18);
3801     __put_user(env->regs[19], &sc->regs.r19);
3802     __put_user(env->regs[20], &sc->regs.r20);
3803     __put_user(env->regs[21], &sc->regs.r21);
3804     __put_user(env->regs[22], &sc->regs.r22);
3805     __put_user(env->regs[23], &sc->regs.r23);
3806     __put_user(env->regs[24], &sc->regs.r24);
3807     __put_user(env->regs[25], &sc->regs.r25);
3808     __put_user(env->regs[26], &sc->regs.r26);
3809     __put_user(env->regs[27], &sc->regs.r27);
3810     __put_user(env->regs[28], &sc->regs.r28);
3811     __put_user(env->regs[29], &sc->regs.r29);
3812     __put_user(env->regs[30], &sc->regs.r30);
3813     __put_user(env->regs[31], &sc->regs.r31);
3814     __put_user(env->sregs[SR_PC], &sc->regs.pc);
3815 }
3816
3817 static void restore_sigcontext(struct target_sigcontext *sc, CPUMBState *env)
3818 {
3819     __get_user(env->regs[0], &sc->regs.r0);
3820     __get_user(env->regs[1], &sc->regs.r1);
3821     __get_user(env->regs[2], &sc->regs.r2);
3822     __get_user(env->regs[3], &sc->regs.r3);
3823     __get_user(env->regs[4], &sc->regs.r4);
3824     __get_user(env->regs[5], &sc->regs.r5);
3825     __get_user(env->regs[6], &sc->regs.r6);
3826     __get_user(env->regs[7], &sc->regs.r7);
3827     __get_user(env->regs[8], &sc->regs.r8);
3828     __get_user(env->regs[9], &sc->regs.r9);
3829     __get_user(env->regs[10], &sc->regs.r10);
3830     __get_user(env->regs[11], &sc->regs.r11);
3831     __get_user(env->regs[12], &sc->regs.r12);
3832     __get_user(env->regs[13], &sc->regs.r13);
3833     __get_user(env->regs[14], &sc->regs.r14);
3834     __get_user(env->regs[15], &sc->regs.r15);
3835     __get_user(env->regs[16], &sc->regs.r16);
3836     __get_user(env->regs[17], &sc->regs.r17);
3837     __get_user(env->regs[18], &sc->regs.r18);
3838     __get_user(env->regs[19], &sc->regs.r19);
3839     __get_user(env->regs[20], &sc->regs.r20);
3840     __get_user(env->regs[21], &sc->regs.r21);
3841     __get_user(env->regs[22], &sc->regs.r22);
3842     __get_user(env->regs[23], &sc->regs.r23);
3843     __get_user(env->regs[24], &sc->regs.r24);
3844     __get_user(env->regs[25], &sc->regs.r25);
3845     __get_user(env->regs[26], &sc->regs.r26);
3846     __get_user(env->regs[27], &sc->regs.r27);
3847     __get_user(env->regs[28], &sc->regs.r28);
3848     __get_user(env->regs[29], &sc->regs.r29);
3849     __get_user(env->regs[30], &sc->regs.r30);
3850     __get_user(env->regs[31], &sc->regs.r31);
3851     __get_user(env->sregs[SR_PC], &sc->regs.pc);
3852 }
3853
3854 static abi_ulong get_sigframe(struct target_sigaction *ka,
3855                               CPUMBState *env, int frame_size)
3856 {
3857     abi_ulong sp = env->regs[1];
3858
3859     if ((ka->sa_flags & TARGET_SA_ONSTACK) != 0 && !on_sig_stack(sp)) {
3860         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3861     }
3862
3863     return ((sp - frame_size) & -8UL);
3864 }
3865
3866 static void setup_frame(int sig, struct target_sigaction *ka,
3867                         target_sigset_t *set, CPUMBState *env)
3868 {
3869     struct target_signal_frame *frame;
3870     abi_ulong frame_addr;
3871     int i;
3872
3873     frame_addr = get_sigframe(ka, env, sizeof *frame);
3874     trace_user_setup_frame(env, frame_addr);
3875     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3876         goto badframe;
3877
3878     /* Save the mask.  */
3879     __put_user(set->sig[0], &frame->uc.tuc_mcontext.oldmask);
3880
3881     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3882         __put_user(set->sig[i], &frame->extramask[i - 1]);
3883     }
3884
3885     setup_sigcontext(&frame->uc.tuc_mcontext, env);
3886
3887     /* Set up to return from userspace. If provided, use a stub
3888        already in userspace. */
3889     /* minus 8 is offset to cater for "rtsd r15,8" offset */
3890     if (ka->sa_flags & TARGET_SA_RESTORER) {
3891         env->regs[15] = ((unsigned long)ka->sa_restorer)-8;
3892     } else {
3893         uint32_t t;
3894         /* Note, these encodings are _big endian_! */
3895         /* addi r12, r0, __NR_sigreturn */
3896         t = 0x31800000UL | TARGET_NR_sigreturn;
3897         __put_user(t, frame->tramp + 0);
3898         /* brki r14, 0x8 */
3899         t = 0xb9cc0008UL;
3900         __put_user(t, frame->tramp + 1);
3901
3902         /* Return from sighandler will jump to the tramp.
3903            Negative 8 offset because return is rtsd r15, 8 */
3904         env->regs[15] = frame_addr + offsetof(struct target_signal_frame, tramp)
3905                                    - 8;
3906     }
3907
3908     /* Set up registers for signal handler */
3909     env->regs[1] = frame_addr;
3910     /* Signal handler args: */
3911     env->regs[5] = sig; /* Arg 0: signum */
3912     env->regs[6] = 0;
3913     /* arg 1: sigcontext */
3914     env->regs[7] = frame_addr += offsetof(typeof(*frame), uc);
3915
3916     /* Offset of 4 to handle microblaze rtid r14, 0 */
3917     env->sregs[SR_PC] = (unsigned long)ka->_sa_handler;
3918
3919     unlock_user_struct(frame, frame_addr, 1);
3920     return;
3921 badframe:
3922     force_sigsegv(sig);
3923 }
3924
3925 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3926                            target_siginfo_t *info,
3927                            target_sigset_t *set, CPUMBState *env)
3928 {
3929     fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n");
3930 }
3931
3932 long do_sigreturn(CPUMBState *env)
3933 {
3934     struct target_signal_frame *frame;
3935     abi_ulong frame_addr;
3936     target_sigset_t target_set;
3937     sigset_t set;
3938     int i;
3939
3940     frame_addr = env->regs[R_SP];
3941     trace_user_do_sigreturn(env, frame_addr);
3942     /* Make sure the guest isn't playing games.  */
3943     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3944         goto badframe;
3945
3946     /* Restore blocked signals */
3947     __get_user(target_set.sig[0], &frame->uc.tuc_mcontext.oldmask);
3948     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3949         __get_user(target_set.sig[i], &frame->extramask[i - 1]);
3950     }
3951     target_to_host_sigset_internal(&set, &target_set);
3952     set_sigmask(&set);
3953
3954     restore_sigcontext(&frame->uc.tuc_mcontext, env);
3955     /* We got here through a sigreturn syscall, our path back is via an
3956        rtb insn so setup r14 for that.  */
3957     env->regs[14] = env->sregs[SR_PC];
3958
3959     unlock_user_struct(frame, frame_addr, 0);
3960     return -TARGET_QEMU_ESIGRETURN;
3961 badframe:
3962     force_sig(TARGET_SIGSEGV);
3963     return -TARGET_QEMU_ESIGRETURN;
3964 }
3965
3966 long do_rt_sigreturn(CPUMBState *env)
3967 {
3968     trace_user_do_rt_sigreturn(env, 0);
3969     fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n");
3970     return -TARGET_ENOSYS;
3971 }
3972
3973 #elif defined(TARGET_CRIS)
3974
3975 struct target_sigcontext {
3976     struct target_pt_regs regs;  /* needs to be first */
3977     uint32_t oldmask;
3978     uint32_t usp;    /* usp before stacking this gunk on it */
3979 };
3980
3981 /* Signal frames. */
3982 struct target_signal_frame {
3983     struct target_sigcontext sc;
3984     uint32_t extramask[TARGET_NSIG_WORDS - 1];
3985     uint16_t retcode[4];      /* Trampoline code. */
3986 };
3987
3988 struct rt_signal_frame {
3989     siginfo_t *pinfo;
3990     void *puc;
3991     siginfo_t info;
3992     ucontext_t uc;
3993     uint16_t retcode[4];      /* Trampoline code. */
3994 };
3995
3996 static void setup_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
3997 {
3998     __put_user(env->regs[0], &sc->regs.r0);
3999     __put_user(env->regs[1], &sc->regs.r1);
4000     __put_user(env->regs[2], &sc->regs.r2);
4001     __put_user(env->regs[3], &sc->regs.r3);
4002     __put_user(env->regs[4], &sc->regs.r4);
4003     __put_user(env->regs[5], &sc->regs.r5);
4004     __put_user(env->regs[6], &sc->regs.r6);
4005     __put_user(env->regs[7], &sc->regs.r7);
4006     __put_user(env->regs[8], &sc->regs.r8);
4007     __put_user(env->regs[9], &sc->regs.r9);
4008     __put_user(env->regs[10], &sc->regs.r10);
4009     __put_user(env->regs[11], &sc->regs.r11);
4010     __put_user(env->regs[12], &sc->regs.r12);
4011     __put_user(env->regs[13], &sc->regs.r13);
4012     __put_user(env->regs[14], &sc->usp);
4013     __put_user(env->regs[15], &sc->regs.acr);
4014     __put_user(env->pregs[PR_MOF], &sc->regs.mof);
4015     __put_user(env->pregs[PR_SRP], &sc->regs.srp);
4016     __put_user(env->pc, &sc->regs.erp);
4017 }
4018
4019 static void restore_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
4020 {
4021     __get_user(env->regs[0], &sc->regs.r0);
4022     __get_user(env->regs[1], &sc->regs.r1);
4023     __get_user(env->regs[2], &sc->regs.r2);
4024     __get_user(env->regs[3], &sc->regs.r3);
4025     __get_user(env->regs[4], &sc->regs.r4);
4026     __get_user(env->regs[5], &sc->regs.r5);
4027     __get_user(env->regs[6], &sc->regs.r6);
4028     __get_user(env->regs[7], &sc->regs.r7);
4029     __get_user(env->regs[8], &sc->regs.r8);
4030     __get_user(env->regs[9], &sc->regs.r9);
4031     __get_user(env->regs[10], &sc->regs.r10);
4032     __get_user(env->regs[11], &sc->regs.r11);
4033     __get_user(env->regs[12], &sc->regs.r12);
4034     __get_user(env->regs[13], &sc->regs.r13);
4035     __get_user(env->regs[14], &sc->usp);
4036     __get_user(env->regs[15], &sc->regs.acr);
4037     __get_user(env->pregs[PR_MOF], &sc->regs.mof);
4038     __get_user(env->pregs[PR_SRP], &sc->regs.srp);
4039     __get_user(env->pc, &sc->regs.erp);
4040 }
4041
4042 static abi_ulong get_sigframe(CPUCRISState *env, int framesize)
4043 {
4044     abi_ulong sp;
4045     /* Align the stack downwards to 4.  */
4046     sp = (env->regs[R_SP] & ~3);
4047     return sp - framesize;
4048 }
4049
4050 static void setup_frame(int sig, struct target_sigaction *ka,
4051                         target_sigset_t *set, CPUCRISState *env)
4052 {
4053     struct target_signal_frame *frame;
4054     abi_ulong frame_addr;
4055     int i;
4056
4057     frame_addr = get_sigframe(env, sizeof *frame);
4058     trace_user_setup_frame(env, frame_addr);
4059     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
4060         goto badframe;
4061
4062     /*
4063      * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
4064      * use this trampoline anymore but it sets it up for GDB.
4065      * In QEMU, using the trampoline simplifies things a bit so we use it.
4066      *
4067      * This is movu.w __NR_sigreturn, r9; break 13;
4068      */
4069     __put_user(0x9c5f, frame->retcode+0);
4070     __put_user(TARGET_NR_sigreturn,
4071                frame->retcode + 1);
4072     __put_user(0xe93d, frame->retcode + 2);
4073
4074     /* Save the mask.  */
4075     __put_user(set->sig[0], &frame->sc.oldmask);
4076
4077     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
4078         __put_user(set->sig[i], &frame->extramask[i - 1]);
4079     }
4080
4081     setup_sigcontext(&frame->sc, env);
4082
4083     /* Move the stack and setup the arguments for the handler.  */
4084     env->regs[R_SP] = frame_addr;
4085     env->regs[10] = sig;
4086     env->pc = (unsigned long) ka->_sa_handler;
4087     /* Link SRP so the guest returns through the trampoline.  */
4088     env->pregs[PR_SRP] = frame_addr + offsetof(typeof(*frame), retcode);
4089
4090     unlock_user_struct(frame, frame_addr, 1);
4091     return;
4092 badframe:
4093     force_sigsegv(sig);
4094 }
4095
4096 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4097                            target_siginfo_t *info,
4098                            target_sigset_t *set, CPUCRISState *env)
4099 {
4100     fprintf(stderr, "CRIS setup_rt_frame: not implemented\n");
4101 }
4102
4103 long do_sigreturn(CPUCRISState *env)
4104 {
4105     struct target_signal_frame *frame;
4106     abi_ulong frame_addr;
4107     target_sigset_t target_set;
4108     sigset_t set;
4109     int i;
4110
4111     frame_addr = env->regs[R_SP];
4112     trace_user_do_sigreturn(env, frame_addr);
4113     /* Make sure the guest isn't playing games.  */
4114     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) {
4115         goto badframe;
4116     }
4117
4118     /* Restore blocked signals */
4119     __get_user(target_set.sig[0], &frame->sc.oldmask);
4120     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
4121         __get_user(target_set.sig[i], &frame->extramask[i - 1]);
4122     }
4123     target_to_host_sigset_internal(&set, &target_set);
4124     set_sigmask(&set);
4125
4126     restore_sigcontext(&frame->sc, env);
4127     unlock_user_struct(frame, frame_addr, 0);
4128     return -TARGET_QEMU_ESIGRETURN;
4129 badframe:
4130     force_sig(TARGET_SIGSEGV);
4131     return -TARGET_QEMU_ESIGRETURN;
4132 }
4133
4134 long do_rt_sigreturn(CPUCRISState *env)
4135 {
4136     trace_user_do_rt_sigreturn(env, 0);
4137     fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n");
4138     return -TARGET_ENOSYS;
4139 }
4140
4141 #elif defined(TARGET_NIOS2)
4142
4143 #define MCONTEXT_VERSION 2
4144
4145 struct target_sigcontext {
4146     int version;
4147     unsigned long gregs[32];
4148 };
4149
4150 struct target_ucontext {
4151     abi_ulong tuc_flags;
4152     abi_ulong tuc_link;
4153     target_stack_t tuc_stack;
4154     struct target_sigcontext tuc_mcontext;
4155     target_sigset_t tuc_sigmask;   /* mask last for extensibility */
4156 };
4157
4158 struct target_rt_sigframe {
4159     struct target_siginfo info;
4160     struct target_ucontext uc;
4161 };
4162
4163 static unsigned long sigsp(unsigned long sp, struct target_sigaction *ka)
4164 {
4165     if (unlikely((ka->sa_flags & SA_ONSTACK)) && !sas_ss_flags(sp)) {
4166 #ifdef CONFIG_STACK_GROWSUP
4167         return target_sigaltstack_used.ss_sp;
4168 #else
4169         return target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
4170 #endif
4171     }
4172     return sp;
4173 }
4174
4175 static int rt_setup_ucontext(struct target_ucontext *uc, CPUNios2State *env)
4176 {
4177     unsigned long *gregs = uc->tuc_mcontext.gregs;
4178
4179     __put_user(MCONTEXT_VERSION, &uc->tuc_mcontext.version);
4180     __put_user(env->regs[1], &gregs[0]);
4181     __put_user(env->regs[2], &gregs[1]);
4182     __put_user(env->regs[3], &gregs[2]);
4183     __put_user(env->regs[4], &gregs[3]);
4184     __put_user(env->regs[5], &gregs[4]);
4185     __put_user(env->regs[6], &gregs[5]);
4186     __put_user(env->regs[7], &gregs[6]);
4187     __put_user(env->regs[8], &gregs[7]);
4188     __put_user(env->regs[9], &gregs[8]);
4189     __put_user(env->regs[10], &gregs[9]);
4190     __put_user(env->regs[11], &gregs[10]);
4191     __put_user(env->regs[12], &gregs[11]);
4192     __put_user(env->regs[13], &gregs[12]);
4193     __put_user(env->regs[14], &gregs[13]);
4194     __put_user(env->regs[15], &gregs[14]);
4195     __put_user(env->regs[16], &gregs[15]);
4196     __put_user(env->regs[17], &gregs[16]);
4197     __put_user(env->regs[18], &gregs[17]);
4198     __put_user(env->regs[19], &gregs[18]);
4199     __put_user(env->regs[20], &gregs[19]);
4200     __put_user(env->regs[21], &gregs[20]);
4201     __put_user(env->regs[22], &gregs[21]);
4202     __put_user(env->regs[23], &gregs[22]);
4203     __put_user(env->regs[R_RA], &gregs[23]);
4204     __put_user(env->regs[R_FP], &gregs[24]);
4205     __put_user(env->regs[R_GP], &gregs[25]);
4206     __put_user(env->regs[R_EA], &gregs[27]);
4207     __put_user(env->regs[R_SP], &gregs[28]);
4208
4209     return 0;
4210 }
4211
4212 static int rt_restore_ucontext(CPUNios2State *env, struct target_ucontext *uc,
4213                                int *pr2)
4214 {
4215     int temp;
4216     abi_ulong off, frame_addr = env->regs[R_SP];
4217     unsigned long *gregs = uc->tuc_mcontext.gregs;
4218     int err;
4219
4220     /* Always make any pending restarted system calls return -EINTR */
4221     /* current->restart_block.fn = do_no_restart_syscall; */
4222
4223     __get_user(temp, &uc->tuc_mcontext.version);
4224     if (temp != MCONTEXT_VERSION) {
4225         return 1;
4226     }
4227
4228     /* restore passed registers */
4229     __get_user(env->regs[1], &gregs[0]);
4230     __get_user(env->regs[2], &gregs[1]);
4231     __get_user(env->regs[3], &gregs[2]);
4232     __get_user(env->regs[4], &gregs[3]);
4233     __get_user(env->regs[5], &gregs[4]);
4234     __get_user(env->regs[6], &gregs[5]);
4235     __get_user(env->regs[7], &gregs[6]);
4236     __get_user(env->regs[8], &gregs[7]);
4237     __get_user(env->regs[9], &gregs[8]);
4238     __get_user(env->regs[10], &gregs[9]);
4239     __get_user(env->regs[11], &gregs[10]);
4240     __get_user(env->regs[12], &gregs[11]);
4241     __get_user(env->regs[13], &gregs[12]);
4242     __get_user(env->regs[14], &gregs[13]);
4243     __get_user(env->regs[15], &gregs[14]);
4244     __get_user(env->regs[16], &gregs[15]);
4245     __get_user(env->regs[17], &gregs[16]);
4246     __get_user(env->regs[18], &gregs[17]);
4247     __get_user(env->regs[19], &gregs[18]);
4248     __get_user(env->regs[20], &gregs[19]);
4249     __get_user(env->regs[21], &gregs[20]);
4250     __get_user(env->regs[22], &gregs[21]);
4251     __get_user(env->regs[23], &gregs[22]);
4252     /* gregs[23] is handled below */
4253     /* Verify, should this be settable */
4254     __get_user(env->regs[R_FP], &gregs[24]);
4255     /* Verify, should this be settable */
4256     __get_user(env->regs[R_GP], &gregs[25]);
4257     /* Not really necessary no user settable bits */
4258     __get_user(temp, &gregs[26]);
4259     __get_user(env->regs[R_EA], &gregs[27]);
4260
4261     __get_user(env->regs[R_RA], &gregs[23]);
4262     __get_user(env->regs[R_SP], &gregs[28]);
4263
4264     off = offsetof(struct target_rt_sigframe, uc.tuc_stack);
4265     err = do_sigaltstack(frame_addr + off, 0, get_sp_from_cpustate(env));
4266     if (err == -EFAULT) {
4267         return 1;
4268     }
4269
4270     *pr2 = env->regs[2];
4271     return 0;
4272 }
4273
4274 static void *get_sigframe(struct target_sigaction *ka, CPUNios2State *env,
4275                           size_t frame_size)
4276 {
4277     unsigned long usp;
4278
4279     /* Default to using normal stack.  */
4280     usp = env->regs[R_SP];
4281
4282     /* This is the X/Open sanctioned signal stack switching.  */
4283     usp = sigsp(usp, ka);
4284
4285     /* Verify, is it 32 or 64 bit aligned */
4286     return (void *)((usp - frame_size) & -8UL);
4287 }
4288
4289 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4290                            target_siginfo_t *info,
4291                            target_sigset_t *set,
4292                            CPUNios2State *env)
4293 {
4294     struct target_rt_sigframe *frame;
4295     int i, err = 0;
4296
4297     frame = get_sigframe(ka, env, sizeof(*frame));
4298
4299     if (ka->sa_flags & SA_SIGINFO) {
4300         tswap_siginfo(&frame->info, info);
4301     }
4302
4303     /* Create the ucontext.  */
4304     __put_user(0, &frame->uc.tuc_flags);
4305     __put_user(0, &frame->uc.tuc_link);
4306     __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
4307     __put_user(sas_ss_flags(env->regs[R_SP]), &frame->uc.tuc_stack.ss_flags);
4308     __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
4309     err |= rt_setup_ucontext(&frame->uc, env);
4310     for (i = 0; i < TARGET_NSIG_WORDS; i++) {
4311         __put_user((abi_ulong)set->sig[i],
4312             (abi_ulong *)&frame->uc.tuc_sigmask.sig[i]);
4313     }
4314
4315     if (err) {
4316         goto give_sigsegv;
4317     }
4318
4319     /* Set up to return from userspace; jump to fixed address sigreturn
4320        trampoline on kuser page.  */
4321     env->regs[R_RA] = (unsigned long) (0x1044);
4322
4323     /* Set up registers for signal handler */
4324     env->regs[R_SP] = (unsigned long) frame;
4325     env->regs[4] = (unsigned long) sig;
4326     env->regs[5] = (unsigned long) &frame->info;
4327     env->regs[6] = (unsigned long) &frame->uc;
4328     env->regs[R_EA] = (unsigned long) ka->_sa_handler;
4329     return;
4330
4331 give_sigsegv:
4332     if (sig == TARGET_SIGSEGV) {
4333         ka->_sa_handler = TARGET_SIG_DFL;
4334     }
4335     force_sigsegv(sig);
4336     return;
4337 }
4338
4339 long do_sigreturn(CPUNios2State *env)
4340 {
4341     trace_user_do_sigreturn(env, 0);
4342     fprintf(stderr, "do_sigreturn: not implemented\n");
4343     return -TARGET_ENOSYS;
4344 }
4345
4346 long do_rt_sigreturn(CPUNios2State *env)
4347 {
4348     /* Verify, can we follow the stack back */
4349     abi_ulong frame_addr = env->regs[R_SP];
4350     struct target_rt_sigframe *frame;
4351     sigset_t set;
4352     int rval;
4353
4354     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4355         goto badframe;
4356     }
4357
4358     target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
4359     do_sigprocmask(SIG_SETMASK, &set, NULL);
4360
4361     if (rt_restore_ucontext(env, &frame->uc, &rval)) {
4362         goto badframe;
4363     }
4364
4365     unlock_user_struct(frame, frame_addr, 0);
4366     return rval;
4367
4368 badframe:
4369     unlock_user_struct(frame, frame_addr, 0);
4370     force_sig(TARGET_SIGSEGV);
4371     return 0;
4372 }
4373 /* TARGET_NIOS2 */
4374
4375 #elif defined(TARGET_OPENRISC)
4376
4377 struct target_sigcontext {
4378     struct target_pt_regs regs;
4379     abi_ulong oldmask;
4380     abi_ulong usp;
4381 };
4382
4383 struct target_ucontext {
4384     abi_ulong tuc_flags;
4385     abi_ulong tuc_link;
4386     target_stack_t tuc_stack;
4387     struct target_sigcontext tuc_mcontext;
4388     target_sigset_t tuc_sigmask;   /* mask last for extensibility */
4389 };
4390
4391 struct target_rt_sigframe {
4392     abi_ulong pinfo;
4393     uint64_t puc;
4394     struct target_siginfo info;
4395     struct target_sigcontext sc;
4396     struct target_ucontext uc;
4397     unsigned char retcode[16];  /* trampoline code */
4398 };
4399
4400 /* This is the asm-generic/ucontext.h version */
4401 #if 0
4402 static int restore_sigcontext(CPUOpenRISCState *regs,
4403                               struct target_sigcontext *sc)
4404 {
4405     unsigned int err = 0;
4406     unsigned long old_usp;
4407
4408     /* Alwys make any pending restarted system call return -EINTR */
4409     current_thread_info()->restart_block.fn = do_no_restart_syscall;
4410
4411     /* restore the regs from &sc->regs (same as sc, since regs is first)
4412      * (sc is already checked for VERIFY_READ since the sigframe was
4413      *  checked in sys_sigreturn previously)
4414      */
4415
4416     if (copy_from_user(regs, &sc, sizeof(struct target_pt_regs))) {
4417         goto badframe;
4418     }
4419
4420     /* make sure the U-flag is set so user-mode cannot fool us */
4421
4422     regs->sr &= ~SR_SM;
4423
4424     /* restore the old USP as it was before we stacked the sc etc.
4425      * (we cannot just pop the sigcontext since we aligned the sp and
4426      *  stuff after pushing it)
4427      */
4428
4429     __get_user(old_usp, &sc->usp);
4430     phx_signal("old_usp 0x%lx", old_usp);
4431
4432     __PHX__ REALLY           /* ??? */
4433     wrusp(old_usp);
4434     regs->gpr[1] = old_usp;
4435
4436     /* TODO: the other ports use regs->orig_XX to disable syscall checks
4437      * after this completes, but we don't use that mechanism. maybe we can
4438      * use it now ?
4439      */
4440
4441     return err;
4442
4443 badframe:
4444     return 1;
4445 }
4446 #endif
4447
4448 /* Set up a signal frame.  */
4449
4450 static void setup_sigcontext(struct target_sigcontext *sc,
4451                              CPUOpenRISCState *regs,
4452                              unsigned long mask)
4453 {
4454     unsigned long usp = cpu_get_gpr(regs, 1);
4455
4456     /* copy the regs. they are first in sc so we can use sc directly */
4457
4458     /*copy_to_user(&sc, regs, sizeof(struct target_pt_regs));*/
4459
4460     /* Set the frametype to CRIS_FRAME_NORMAL for the execution of
4461        the signal handler. The frametype will be restored to its previous
4462        value in restore_sigcontext. */
4463     /*regs->frametype = CRIS_FRAME_NORMAL;*/
4464
4465     /* then some other stuff */
4466     __put_user(mask, &sc->oldmask);
4467     __put_user(usp, &sc->usp);
4468 }
4469
4470 static inline unsigned long align_sigframe(unsigned long sp)
4471 {
4472     return sp & ~3UL;
4473 }
4474
4475 static inline abi_ulong get_sigframe(struct target_sigaction *ka,
4476                                      CPUOpenRISCState *regs,
4477                                      size_t frame_size)
4478 {
4479     unsigned long sp = cpu_get_gpr(regs, 1);
4480     int onsigstack = on_sig_stack(sp);
4481
4482     /* redzone */
4483     /* This is the X/Open sanctioned signal stack switching.  */
4484     if ((ka->sa_flags & TARGET_SA_ONSTACK) != 0 && !onsigstack) {
4485         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
4486     }
4487
4488     sp = align_sigframe(sp - frame_size);
4489
4490     /*
4491      * If we are on the alternate signal stack and would overflow it, don't.
4492      * Return an always-bogus address instead so we will die with SIGSEGV.
4493      */
4494
4495     if (onsigstack && !likely(on_sig_stack(sp))) {
4496         return -1L;
4497     }
4498
4499     return sp;
4500 }
4501
4502 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4503                            target_siginfo_t *info,
4504                            target_sigset_t *set, CPUOpenRISCState *env)
4505 {
4506     int err = 0;
4507     abi_ulong frame_addr;
4508     unsigned long return_ip;
4509     struct target_rt_sigframe *frame;
4510     abi_ulong info_addr, uc_addr;
4511
4512     frame_addr = get_sigframe(ka, env, sizeof(*frame));
4513     trace_user_setup_rt_frame(env, frame_addr);
4514     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4515         goto give_sigsegv;
4516     }
4517
4518     info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
4519     __put_user(info_addr, &frame->pinfo);
4520     uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
4521     __put_user(uc_addr, &frame->puc);
4522
4523     if (ka->sa_flags & SA_SIGINFO) {
4524         tswap_siginfo(&frame->info, info);
4525     }
4526
4527     /*err |= __clear_user(&frame->uc, offsetof(ucontext_t, uc_mcontext));*/
4528     __put_user(0, &frame->uc.tuc_flags);
4529     __put_user(0, &frame->uc.tuc_link);
4530     __put_user(target_sigaltstack_used.ss_sp,
4531                &frame->uc.tuc_stack.ss_sp);
4532     __put_user(sas_ss_flags(cpu_get_gpr(env, 1)),
4533                &frame->uc.tuc_stack.ss_flags);
4534     __put_user(target_sigaltstack_used.ss_size,
4535                &frame->uc.tuc_stack.ss_size);
4536     setup_sigcontext(&frame->sc, env, set->sig[0]);
4537
4538     /*err |= copy_to_user(frame->uc.tuc_sigmask, set, sizeof(*set));*/
4539
4540     /* trampoline - the desired return ip is the retcode itself */
4541     return_ip = (unsigned long)&frame->retcode;
4542     /* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */
4543     __put_user(0xa960, (short *)(frame->retcode + 0));
4544     __put_user(TARGET_NR_rt_sigreturn, (short *)(frame->retcode + 2));
4545     __put_user(0x20000001, (unsigned long *)(frame->retcode + 4));
4546     __put_user(0x15000000, (unsigned long *)(frame->retcode + 8));
4547
4548     if (err) {
4549         goto give_sigsegv;
4550     }
4551
4552     /* TODO what is the current->exec_domain stuff and invmap ? */
4553
4554     /* Set up registers for signal handler */
4555     env->pc = (unsigned long)ka->_sa_handler; /* what we enter NOW */
4556     cpu_set_gpr(env, 9, (unsigned long)return_ip);     /* what we enter LATER */
4557     cpu_set_gpr(env, 3, (unsigned long)sig);           /* arg 1: signo */
4558     cpu_set_gpr(env, 4, (unsigned long)&frame->info);  /* arg 2: (siginfo_t*) */
4559     cpu_set_gpr(env, 5, (unsigned long)&frame->uc);    /* arg 3: ucontext */
4560
4561     /* actually move the usp to reflect the stacked frame */
4562     cpu_set_gpr(env, 1, (unsigned long)frame);
4563
4564     return;
4565
4566 give_sigsegv:
4567     unlock_user_struct(frame, frame_addr, 1);
4568     force_sigsegv(sig);
4569 }
4570
4571 long do_sigreturn(CPUOpenRISCState *env)
4572 {
4573     trace_user_do_sigreturn(env, 0);
4574     fprintf(stderr, "do_sigreturn: not implemented\n");
4575     return -TARGET_ENOSYS;
4576 }
4577
4578 long do_rt_sigreturn(CPUOpenRISCState *env)
4579 {
4580     trace_user_do_rt_sigreturn(env, 0);
4581     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
4582     return -TARGET_ENOSYS;
4583 }
4584 /* TARGET_OPENRISC */
4585
4586 #elif defined(TARGET_S390X)
4587
4588 #define __NUM_GPRS 16
4589 #define __NUM_FPRS 16
4590 #define __NUM_ACRS 16
4591
4592 #define S390_SYSCALL_SIZE   2
4593 #define __SIGNAL_FRAMESIZE      160 /* FIXME: 31-bit mode -> 96 */
4594
4595 #define _SIGCONTEXT_NSIG        64
4596 #define _SIGCONTEXT_NSIG_BPW    64 /* FIXME: 31-bit mode -> 32 */
4597 #define _SIGCONTEXT_NSIG_WORDS  (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW)
4598 #define _SIGMASK_COPY_SIZE    (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS)
4599 #define PSW_ADDR_AMODE            0x0000000000000000UL /* 0x80000000UL for 31-bit */
4600 #define S390_SYSCALL_OPCODE ((uint16_t)0x0a00)
4601
4602 typedef struct {
4603     target_psw_t psw;
4604     target_ulong gprs[__NUM_GPRS];
4605     unsigned int acrs[__NUM_ACRS];
4606 } target_s390_regs_common;
4607
4608 typedef struct {
4609     unsigned int fpc;
4610     double   fprs[__NUM_FPRS];
4611 } target_s390_fp_regs;
4612
4613 typedef struct {
4614     target_s390_regs_common regs;
4615     target_s390_fp_regs     fpregs;
4616 } target_sigregs;
4617
4618 struct target_sigcontext {
4619     target_ulong   oldmask[_SIGCONTEXT_NSIG_WORDS];
4620     target_sigregs *sregs;
4621 };
4622
4623 typedef struct {
4624     uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
4625     struct target_sigcontext sc;
4626     target_sigregs sregs;
4627     int signo;
4628     uint8_t retcode[S390_SYSCALL_SIZE];
4629 } sigframe;
4630
4631 struct target_ucontext {
4632     target_ulong tuc_flags;
4633     struct target_ucontext *tuc_link;
4634     target_stack_t tuc_stack;
4635     target_sigregs tuc_mcontext;
4636     target_sigset_t tuc_sigmask;   /* mask last for extensibility */
4637 };
4638
4639 typedef struct {
4640     uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
4641     uint8_t retcode[S390_SYSCALL_SIZE];
4642     struct target_siginfo info;
4643     struct target_ucontext uc;
4644 } rt_sigframe;
4645
4646 static inline abi_ulong
4647 get_sigframe(struct target_sigaction *ka, CPUS390XState *env, size_t frame_size)
4648 {
4649     abi_ulong sp;
4650
4651     /* Default to using normal stack */
4652     sp = env->regs[15];
4653
4654     /* This is the X/Open sanctioned signal stack switching.  */
4655     if (ka->sa_flags & TARGET_SA_ONSTACK) {
4656         if (!sas_ss_flags(sp)) {
4657             sp = target_sigaltstack_used.ss_sp +
4658                  target_sigaltstack_used.ss_size;
4659         }
4660     }
4661
4662     /* This is the legacy signal stack switching. */
4663     else if (/* FIXME !user_mode(regs) */ 0 &&
4664              !(ka->sa_flags & TARGET_SA_RESTORER) &&
4665              ka->sa_restorer) {
4666         sp = (abi_ulong) ka->sa_restorer;
4667     }
4668
4669     return (sp - frame_size) & -8ul;
4670 }
4671
4672 static void save_sigregs(CPUS390XState *env, target_sigregs *sregs)
4673 {
4674     int i;
4675     //save_access_regs(current->thread.acrs); FIXME
4676
4677     /* Copy a 'clean' PSW mask to the user to avoid leaking
4678        information about whether PER is currently on.  */
4679     __put_user(env->psw.mask, &sregs->regs.psw.mask);
4680     __put_user(env->psw.addr, &sregs->regs.psw.addr);
4681     for (i = 0; i < 16; i++) {
4682         __put_user(env->regs[i], &sregs->regs.gprs[i]);
4683     }
4684     for (i = 0; i < 16; i++) {
4685         __put_user(env->aregs[i], &sregs->regs.acrs[i]);
4686     }
4687     /*
4688      * We have to store the fp registers to current->thread.fp_regs
4689      * to merge them with the emulated registers.
4690      */
4691     //save_fp_regs(&current->thread.fp_regs); FIXME
4692     for (i = 0; i < 16; i++) {
4693         __put_user(get_freg(env, i)->ll, &sregs->fpregs.fprs[i]);
4694     }
4695 }
4696
4697 static void setup_frame(int sig, struct target_sigaction *ka,
4698                         target_sigset_t *set, CPUS390XState *env)
4699 {
4700     sigframe *frame;
4701     abi_ulong frame_addr;
4702
4703     frame_addr = get_sigframe(ka, env, sizeof(*frame));
4704     trace_user_setup_frame(env, frame_addr);
4705     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4706         goto give_sigsegv;
4707     }
4708
4709     __put_user(set->sig[0], &frame->sc.oldmask[0]);
4710
4711     save_sigregs(env, &frame->sregs);
4712
4713     __put_user((abi_ulong)(unsigned long)&frame->sregs,
4714                (abi_ulong *)&frame->sc.sregs);
4715
4716     /* Set up to return from userspace.  If provided, use a stub
4717        already in userspace.  */
4718     if (ka->sa_flags & TARGET_SA_RESTORER) {
4719         env->regs[14] = (unsigned long)
4720                 ka->sa_restorer | PSW_ADDR_AMODE;
4721     } else {
4722         env->regs[14] = (frame_addr + offsetof(sigframe, retcode))
4723                         | PSW_ADDR_AMODE;
4724         __put_user(S390_SYSCALL_OPCODE | TARGET_NR_sigreturn,
4725                    (uint16_t *)(frame->retcode));
4726     }
4727
4728     /* Set up backchain. */
4729     __put_user(env->regs[15], (abi_ulong *) frame);
4730
4731     /* Set up registers for signal handler */
4732     env->regs[15] = frame_addr;
4733     env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
4734
4735     env->regs[2] = sig; //map_signal(sig);
4736     env->regs[3] = frame_addr += offsetof(typeof(*frame), sc);
4737
4738     /* We forgot to include these in the sigcontext.
4739        To avoid breaking binary compatibility, they are passed as args. */
4740     env->regs[4] = 0; // FIXME: no clue... current->thread.trap_no;
4741     env->regs[5] = 0; // FIXME: no clue... current->thread.prot_addr;
4742
4743     /* Place signal number on stack to allow backtrace from handler.  */
4744     __put_user(env->regs[2], &frame->signo);
4745     unlock_user_struct(frame, frame_addr, 1);
4746     return;
4747
4748 give_sigsegv:
4749     force_sigsegv(sig);
4750 }
4751
4752 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4753                            target_siginfo_t *info,
4754                            target_sigset_t *set, CPUS390XState *env)
4755 {
4756     int i;
4757     rt_sigframe *frame;
4758     abi_ulong frame_addr;
4759
4760     frame_addr = get_sigframe(ka, env, sizeof *frame);
4761     trace_user_setup_rt_frame(env, frame_addr);
4762     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4763         goto give_sigsegv;
4764     }
4765
4766     tswap_siginfo(&frame->info, info);
4767
4768     /* Create the ucontext.  */
4769     __put_user(0, &frame->uc.tuc_flags);
4770     __put_user((abi_ulong)0, (abi_ulong *)&frame->uc.tuc_link);
4771     __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
4772     __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
4773                &frame->uc.tuc_stack.ss_flags);
4774     __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
4775     save_sigregs(env, &frame->uc.tuc_mcontext);
4776     for (i = 0; i < TARGET_NSIG_WORDS; i++) {
4777         __put_user((abi_ulong)set->sig[i],
4778                    (abi_ulong *)&frame->uc.tuc_sigmask.sig[i]);
4779     }
4780
4781     /* Set up to return from userspace.  If provided, use a stub
4782        already in userspace.  */
4783     if (ka->sa_flags & TARGET_SA_RESTORER) {
4784         env->regs[14] = (unsigned long) ka->sa_restorer | PSW_ADDR_AMODE;
4785     } else {
4786         env->regs[14] = (unsigned long) frame->retcode | PSW_ADDR_AMODE;
4787         __put_user(S390_SYSCALL_OPCODE | TARGET_NR_rt_sigreturn,
4788                    (uint16_t *)(frame->retcode));
4789     }
4790
4791     /* Set up backchain. */
4792     __put_user(env->regs[15], (abi_ulong *) frame);
4793
4794     /* Set up registers for signal handler */
4795     env->regs[15] = frame_addr;
4796     env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
4797
4798     env->regs[2] = sig; //map_signal(sig);
4799     env->regs[3] = frame_addr + offsetof(typeof(*frame), info);
4800     env->regs[4] = frame_addr + offsetof(typeof(*frame), uc);
4801     return;
4802
4803 give_sigsegv:
4804     force_sigsegv(sig);
4805 }
4806
4807 static int
4808 restore_sigregs(CPUS390XState *env, target_sigregs *sc)
4809 {
4810     int err = 0;
4811     int i;
4812
4813     for (i = 0; i < 16; i++) {
4814         __get_user(env->regs[i], &sc->regs.gprs[i]);
4815     }
4816
4817     __get_user(env->psw.mask, &sc->regs.psw.mask);
4818     trace_user_s390x_restore_sigregs(env, (unsigned long long)sc->regs.psw.addr,
4819                                      (unsigned long long)env->psw.addr);
4820     __get_user(env->psw.addr, &sc->regs.psw.addr);
4821     /* FIXME: 31-bit -> | PSW_ADDR_AMODE */
4822
4823     for (i = 0; i < 16; i++) {
4824         __get_user(env->aregs[i], &sc->regs.acrs[i]);
4825     }
4826     for (i = 0; i < 16; i++) {
4827         __get_user(get_freg(env, i)->ll, &sc->fpregs.fprs[i]);
4828     }
4829
4830     return err;
4831 }
4832
4833 long do_sigreturn(CPUS390XState *env)
4834 {
4835     sigframe *frame;
4836     abi_ulong frame_addr = env->regs[15];
4837     target_sigset_t target_set;
4838     sigset_t set;
4839
4840     trace_user_do_sigreturn(env, frame_addr);
4841     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4842         goto badframe;
4843     }
4844     __get_user(target_set.sig[0], &frame->sc.oldmask[0]);
4845
4846     target_to_host_sigset_internal(&set, &target_set);
4847     set_sigmask(&set); /* ~_BLOCKABLE? */
4848
4849     if (restore_sigregs(env, &frame->sregs)) {
4850         goto badframe;
4851     }
4852
4853     unlock_user_struct(frame, frame_addr, 0);
4854     return -TARGET_QEMU_ESIGRETURN;
4855
4856 badframe:
4857     force_sig(TARGET_SIGSEGV);
4858     return -TARGET_QEMU_ESIGRETURN;
4859 }
4860
4861 long do_rt_sigreturn(CPUS390XState *env)
4862 {
4863     rt_sigframe *frame;
4864     abi_ulong frame_addr = env->regs[15];
4865     sigset_t set;
4866
4867     trace_user_do_rt_sigreturn(env, frame_addr);
4868     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4869         goto badframe;
4870     }
4871     target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
4872
4873     set_sigmask(&set); /* ~_BLOCKABLE? */
4874
4875     if (restore_sigregs(env, &frame->uc.tuc_mcontext)) {
4876         goto badframe;
4877     }
4878
4879     if (do_sigaltstack(frame_addr + offsetof(rt_sigframe, uc.tuc_stack), 0,
4880                        get_sp_from_cpustate(env)) == -EFAULT) {
4881         goto badframe;
4882     }
4883     unlock_user_struct(frame, frame_addr, 0);
4884     return -TARGET_QEMU_ESIGRETURN;
4885
4886 badframe:
4887     unlock_user_struct(frame, frame_addr, 0);
4888     force_sig(TARGET_SIGSEGV);
4889     return -TARGET_QEMU_ESIGRETURN;
4890 }
4891
4892 #elif defined(TARGET_PPC)
4893
4894 /* Size of dummy stack frame allocated when calling signal handler.
4895    See arch/powerpc/include/asm/ptrace.h.  */
4896 #if defined(TARGET_PPC64)
4897 #define SIGNAL_FRAMESIZE 128
4898 #else
4899 #define SIGNAL_FRAMESIZE 64
4900 #endif
4901
4902 /* See arch/powerpc/include/asm/ucontext.h.  Only used for 32-bit PPC;
4903    on 64-bit PPC, sigcontext and mcontext are one and the same.  */
4904 struct target_mcontext {
4905     target_ulong mc_gregs[48];
4906     /* Includes fpscr.  */
4907     uint64_t mc_fregs[33];
4908 #if defined(TARGET_PPC64)
4909     /* Pointer to the vector regs */
4910     target_ulong v_regs;
4911 #else
4912     target_ulong mc_pad[2];
4913 #endif
4914     /* We need to handle Altivec and SPE at the same time, which no
4915        kernel needs to do.  Fortunately, the kernel defines this bit to
4916        be Altivec-register-large all the time, rather than trying to
4917        twiddle it based on the specific platform.  */
4918     union {
4919         /* SPE vector registers.  One extra for SPEFSCR.  */
4920         uint32_t spe[33];
4921         /* Altivec vector registers.  The packing of VSCR and VRSAVE
4922            varies depending on whether we're PPC64 or not: PPC64 splits
4923            them apart; PPC32 stuffs them together.
4924            We also need to account for the VSX registers on PPC64
4925         */
4926 #if defined(TARGET_PPC64)
4927 #define QEMU_NVRREG (34 + 16)
4928         /* On ppc64, this mcontext structure is naturally *unaligned*,
4929          * or rather it is aligned on a 8 bytes boundary but not on
4930          * a 16 bytes one. This pad fixes it up. This is also why the
4931          * vector regs are referenced by the v_regs pointer above so
4932          * any amount of padding can be added here
4933          */
4934         target_ulong pad;
4935 #else
4936         /* On ppc32, we are already aligned to 16 bytes */
4937 #define QEMU_NVRREG 33
4938 #endif
4939         /* We cannot use ppc_avr_t here as we do *not* want the implied
4940          * 16-bytes alignment that would result from it. This would have
4941          * the effect of making the whole struct target_mcontext aligned
4942          * which breaks the layout of struct target_ucontext on ppc64.
4943          */
4944         uint64_t altivec[QEMU_NVRREG][2];
4945 #undef QEMU_NVRREG
4946     } mc_vregs;
4947 };
4948
4949 /* See arch/powerpc/include/asm/sigcontext.h.  */
4950 struct target_sigcontext {
4951     target_ulong _unused[4];
4952     int32_t signal;
4953 #if defined(TARGET_PPC64)
4954     int32_t pad0;
4955 #endif
4956     target_ulong handler;
4957     target_ulong oldmask;
4958     target_ulong regs;      /* struct pt_regs __user * */
4959 #if defined(TARGET_PPC64)
4960     struct target_mcontext mcontext;
4961 #endif
4962 };
4963
4964 /* Indices for target_mcontext.mc_gregs, below.
4965    See arch/powerpc/include/asm/ptrace.h for details.  */
4966 enum {
4967     TARGET_PT_R0 = 0,
4968     TARGET_PT_R1 = 1,
4969     TARGET_PT_R2 = 2,
4970     TARGET_PT_R3 = 3,
4971     TARGET_PT_R4 = 4,
4972     TARGET_PT_R5 = 5,
4973     TARGET_PT_R6 = 6,
4974     TARGET_PT_R7 = 7,
4975     TARGET_PT_R8 = 8,
4976     TARGET_PT_R9 = 9,
4977     TARGET_PT_R10 = 10,
4978     TARGET_PT_R11 = 11,
4979     TARGET_PT_R12 = 12,
4980     TARGET_PT_R13 = 13,
4981     TARGET_PT_R14 = 14,
4982     TARGET_PT_R15 = 15,
4983     TARGET_PT_R16 = 16,
4984     TARGET_PT_R17 = 17,
4985     TARGET_PT_R18 = 18,
4986     TARGET_PT_R19 = 19,
4987     TARGET_PT_R20 = 20,
4988     TARGET_PT_R21 = 21,
4989     TARGET_PT_R22 = 22,
4990     TARGET_PT_R23 = 23,
4991     TARGET_PT_R24 = 24,
4992     TARGET_PT_R25 = 25,
4993     TARGET_PT_R26 = 26,
4994     TARGET_PT_R27 = 27,
4995     TARGET_PT_R28 = 28,
4996     TARGET_PT_R29 = 29,
4997     TARGET_PT_R30 = 30,
4998     TARGET_PT_R31 = 31,
4999     TARGET_PT_NIP = 32,
5000     TARGET_PT_MSR = 33,
5001     TARGET_PT_ORIG_R3 = 34,
5002     TARGET_PT_CTR = 35,
5003     TARGET_PT_LNK = 36,
5004     TARGET_PT_XER = 37,
5005     TARGET_PT_CCR = 38,
5006     /* Yes, there are two registers with #39.  One is 64-bit only.  */
5007     TARGET_PT_MQ = 39,
5008     TARGET_PT_SOFTE = 39,
5009     TARGET_PT_TRAP = 40,
5010     TARGET_PT_DAR = 41,
5011     TARGET_PT_DSISR = 42,
5012     TARGET_PT_RESULT = 43,
5013     TARGET_PT_REGS_COUNT = 44
5014 };
5015
5016
5017 struct target_ucontext {
5018     target_ulong tuc_flags;
5019     target_ulong tuc_link;    /* ucontext_t __user * */
5020     struct target_sigaltstack tuc_stack;
5021 #if !defined(TARGET_PPC64)
5022     int32_t tuc_pad[7];
5023     target_ulong tuc_regs;    /* struct mcontext __user *
5024                                 points to uc_mcontext field */
5025 #endif
5026     target_sigset_t tuc_sigmask;
5027 #if defined(TARGET_PPC64)
5028     target_sigset_t unused[15]; /* Allow for uc_sigmask growth */
5029     struct target_sigcontext tuc_sigcontext;
5030 #else
5031     int32_t tuc_maskext[30];
5032     int32_t tuc_pad2[3];
5033     struct target_mcontext tuc_mcontext;
5034 #endif
5035 };
5036
5037 /* See arch/powerpc/kernel/signal_32.c.  */
5038 struct target_sigframe {
5039     struct target_sigcontext sctx;
5040     struct target_mcontext mctx;
5041     int32_t abigap[56];
5042 };
5043
5044 #if defined(TARGET_PPC64)
5045
5046 #define TARGET_TRAMP_SIZE 6
5047
5048 struct target_rt_sigframe {
5049     /* sys_rt_sigreturn requires the ucontext be the first field */
5050     struct target_ucontext uc;
5051     target_ulong  _unused[2];
5052     uint32_t trampoline[TARGET_TRAMP_SIZE];
5053     target_ulong pinfo; /* struct siginfo __user * */
5054     target_ulong puc; /* void __user * */
5055     struct target_siginfo info;
5056     /* 64 bit ABI allows for 288 bytes below sp before decrementing it. */
5057     char abigap[288];
5058 } __attribute__((aligned(16)));
5059
5060 #else
5061
5062 struct target_rt_sigframe {
5063     struct target_siginfo info;
5064     struct target_ucontext uc;
5065     int32_t abigap[56];
5066 };
5067
5068 #endif
5069
5070 #if defined(TARGET_PPC64)
5071
5072 struct target_func_ptr {
5073     target_ulong entry;
5074     target_ulong toc;
5075 };
5076
5077 #endif
5078
5079 /* We use the mc_pad field for the signal return trampoline.  */
5080 #define tramp mc_pad
5081
5082 /* See arch/powerpc/kernel/signal.c.  */
5083 static target_ulong get_sigframe(struct target_sigaction *ka,
5084                                  CPUPPCState *env,
5085                                  int frame_size)
5086 {
5087     target_ulong oldsp;
5088
5089     oldsp = env->gpr[1];
5090
5091     if ((ka->sa_flags & TARGET_SA_ONSTACK) &&
5092             (sas_ss_flags(oldsp) == 0)) {
5093         oldsp = (target_sigaltstack_used.ss_sp
5094                  + target_sigaltstack_used.ss_size);
5095     }
5096
5097     return (oldsp - frame_size) & ~0xFUL;
5098 }
5099
5100 #if ((defined(TARGET_WORDS_BIGENDIAN) && defined(HOST_WORDS_BIGENDIAN)) || \
5101      (!defined(HOST_WORDS_BIGENDIAN) && !defined(TARGET_WORDS_BIGENDIAN)))
5102 #define PPC_VEC_HI      0
5103 #define PPC_VEC_LO      1
5104 #else
5105 #define PPC_VEC_HI      1
5106 #define PPC_VEC_LO      0
5107 #endif
5108
5109
5110 static void save_user_regs(CPUPPCState *env, struct target_mcontext *frame)
5111 {
5112     target_ulong msr = env->msr;
5113     int i;
5114     target_ulong ccr = 0;
5115
5116     /* In general, the kernel attempts to be intelligent about what it
5117        needs to save for Altivec/FP/SPE registers.  We don't care that
5118        much, so we just go ahead and save everything.  */
5119
5120     /* Save general registers.  */
5121     for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
5122         __put_user(env->gpr[i], &frame->mc_gregs[i]);
5123     }
5124     __put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]);
5125     __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]);
5126     __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]);
5127     __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]);
5128
5129     for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
5130         ccr |= env->crf[i] << (32 - ((i + 1) * 4));
5131     }
5132     __put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]);
5133
5134     /* Save Altivec registers if necessary.  */
5135     if (env->insns_flags & PPC_ALTIVEC) {
5136         uint32_t *vrsave;
5137         for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
5138             ppc_avr_t *avr = &env->avr[i];
5139             ppc_avr_t *vreg = (ppc_avr_t *)&frame->mc_vregs.altivec[i];
5140
5141             __put_user(avr->u64[PPC_VEC_HI], &vreg->u64[0]);
5142             __put_user(avr->u64[PPC_VEC_LO], &vreg->u64[1]);
5143         }
5144         /* Set MSR_VR in the saved MSR value to indicate that
5145            frame->mc_vregs contains valid data.  */
5146         msr |= MSR_VR;
5147 #if defined(TARGET_PPC64)
5148         vrsave = (uint32_t *)&frame->mc_vregs.altivec[33];
5149         /* 64-bit needs to put a pointer to the vectors in the frame */
5150         __put_user(h2g(frame->mc_vregs.altivec), &frame->v_regs);
5151 #else
5152         vrsave = (uint32_t *)&frame->mc_vregs.altivec[32];
5153 #endif
5154         __put_user((uint32_t)env->spr[SPR_VRSAVE], vrsave);
5155     }
5156
5157     /* Save VSX second halves */
5158     if (env->insns_flags2 & PPC2_VSX) {
5159         uint64_t *vsregs = (uint64_t *)&frame->mc_vregs.altivec[34];
5160         for (i = 0; i < ARRAY_SIZE(env->vsr); i++) {
5161             __put_user(env->vsr[i], &vsregs[i]);
5162         }
5163     }
5164
5165     /* Save floating point registers.  */
5166     if (env->insns_flags & PPC_FLOAT) {
5167         for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
5168             __put_user(env->fpr[i], &frame->mc_fregs[i]);
5169         }
5170         __put_user((uint64_t) env->fpscr, &frame->mc_fregs[32]);
5171     }
5172
5173     /* Save SPE registers.  The kernel only saves the high half.  */
5174     if (env->insns_flags & PPC_SPE) {
5175 #if defined(TARGET_PPC64)
5176         for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
5177             __put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i]);
5178         }
5179 #else
5180         for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
5181             __put_user(env->gprh[i], &frame->mc_vregs.spe[i]);
5182         }
5183 #endif
5184         /* Set MSR_SPE in the saved MSR value to indicate that
5185            frame->mc_vregs contains valid data.  */
5186         msr |= MSR_SPE;
5187         __put_user(env->spe_fscr, &frame->mc_vregs.spe[32]);
5188     }
5189
5190     /* Store MSR.  */
5191     __put_user(msr, &frame->mc_gregs[TARGET_PT_MSR]);
5192 }
5193
5194 static void encode_trampoline(int sigret, uint32_t *tramp)
5195 {
5196     /* Set up the sigreturn trampoline: li r0,sigret; sc.  */
5197     if (sigret) {
5198         __put_user(0x38000000 | sigret, &tramp[0]);
5199         __put_user(0x44000002, &tramp[1]);
5200     }
5201 }
5202
5203 static void restore_user_regs(CPUPPCState *env,
5204                               struct target_mcontext *frame, int sig)
5205 {
5206     target_ulong save_r2 = 0;
5207     target_ulong msr;
5208     target_ulong ccr;
5209
5210     int i;
5211
5212     if (!sig) {
5213         save_r2 = env->gpr[2];
5214     }
5215
5216     /* Restore general registers.  */
5217     for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
5218         __get_user(env->gpr[i], &frame->mc_gregs[i]);
5219     }
5220     __get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]);
5221     __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]);
5222     __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]);
5223     __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]);
5224     __get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]);
5225
5226     for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
5227         env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf;
5228     }
5229
5230     if (!sig) {
5231         env->gpr[2] = save_r2;
5232     }
5233     /* Restore MSR.  */
5234     __get_user(msr, &frame->mc_gregs[TARGET_PT_MSR]);
5235
5236     /* If doing signal return, restore the previous little-endian mode.  */
5237     if (sig)
5238         env->msr = (env->msr & ~(1ull << MSR_LE)) | (msr & (1ull << MSR_LE));
5239
5240     /* Restore Altivec registers if necessary.  */
5241     if (env->insns_flags & PPC_ALTIVEC) {
5242         ppc_avr_t *v_regs;
5243         uint32_t *vrsave;
5244 #if defined(TARGET_PPC64)
5245         uint64_t v_addr;
5246         /* 64-bit needs to recover the pointer to the vectors from the frame */
5247         __get_user(v_addr, &frame->v_regs);
5248         v_regs = g2h(v_addr);
5249 #else
5250         v_regs = (ppc_avr_t *)frame->mc_vregs.altivec;
5251 #endif
5252         for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
5253             ppc_avr_t *avr = &env->avr[i];
5254             ppc_avr_t *vreg = &v_regs[i];
5255
5256             __get_user(avr->u64[PPC_VEC_HI], &vreg->u64[0]);
5257             __get_user(avr->u64[PPC_VEC_LO], &vreg->u64[1]);
5258         }
5259         /* Set MSR_VEC in the saved MSR value to indicate that
5260            frame->mc_vregs contains valid data.  */
5261 #if defined(TARGET_PPC64)
5262         vrsave = (uint32_t *)&v_regs[33];
5263 #else
5264         vrsave = (uint32_t *)&v_regs[32];
5265 #endif
5266         __get_user(env->spr[SPR_VRSAVE], vrsave);
5267     }
5268
5269     /* Restore VSX second halves */
5270     if (env->insns_flags2 & PPC2_VSX) {
5271         uint64_t *vsregs = (uint64_t *)&frame->mc_vregs.altivec[34];
5272         for (i = 0; i < ARRAY_SIZE(env->vsr); i++) {
5273             __get_user(env->vsr[i], &vsregs[i]);
5274         }
5275     }
5276
5277     /* Restore floating point registers.  */
5278     if (env->insns_flags & PPC_FLOAT) {
5279         uint64_t fpscr;
5280         for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
5281             __get_user(env->fpr[i], &frame->mc_fregs[i]);
5282         }
5283         __get_user(fpscr, &frame->mc_fregs[32]);
5284         env->fpscr = (uint32_t) fpscr;
5285     }
5286
5287     /* Save SPE registers.  The kernel only saves the high half.  */
5288     if (env->insns_flags & PPC_SPE) {
5289 #if defined(TARGET_PPC64)
5290         for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
5291             uint32_t hi;
5292
5293             __get_user(hi, &frame->mc_vregs.spe[i]);
5294             env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]);
5295         }
5296 #else
5297         for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
5298             __get_user(env->gprh[i], &frame->mc_vregs.spe[i]);
5299         }
5300 #endif
5301         __get_user(env->spe_fscr, &frame->mc_vregs.spe[32]);
5302     }
5303 }
5304
5305 #if !defined(TARGET_PPC64)
5306 static void setup_frame(int sig, struct target_sigaction *ka,
5307                         target_sigset_t *set, CPUPPCState *env)
5308 {
5309     struct target_sigframe *frame;
5310     struct target_sigcontext *sc;
5311     target_ulong frame_addr, newsp;
5312     int err = 0;
5313
5314     frame_addr = get_sigframe(ka, env, sizeof(*frame));
5315     trace_user_setup_frame(env, frame_addr);
5316     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
5317         goto sigsegv;
5318     sc = &frame->sctx;
5319
5320     __put_user(ka->_sa_handler, &sc->handler);
5321     __put_user(set->sig[0], &sc->oldmask);
5322     __put_user(set->sig[1], &sc->_unused[3]);
5323     __put_user(h2g(&frame->mctx), &sc->regs);
5324     __put_user(sig, &sc->signal);
5325
5326     /* Save user regs.  */
5327     save_user_regs(env, &frame->mctx);
5328
5329     /* Construct the trampoline code on the stack. */
5330     encode_trampoline(TARGET_NR_sigreturn, (uint32_t *)&frame->mctx.tramp);
5331
5332     /* The kernel checks for the presence of a VDSO here.  We don't
5333        emulate a vdso, so use a sigreturn system call.  */
5334     env->lr = (target_ulong) h2g(frame->mctx.tramp);
5335
5336     /* Turn off all fp exceptions.  */
5337     env->fpscr = 0;
5338
5339     /* Create a stack frame for the caller of the handler.  */
5340     newsp = frame_addr - SIGNAL_FRAMESIZE;
5341     err |= put_user(env->gpr[1], newsp, target_ulong);
5342
5343     if (err)
5344         goto sigsegv;
5345
5346     /* Set up registers for signal handler.  */
5347     env->gpr[1] = newsp;
5348     env->gpr[3] = sig;
5349     env->gpr[4] = frame_addr + offsetof(struct target_sigframe, sctx);
5350
5351     env->nip = (target_ulong) ka->_sa_handler;
5352
5353     /* Signal handlers are entered in big-endian mode.  */
5354     env->msr &= ~(1ull << MSR_LE);
5355
5356     unlock_user_struct(frame, frame_addr, 1);
5357     return;
5358
5359 sigsegv:
5360     unlock_user_struct(frame, frame_addr, 1);
5361     force_sigsegv(sig);
5362 }
5363 #endif /* !defined(TARGET_PPC64) */
5364
5365 static void setup_rt_frame(int sig, struct target_sigaction *ka,
5366                            target_siginfo_t *info,
5367                            target_sigset_t *set, CPUPPCState *env)
5368 {
5369     struct target_rt_sigframe *rt_sf;
5370     uint32_t *trampptr = 0;
5371     struct target_mcontext *mctx = 0;
5372     target_ulong rt_sf_addr, newsp = 0;
5373     int i, err = 0;
5374 #if defined(TARGET_PPC64)
5375     struct target_sigcontext *sc = 0;
5376     struct image_info *image = ((TaskState *)thread_cpu->opaque)->info;
5377 #endif
5378
5379     rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf));
5380     if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1))
5381         goto sigsegv;
5382
5383     tswap_siginfo(&rt_sf->info, info);
5384
5385     __put_user(0, &rt_sf->uc.tuc_flags);
5386     __put_user(0, &rt_sf->uc.tuc_link);
5387     __put_user((target_ulong)target_sigaltstack_used.ss_sp,
5388                &rt_sf->uc.tuc_stack.ss_sp);
5389     __put_user(sas_ss_flags(env->gpr[1]),
5390                &rt_sf->uc.tuc_stack.ss_flags);
5391     __put_user(target_sigaltstack_used.ss_size,
5392                &rt_sf->uc.tuc_stack.ss_size);
5393 #if !defined(TARGET_PPC64)
5394     __put_user(h2g (&rt_sf->uc.tuc_mcontext),
5395                &rt_sf->uc.tuc_regs);
5396 #endif
5397     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
5398         __put_user(set->sig[i], &rt_sf->uc.tuc_sigmask.sig[i]);
5399     }
5400
5401 #if defined(TARGET_PPC64)
5402     mctx = &rt_sf->uc.tuc_sigcontext.mcontext;
5403     trampptr = &rt_sf->trampoline[0];
5404
5405     sc = &rt_sf->uc.tuc_sigcontext;
5406     __put_user(h2g(mctx), &sc->regs);
5407     __put_user(sig, &sc->signal);
5408 #else
5409     mctx = &rt_sf->uc.tuc_mcontext;
5410     trampptr = (uint32_t *)&rt_sf->uc.tuc_mcontext.tramp;
5411 #endif
5412
5413     save_user_regs(env, mctx);
5414     encode_trampoline(TARGET_NR_rt_sigreturn, trampptr);
5415
5416     /* The kernel checks for the presence of a VDSO here.  We don't
5417        emulate a vdso, so use a sigreturn system call.  */
5418     env->lr = (target_ulong) h2g(trampptr);
5419
5420     /* Turn off all fp exceptions.  */
5421     env->fpscr = 0;
5422
5423     /* Create a stack frame for the caller of the handler.  */
5424     newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16);
5425     err |= put_user(env->gpr[1], newsp, target_ulong);
5426
5427     if (err)
5428         goto sigsegv;
5429
5430     /* Set up registers for signal handler.  */
5431     env->gpr[1] = newsp;
5432     env->gpr[3] = (target_ulong) sig;
5433     env->gpr[4] = (target_ulong) h2g(&rt_sf->info);
5434     env->gpr[5] = (target_ulong) h2g(&rt_sf->uc);
5435     env->gpr[6] = (target_ulong) h2g(rt_sf);
5436
5437 #if defined(TARGET_PPC64)
5438     if (get_ppc64_abi(image) < 2) {
5439         /* ELFv1 PPC64 function pointers are pointers to OPD entries. */
5440         struct target_func_ptr *handler =
5441             (struct target_func_ptr *)g2h(ka->_sa_handler);
5442         env->nip = tswapl(handler->entry);
5443         env->gpr[2] = tswapl(handler->toc);
5444     } else {
5445         /* ELFv2 PPC64 function pointers are entry points, but R12
5446          * must also be set */
5447         env->nip = tswapl((target_ulong) ka->_sa_handler);
5448         env->gpr[12] = env->nip;
5449     }
5450 #else
5451     env->nip = (target_ulong) ka->_sa_handler;
5452 #endif
5453
5454     /* Signal handlers are entered in big-endian mode.  */
5455     env->msr &= ~(1ull << MSR_LE);
5456
5457     unlock_user_struct(rt_sf, rt_sf_addr, 1);
5458     return;
5459
5460 sigsegv:
5461     unlock_user_struct(rt_sf, rt_sf_addr, 1);
5462     force_sigsegv(sig);
5463
5464 }
5465
5466 #if !defined(TARGET_PPC64)
5467 long do_sigreturn(CPUPPCState *env)
5468 {
5469     struct target_sigcontext *sc = NULL;
5470     struct target_mcontext *sr = NULL;
5471     target_ulong sr_addr = 0, sc_addr;
5472     sigset_t blocked;
5473     target_sigset_t set;
5474
5475     sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE;
5476     if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1))
5477         goto sigsegv;
5478
5479 #if defined(TARGET_PPC64)
5480     set.sig[0] = sc->oldmask + ((uint64_t)(sc->_unused[3]) << 32);
5481 #else
5482     __get_user(set.sig[0], &sc->oldmask);
5483     __get_user(set.sig[1], &sc->_unused[3]);
5484 #endif
5485     target_to_host_sigset_internal(&blocked, &set);
5486     set_sigmask(&blocked);
5487
5488     __get_user(sr_addr, &sc->regs);
5489     if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1))
5490         goto sigsegv;
5491     restore_user_regs(env, sr, 1);
5492
5493     unlock_user_struct(sr, sr_addr, 1);
5494     unlock_user_struct(sc, sc_addr, 1);
5495     return -TARGET_QEMU_ESIGRETURN;
5496
5497 sigsegv:
5498     unlock_user_struct(sr, sr_addr, 1);
5499     unlock_user_struct(sc, sc_addr, 1);
5500     force_sig(TARGET_SIGSEGV);
5501     return -TARGET_QEMU_ESIGRETURN;
5502 }
5503 #endif /* !defined(TARGET_PPC64) */
5504
5505 /* See arch/powerpc/kernel/signal_32.c.  */
5506 static int do_setcontext(struct target_ucontext *ucp, CPUPPCState *env, int sig)
5507 {
5508     struct target_mcontext *mcp;
5509     target_ulong mcp_addr;
5510     sigset_t blocked;
5511     target_sigset_t set;
5512
5513     if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, tuc_sigmask),
5514                        sizeof (set)))
5515         return 1;
5516
5517 #if defined(TARGET_PPC64)
5518     mcp_addr = h2g(ucp) +
5519         offsetof(struct target_ucontext, tuc_sigcontext.mcontext);
5520 #else
5521     __get_user(mcp_addr, &ucp->tuc_regs);
5522 #endif
5523
5524     if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1))
5525         return 1;
5526
5527     target_to_host_sigset_internal(&blocked, &set);
5528     set_sigmask(&blocked);
5529     restore_user_regs(env, mcp, sig);
5530
5531     unlock_user_struct(mcp, mcp_addr, 1);
5532     return 0;
5533 }
5534
5535 long do_rt_sigreturn(CPUPPCState *env)
5536 {
5537     struct target_rt_sigframe *rt_sf = NULL;
5538     target_ulong rt_sf_addr;
5539
5540     rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16;
5541     if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1))
5542         goto sigsegv;
5543
5544     if (do_setcontext(&rt_sf->uc, env, 1))
5545         goto sigsegv;
5546
5547     do_sigaltstack(rt_sf_addr
5548                    + offsetof(struct target_rt_sigframe, uc.tuc_stack),
5549                    0, env->gpr[1]);
5550
5551     unlock_user_struct(rt_sf, rt_sf_addr, 1);
5552     return -TARGET_QEMU_ESIGRETURN;
5553
5554 sigsegv:
5555     unlock_user_struct(rt_sf, rt_sf_addr, 1);
5556     force_sig(TARGET_SIGSEGV);
5557     return -TARGET_QEMU_ESIGRETURN;
5558 }
5559
5560 #elif defined(TARGET_M68K)
5561
5562 struct target_sigcontext {
5563     abi_ulong  sc_mask;
5564     abi_ulong  sc_usp;
5565     abi_ulong  sc_d0;
5566     abi_ulong  sc_d1;
5567     abi_ulong  sc_a0;
5568     abi_ulong  sc_a1;
5569     unsigned short sc_sr;
5570     abi_ulong  sc_pc;
5571 };
5572
5573 struct target_sigframe
5574 {
5575     abi_ulong pretcode;
5576     int sig;
5577     int code;
5578     abi_ulong psc;
5579     char retcode[8];
5580     abi_ulong extramask[TARGET_NSIG_WORDS-1];
5581     struct target_sigcontext sc;
5582 };
5583
5584 typedef int target_greg_t;
5585 #define TARGET_NGREG 18
5586 typedef target_greg_t target_gregset_t[TARGET_NGREG];
5587
5588 typedef struct target_fpregset {
5589     int f_fpcntl[3];
5590     int f_fpregs[8*3];
5591 } target_fpregset_t;
5592
5593 struct target_mcontext {
5594     int version;
5595     target_gregset_t gregs;
5596     target_fpregset_t fpregs;
5597 };
5598
5599 #define TARGET_MCONTEXT_VERSION 2
5600
5601 struct target_ucontext {
5602     abi_ulong tuc_flags;
5603     abi_ulong tuc_link;
5604     target_stack_t tuc_stack;
5605     struct target_mcontext tuc_mcontext;
5606     abi_long tuc_filler[80];
5607     target_sigset_t tuc_sigmask;
5608 };
5609
5610 struct target_rt_sigframe
5611 {
5612     abi_ulong pretcode;
5613     int sig;
5614     abi_ulong pinfo;
5615     abi_ulong puc;
5616     char retcode[8];
5617     struct target_siginfo info;
5618     struct target_ucontext uc;
5619 };
5620
5621 static void setup_sigcontext(struct target_sigcontext *sc, CPUM68KState *env,
5622                              abi_ulong mask)
5623 {
5624     uint32_t sr = (env->sr & 0xff00) | cpu_m68k_get_ccr(env);
5625     __put_user(mask, &sc->sc_mask);
5626     __put_user(env->aregs[7], &sc->sc_usp);
5627     __put_user(env->dregs[0], &sc->sc_d0);
5628     __put_user(env->dregs[1], &sc->sc_d1);
5629     __put_user(env->aregs[0], &sc->sc_a0);
5630     __put_user(env->aregs[1], &sc->sc_a1);
5631     __put_user(sr, &sc->sc_sr);
5632     __put_user(env->pc, &sc->sc_pc);
5633 }
5634
5635 static void
5636 restore_sigcontext(CPUM68KState *env, struct target_sigcontext *sc)
5637 {
5638     int temp;
5639
5640     __get_user(env->aregs[7], &sc->sc_usp);
5641     __get_user(env->dregs[0], &sc->sc_d0);
5642     __get_user(env->dregs[1], &sc->sc_d1);
5643     __get_user(env->aregs[0], &sc->sc_a0);
5644     __get_user(env->aregs[1], &sc->sc_a1);
5645     __get_user(env->pc, &sc->sc_pc);
5646     __get_user(temp, &sc->sc_sr);
5647     cpu_m68k_set_ccr(env, temp);
5648 }
5649
5650 /*
5651  * Determine which stack to use..
5652  */
5653 static inline abi_ulong
5654 get_sigframe(struct target_sigaction *ka, CPUM68KState *regs,
5655              size_t frame_size)
5656 {
5657     unsigned long sp;
5658
5659     sp = regs->aregs[7];
5660
5661     /* This is the X/Open sanctioned signal stack switching.  */
5662     if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
5663         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5664     }
5665
5666     return ((sp - frame_size) & -8UL);
5667 }
5668
5669 static void setup_frame(int sig, struct target_sigaction *ka,
5670                         target_sigset_t *set, CPUM68KState *env)
5671 {
5672     struct target_sigframe *frame;
5673     abi_ulong frame_addr;
5674     abi_ulong retcode_addr;
5675     abi_ulong sc_addr;
5676     int i;
5677
5678     frame_addr = get_sigframe(ka, env, sizeof *frame);
5679     trace_user_setup_frame(env, frame_addr);
5680     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5681         goto give_sigsegv;
5682     }
5683
5684     __put_user(sig, &frame->sig);
5685
5686     sc_addr = frame_addr + offsetof(struct target_sigframe, sc);
5687     __put_user(sc_addr, &frame->psc);
5688
5689     setup_sigcontext(&frame->sc, env, set->sig[0]);
5690
5691     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
5692         __put_user(set->sig[i], &frame->extramask[i - 1]);
5693     }
5694
5695     /* Set up to return from userspace.  */
5696
5697     retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
5698     __put_user(retcode_addr, &frame->pretcode);
5699
5700     /* moveq #,d0; trap #0 */
5701
5702     __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16),
5703                (uint32_t *)(frame->retcode));
5704
5705     /* Set up to return from userspace */
5706
5707     env->aregs[7] = frame_addr;
5708     env->pc = ka->_sa_handler;
5709
5710     unlock_user_struct(frame, frame_addr, 1);
5711     return;
5712
5713 give_sigsegv:
5714     force_sigsegv(sig);
5715 }
5716
5717 static inline void target_rt_save_fpu_state(struct target_ucontext *uc,
5718                                            CPUM68KState *env)
5719 {
5720     int i;
5721     target_fpregset_t *fpregs = &uc->tuc_mcontext.fpregs;
5722
5723     __put_user(env->fpcr, &fpregs->f_fpcntl[0]);
5724     __put_user(env->fpsr, &fpregs->f_fpcntl[1]);
5725     /* fpiar is not emulated */
5726
5727     for (i = 0; i < 8; i++) {
5728         uint32_t high = env->fregs[i].d.high << 16;
5729         __put_user(high, &fpregs->f_fpregs[i * 3]);
5730         __put_user(env->fregs[i].d.low,
5731                    (uint64_t *)&fpregs->f_fpregs[i * 3 + 1]);
5732     }
5733 }
5734
5735 static inline int target_rt_setup_ucontext(struct target_ucontext *uc,
5736                                            CPUM68KState *env)
5737 {
5738     target_greg_t *gregs = uc->tuc_mcontext.gregs;
5739     uint32_t sr = (env->sr & 0xff00) | cpu_m68k_get_ccr(env);
5740
5741     __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
5742     __put_user(env->dregs[0], &gregs[0]);
5743     __put_user(env->dregs[1], &gregs[1]);
5744     __put_user(env->dregs[2], &gregs[2]);
5745     __put_user(env->dregs[3], &gregs[3]);
5746     __put_user(env->dregs[4], &gregs[4]);
5747     __put_user(env->dregs[5], &gregs[5]);
5748     __put_user(env->dregs[6], &gregs[6]);
5749     __put_user(env->dregs[7], &gregs[7]);
5750     __put_user(env->aregs[0], &gregs[8]);
5751     __put_user(env->aregs[1], &gregs[9]);
5752     __put_user(env->aregs[2], &gregs[10]);
5753     __put_user(env->aregs[3], &gregs[11]);
5754     __put_user(env->aregs[4], &gregs[12]);
5755     __put_user(env->aregs[5], &gregs[13]);
5756     __put_user(env->aregs[6], &gregs[14]);
5757     __put_user(env->aregs[7], &gregs[15]);
5758     __put_user(env->pc, &gregs[16]);
5759     __put_user(sr, &gregs[17]);
5760
5761     target_rt_save_fpu_state(uc, env);
5762
5763     return 0;
5764 }
5765
5766 static inline void target_rt_restore_fpu_state(CPUM68KState *env,
5767                                                struct target_ucontext *uc)
5768 {
5769     int i;
5770     target_fpregset_t *fpregs = &uc->tuc_mcontext.fpregs;
5771     uint32_t fpcr;
5772
5773     __get_user(fpcr, &fpregs->f_fpcntl[0]);
5774     cpu_m68k_set_fpcr(env, fpcr);
5775     __get_user(env->fpsr, &fpregs->f_fpcntl[1]);
5776     /* fpiar is not emulated */
5777
5778     for (i = 0; i < 8; i++) {
5779         uint32_t high;
5780         __get_user(high, &fpregs->f_fpregs[i * 3]);
5781         env->fregs[i].d.high = high >> 16;
5782         __get_user(env->fregs[i].d.low,
5783                    (uint64_t *)&fpregs->f_fpregs[i * 3 + 1]);
5784     }
5785 }
5786
5787 static inline int target_rt_restore_ucontext(CPUM68KState *env,
5788                                              struct target_ucontext *uc)
5789 {
5790     int temp;
5791     target_greg_t *gregs = uc->tuc_mcontext.gregs;
5792
5793     __get_user(temp, &uc->tuc_mcontext.version);
5794     if (temp != TARGET_MCONTEXT_VERSION)
5795         goto badframe;
5796
5797     /* restore passed registers */
5798     __get_user(env->dregs[0], &gregs[0]);
5799     __get_user(env->dregs[1], &gregs[1]);
5800     __get_user(env->dregs[2], &gregs[2]);
5801     __get_user(env->dregs[3], &gregs[3]);
5802     __get_user(env->dregs[4], &gregs[4]);
5803     __get_user(env->dregs[5], &gregs[5]);
5804     __get_user(env->dregs[6], &gregs[6]);
5805     __get_user(env->dregs[7], &gregs[7]);
5806     __get_user(env->aregs[0], &gregs[8]);
5807     __get_user(env->aregs[1], &gregs[9]);
5808     __get_user(env->aregs[2], &gregs[10]);
5809     __get_user(env->aregs[3], &gregs[11]);
5810     __get_user(env->aregs[4], &gregs[12]);
5811     __get_user(env->aregs[5], &gregs[13]);
5812     __get_user(env->aregs[6], &gregs[14]);
5813     __get_user(env->aregs[7], &gregs[15]);
5814     __get_user(env->pc, &gregs[16]);
5815     __get_user(temp, &gregs[17]);
5816     cpu_m68k_set_ccr(env, temp);
5817
5818     target_rt_restore_fpu_state(env, uc);
5819
5820     return 0;
5821
5822 badframe:
5823     return 1;
5824 }
5825
5826 static void setup_rt_frame(int sig, struct target_sigaction *ka,
5827                            target_siginfo_t *info,
5828                            target_sigset_t *set, CPUM68KState *env)
5829 {
5830     struct target_rt_sigframe *frame;
5831     abi_ulong frame_addr;
5832     abi_ulong retcode_addr;
5833     abi_ulong info_addr;
5834     abi_ulong uc_addr;
5835     int err = 0;
5836     int i;
5837
5838     frame_addr = get_sigframe(ka, env, sizeof *frame);
5839     trace_user_setup_rt_frame(env, frame_addr);
5840     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5841         goto give_sigsegv;
5842     }
5843
5844     __put_user(sig, &frame->sig);
5845
5846     info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
5847     __put_user(info_addr, &frame->pinfo);
5848
5849     uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
5850     __put_user(uc_addr, &frame->puc);
5851
5852     tswap_siginfo(&frame->info, info);
5853
5854     /* Create the ucontext */
5855
5856     __put_user(0, &frame->uc.tuc_flags);
5857     __put_user(0, &frame->uc.tuc_link);
5858     __put_user(target_sigaltstack_used.ss_sp,
5859                &frame->uc.tuc_stack.ss_sp);
5860     __put_user(sas_ss_flags(env->aregs[7]),
5861             &frame->uc.tuc_stack.ss_flags);
5862     __put_user(target_sigaltstack_used.ss_size,
5863                &frame->uc.tuc_stack.ss_size);
5864     err |= target_rt_setup_ucontext(&frame->uc, env);
5865
5866     if (err)
5867         goto give_sigsegv;
5868
5869     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
5870         __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
5871     }
5872
5873     /* Set up to return from userspace.  */
5874
5875     retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
5876     __put_user(retcode_addr, &frame->pretcode);
5877
5878     /* moveq #,d0; notb d0; trap #0 */
5879
5880     __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16),
5881                (uint32_t *)(frame->retcode + 0));
5882     __put_user(0x4e40, (uint16_t *)(frame->retcode + 4));
5883
5884     if (err)
5885         goto give_sigsegv;
5886
5887     /* Set up to return from userspace */
5888
5889     env->aregs[7] = frame_addr;
5890     env->pc = ka->_sa_handler;
5891
5892     unlock_user_struct(frame, frame_addr, 1);
5893     return;
5894
5895 give_sigsegv:
5896     unlock_user_struct(frame, frame_addr, 1);
5897     force_sigsegv(sig);
5898 }
5899
5900 long do_sigreturn(CPUM68KState *env)
5901 {
5902     struct target_sigframe *frame;
5903     abi_ulong frame_addr = env->aregs[7] - 4;
5904     target_sigset_t target_set;
5905     sigset_t set;
5906     int i;
5907
5908     trace_user_do_sigreturn(env, frame_addr);
5909     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
5910         goto badframe;
5911
5912     /* set blocked signals */
5913
5914     __get_user(target_set.sig[0], &frame->sc.sc_mask);
5915
5916     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
5917         __get_user(target_set.sig[i], &frame->extramask[i - 1]);
5918     }
5919
5920     target_to_host_sigset_internal(&set, &target_set);
5921     set_sigmask(&set);
5922
5923     /* restore registers */
5924
5925     restore_sigcontext(env, &frame->sc);
5926
5927     unlock_user_struct(frame, frame_addr, 0);
5928     return -TARGET_QEMU_ESIGRETURN;
5929
5930 badframe:
5931     force_sig(TARGET_SIGSEGV);
5932     return -TARGET_QEMU_ESIGRETURN;
5933 }
5934
5935 long do_rt_sigreturn(CPUM68KState *env)
5936 {
5937     struct target_rt_sigframe *frame;
5938     abi_ulong frame_addr = env->aregs[7] - 4;
5939     sigset_t set;
5940
5941     trace_user_do_rt_sigreturn(env, frame_addr);
5942     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
5943         goto badframe;
5944
5945     target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
5946     set_sigmask(&set);
5947
5948     /* restore registers */
5949
5950     if (target_rt_restore_ucontext(env, &frame->uc))
5951         goto badframe;
5952
5953     if (do_sigaltstack(frame_addr +
5954                        offsetof(struct target_rt_sigframe, uc.tuc_stack),
5955                        0, get_sp_from_cpustate(env)) == -EFAULT)
5956         goto badframe;
5957
5958     unlock_user_struct(frame, frame_addr, 0);
5959     return -TARGET_QEMU_ESIGRETURN;
5960
5961 badframe:
5962     unlock_user_struct(frame, frame_addr, 0);
5963     force_sig(TARGET_SIGSEGV);
5964     return -TARGET_QEMU_ESIGRETURN;
5965 }
5966
5967 #elif defined(TARGET_ALPHA)
5968
5969 struct target_sigcontext {
5970     abi_long sc_onstack;
5971     abi_long sc_mask;
5972     abi_long sc_pc;
5973     abi_long sc_ps;
5974     abi_long sc_regs[32];
5975     abi_long sc_ownedfp;
5976     abi_long sc_fpregs[32];
5977     abi_ulong sc_fpcr;
5978     abi_ulong sc_fp_control;
5979     abi_ulong sc_reserved1;
5980     abi_ulong sc_reserved2;
5981     abi_ulong sc_ssize;
5982     abi_ulong sc_sbase;
5983     abi_ulong sc_traparg_a0;
5984     abi_ulong sc_traparg_a1;
5985     abi_ulong sc_traparg_a2;
5986     abi_ulong sc_fp_trap_pc;
5987     abi_ulong sc_fp_trigger_sum;
5988     abi_ulong sc_fp_trigger_inst;
5989 };
5990
5991 struct target_ucontext {
5992     abi_ulong tuc_flags;
5993     abi_ulong tuc_link;
5994     abi_ulong tuc_osf_sigmask;
5995     target_stack_t tuc_stack;
5996     struct target_sigcontext tuc_mcontext;
5997     target_sigset_t tuc_sigmask;
5998 };
5999
6000 struct target_sigframe {
6001     struct target_sigcontext sc;
6002     unsigned int retcode[3];
6003 };
6004
6005 struct target_rt_sigframe {
6006     target_siginfo_t info;
6007     struct target_ucontext uc;
6008     unsigned int retcode[3];
6009 };
6010
6011 #define INSN_MOV_R30_R16        0x47fe0410
6012 #define INSN_LDI_R0             0x201f0000
6013 #define INSN_CALLSYS            0x00000083
6014
6015 static void setup_sigcontext(struct target_sigcontext *sc, CPUAlphaState *env,
6016                              abi_ulong frame_addr, target_sigset_t *set)
6017 {
6018     int i;
6019
6020     __put_user(on_sig_stack(frame_addr), &sc->sc_onstack);
6021     __put_user(set->sig[0], &sc->sc_mask);
6022     __put_user(env->pc, &sc->sc_pc);
6023     __put_user(8, &sc->sc_ps);
6024
6025     for (i = 0; i < 31; ++i) {
6026         __put_user(env->ir[i], &sc->sc_regs[i]);
6027     }
6028     __put_user(0, &sc->sc_regs[31]);
6029
6030     for (i = 0; i < 31; ++i) {
6031         __put_user(env->fir[i], &sc->sc_fpregs[i]);
6032     }
6033     __put_user(0, &sc->sc_fpregs[31]);
6034     __put_user(cpu_alpha_load_fpcr(env), &sc->sc_fpcr);
6035
6036     __put_user(0, &sc->sc_traparg_a0); /* FIXME */
6037     __put_user(0, &sc->sc_traparg_a1); /* FIXME */
6038     __put_user(0, &sc->sc_traparg_a2); /* FIXME */
6039 }
6040
6041 static void restore_sigcontext(CPUAlphaState *env,
6042                                struct target_sigcontext *sc)
6043 {
6044     uint64_t fpcr;
6045     int i;
6046
6047     __get_user(env->pc, &sc->sc_pc);
6048
6049     for (i = 0; i < 31; ++i) {
6050         __get_user(env->ir[i], &sc->sc_regs[i]);
6051     }
6052     for (i = 0; i < 31; ++i) {
6053         __get_user(env->fir[i], &sc->sc_fpregs[i]);
6054     }
6055
6056     __get_user(fpcr, &sc->sc_fpcr);
6057     cpu_alpha_store_fpcr(env, fpcr);
6058 }
6059
6060 static inline abi_ulong get_sigframe(struct target_sigaction *sa,
6061                                      CPUAlphaState *env,
6062                                      unsigned long framesize)
6063 {
6064     abi_ulong sp = env->ir[IR_SP];
6065
6066     /* This is the X/Open sanctioned signal stack switching.  */
6067     if ((sa->sa_flags & TARGET_SA_ONSTACK) != 0 && !sas_ss_flags(sp)) {
6068         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
6069     }
6070     return (sp - framesize) & -32;
6071 }
6072
6073 static void setup_frame(int sig, struct target_sigaction *ka,
6074                         target_sigset_t *set, CPUAlphaState *env)
6075 {
6076     abi_ulong frame_addr, r26;
6077     struct target_sigframe *frame;
6078     int err = 0;
6079
6080     frame_addr = get_sigframe(ka, env, sizeof(*frame));
6081     trace_user_setup_frame(env, frame_addr);
6082     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
6083         goto give_sigsegv;
6084     }
6085
6086     setup_sigcontext(&frame->sc, env, frame_addr, set);
6087
6088     if (ka->sa_restorer) {
6089         r26 = ka->sa_restorer;
6090     } else {
6091         __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
6092         __put_user(INSN_LDI_R0 + TARGET_NR_sigreturn,
6093                    &frame->retcode[1]);
6094         __put_user(INSN_CALLSYS, &frame->retcode[2]);
6095         /* imb() */
6096         r26 = frame_addr;
6097     }
6098
6099     unlock_user_struct(frame, frame_addr, 1);
6100
6101     if (err) {
6102 give_sigsegv:
6103         force_sigsegv(sig);
6104         return;
6105     }
6106
6107     env->ir[IR_RA] = r26;
6108     env->ir[IR_PV] = env->pc = ka->_sa_handler;
6109     env->ir[IR_A0] = sig;
6110     env->ir[IR_A1] = 0;
6111     env->ir[IR_A2] = frame_addr + offsetof(struct target_sigframe, sc);
6112     env->ir[IR_SP] = frame_addr;
6113 }
6114
6115 static void setup_rt_frame(int sig, struct target_sigaction *ka,
6116                            target_siginfo_t *info,
6117                            target_sigset_t *set, CPUAlphaState *env)
6118 {
6119     abi_ulong frame_addr, r26;
6120     struct target_rt_sigframe *frame;
6121     int i, err = 0;
6122
6123     frame_addr = get_sigframe(ka, env, sizeof(*frame));
6124     trace_user_setup_rt_frame(env, frame_addr);
6125     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
6126         goto give_sigsegv;
6127     }
6128
6129     tswap_siginfo(&frame->info, info);
6130
6131     __put_user(0, &frame->uc.tuc_flags);
6132     __put_user(0, &frame->uc.tuc_link);
6133     __put_user(set->sig[0], &frame->uc.tuc_osf_sigmask);
6134     __put_user(target_sigaltstack_used.ss_sp,
6135                &frame->uc.tuc_stack.ss_sp);
6136     __put_user(sas_ss_flags(env->ir[IR_SP]),
6137                &frame->uc.tuc_stack.ss_flags);
6138     __put_user(target_sigaltstack_used.ss_size,
6139                &frame->uc.tuc_stack.ss_size);
6140     setup_sigcontext(&frame->uc.tuc_mcontext, env, frame_addr, set);
6141     for (i = 0; i < TARGET_NSIG_WORDS; ++i) {
6142         __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
6143     }
6144
6145     if (ka->sa_restorer) {
6146         r26 = ka->sa_restorer;
6147     } else {
6148         __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
6149         __put_user(INSN_LDI_R0 + TARGET_NR_rt_sigreturn,
6150                    &frame->retcode[1]);
6151         __put_user(INSN_CALLSYS, &frame->retcode[2]);
6152         /* imb(); */
6153         r26 = frame_addr;
6154     }
6155
6156     if (err) {
6157 give_sigsegv:
6158         force_sigsegv(sig);
6159         return;
6160     }
6161
6162     env->ir[IR_RA] = r26;
6163     env->ir[IR_PV] = env->pc = ka->_sa_handler;
6164     env->ir[IR_A0] = sig;
6165     env->ir[IR_A1] = frame_addr + offsetof(struct target_rt_sigframe, info);
6166     env->ir[IR_A2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
6167     env->ir[IR_SP] = frame_addr;
6168 }
6169
6170 long do_sigreturn(CPUAlphaState *env)
6171 {
6172     struct target_sigcontext *sc;
6173     abi_ulong sc_addr = env->ir[IR_A0];
6174     target_sigset_t target_set;
6175     sigset_t set;
6176
6177     if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) {
6178         goto badframe;
6179     }
6180
6181     target_sigemptyset(&target_set);
6182     __get_user(target_set.sig[0], &sc->sc_mask);
6183
6184     target_to_host_sigset_internal(&set, &target_set);
6185     set_sigmask(&set);
6186
6187     restore_sigcontext(env, sc);
6188     unlock_user_struct(sc, sc_addr, 0);
6189     return -TARGET_QEMU_ESIGRETURN;
6190
6191 badframe:
6192     force_sig(TARGET_SIGSEGV);
6193     return -TARGET_QEMU_ESIGRETURN;
6194 }
6195
6196 long do_rt_sigreturn(CPUAlphaState *env)
6197 {
6198     abi_ulong frame_addr = env->ir[IR_A0];
6199     struct target_rt_sigframe *frame;
6200     sigset_t set;
6201
6202     trace_user_do_rt_sigreturn(env, frame_addr);
6203     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
6204         goto badframe;
6205     }
6206     target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
6207     set_sigmask(&set);
6208
6209     restore_sigcontext(env, &frame->uc.tuc_mcontext);
6210     if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
6211                                              uc.tuc_stack),
6212                        0, env->ir[IR_SP]) == -EFAULT) {
6213         goto badframe;
6214     }
6215
6216     unlock_user_struct(frame, frame_addr, 0);
6217     return -TARGET_QEMU_ESIGRETURN;
6218
6219
6220 badframe:
6221     unlock_user_struct(frame, frame_addr, 0);
6222     force_sig(TARGET_SIGSEGV);
6223     return -TARGET_QEMU_ESIGRETURN;
6224 }
6225
6226 #elif defined(TARGET_TILEGX)
6227
6228 struct target_sigcontext {
6229     union {
6230         /* General-purpose registers.  */
6231         abi_ulong gregs[56];
6232         struct {
6233             abi_ulong __gregs[53];
6234             abi_ulong tp;        /* Aliases gregs[TREG_TP].  */
6235             abi_ulong sp;        /* Aliases gregs[TREG_SP].  */
6236             abi_ulong lr;        /* Aliases gregs[TREG_LR].  */
6237         };
6238     };
6239     abi_ulong pc;        /* Program counter.  */
6240     abi_ulong ics;       /* In Interrupt Critical Section?  */
6241     abi_ulong faultnum;  /* Fault number.  */
6242     abi_ulong pad[5];
6243 };
6244
6245 struct target_ucontext {
6246     abi_ulong tuc_flags;
6247     abi_ulong tuc_link;
6248     target_stack_t tuc_stack;
6249     struct target_sigcontext tuc_mcontext;
6250     target_sigset_t tuc_sigmask;   /* mask last for extensibility */
6251 };
6252
6253 struct target_rt_sigframe {
6254     unsigned char save_area[16]; /* caller save area */
6255     struct target_siginfo info;
6256     struct target_ucontext uc;
6257     abi_ulong retcode[2];
6258 };
6259
6260 #define INSN_MOVELI_R10_139  0x00045fe551483000ULL /* { moveli r10, 139 } */
6261 #define INSN_SWINT1          0x286b180051485000ULL /* { swint1 } */
6262
6263
6264 static void setup_sigcontext(struct target_sigcontext *sc,
6265                              CPUArchState *env, int signo)
6266 {
6267     int i;
6268
6269     for (i = 0; i < TILEGX_R_COUNT; ++i) {
6270         __put_user(env->regs[i], &sc->gregs[i]);
6271     }
6272
6273     __put_user(env->pc, &sc->pc);
6274     __put_user(0, &sc->ics);
6275     __put_user(signo, &sc->faultnum);
6276 }
6277
6278 static void restore_sigcontext(CPUTLGState *env, struct target_sigcontext *sc)
6279 {
6280     int i;
6281
6282     for (i = 0; i < TILEGX_R_COUNT; ++i) {
6283         __get_user(env->regs[i], &sc->gregs[i]);
6284     }
6285
6286     __get_user(env->pc, &sc->pc);
6287 }
6288
6289 static abi_ulong get_sigframe(struct target_sigaction *ka, CPUArchState *env,
6290                               size_t frame_size)
6291 {
6292     unsigned long sp = env->regs[TILEGX_R_SP];
6293
6294     if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size))) {
6295         return -1UL;
6296     }
6297
6298     if ((ka->sa_flags & SA_ONSTACK) && !sas_ss_flags(sp)) {
6299         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
6300     }
6301
6302     sp -= frame_size;
6303     sp &= -16UL;
6304     return sp;
6305 }
6306
6307 static void setup_rt_frame(int sig, struct target_sigaction *ka,
6308                            target_siginfo_t *info,
6309                            target_sigset_t *set, CPUArchState *env)
6310 {
6311     abi_ulong frame_addr;
6312     struct target_rt_sigframe *frame;
6313     unsigned long restorer;
6314
6315     frame_addr = get_sigframe(ka, env, sizeof(*frame));
6316     trace_user_setup_rt_frame(env, frame_addr);
6317     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
6318         goto give_sigsegv;
6319     }
6320
6321     /* Always write at least the signal number for the stack backtracer. */
6322     if (ka->sa_flags & TARGET_SA_SIGINFO) {
6323         /* At sigreturn time, restore the callee-save registers too. */
6324         tswap_siginfo(&frame->info, info);
6325         /* regs->flags |= PT_FLAGS_RESTORE_REGS; FIXME: we can skip it? */
6326     } else {
6327         __put_user(info->si_signo, &frame->info.si_signo);
6328     }
6329
6330     /* Create the ucontext.  */
6331     __put_user(0, &frame->uc.tuc_flags);
6332     __put_user(0, &frame->uc.tuc_link);
6333     __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
6334     __put_user(sas_ss_flags(env->regs[TILEGX_R_SP]),
6335                &frame->uc.tuc_stack.ss_flags);
6336     __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
6337     setup_sigcontext(&frame->uc.tuc_mcontext, env, info->si_signo);
6338
6339     if (ka->sa_flags & TARGET_SA_RESTORER) {
6340         restorer = (unsigned long) ka->sa_restorer;
6341     } else {
6342         __put_user(INSN_MOVELI_R10_139, &frame->retcode[0]);
6343         __put_user(INSN_SWINT1, &frame->retcode[1]);
6344         restorer = frame_addr + offsetof(struct target_rt_sigframe, retcode);
6345     }
6346     env->pc = (unsigned long) ka->_sa_handler;
6347     env->regs[TILEGX_R_SP] = (unsigned long) frame;
6348     env->regs[TILEGX_R_LR] = restorer;
6349     env->regs[0] = (unsigned long) sig;
6350     env->regs[1] = (unsigned long) &frame->info;
6351     env->regs[2] = (unsigned long) &frame->uc;
6352     /* regs->flags |= PT_FLAGS_CALLER_SAVES; FIXME: we can skip it? */
6353
6354     unlock_user_struct(frame, frame_addr, 1);
6355     return;
6356
6357 give_sigsegv:
6358     force_sigsegv(sig);
6359 }
6360
6361 long do_rt_sigreturn(CPUTLGState *env)
6362 {
6363     abi_ulong frame_addr = env->regs[TILEGX_R_SP];
6364     struct target_rt_sigframe *frame;
6365     sigset_t set;
6366
6367     trace_user_do_rt_sigreturn(env, frame_addr);
6368     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
6369         goto badframe;
6370     }
6371     target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
6372     set_sigmask(&set);
6373
6374     restore_sigcontext(env, &frame->uc.tuc_mcontext);
6375     if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
6376                                              uc.tuc_stack),
6377                        0, env->regs[TILEGX_R_SP]) == -EFAULT) {
6378         goto badframe;
6379     }
6380
6381     unlock_user_struct(frame, frame_addr, 0);
6382     return -TARGET_QEMU_ESIGRETURN;
6383
6384
6385  badframe:
6386     unlock_user_struct(frame, frame_addr, 0);
6387     force_sig(TARGET_SIGSEGV);
6388     return -TARGET_QEMU_ESIGRETURN;
6389 }
6390
6391 #elif defined(TARGET_RISCV)
6392
6393 /* Signal handler invocation must be transparent for the code being
6394    interrupted. Complete CPU (hart) state is saved on entry and restored
6395    before returning from the handler. Process sigmask is also saved to block
6396    signals while the handler is running. The handler gets its own stack,
6397    which also doubles as storage for the CPU state and sigmask.
6398
6399    The code below is qemu re-implementation of arch/riscv/kernel/signal.c */
6400
6401 struct target_sigcontext {
6402     abi_long pc;
6403     abi_long gpr[31]; /* x0 is not present, so all offsets must be -1 */
6404     uint64_t fpr[32];
6405     uint32_t fcsr;
6406 }; /* cf. riscv-linux:arch/riscv/include/uapi/asm/ptrace.h */
6407
6408 struct target_ucontext {
6409     unsigned long uc_flags;
6410     struct target_ucontext *uc_link;
6411     target_stack_t uc_stack;
6412     struct target_sigcontext uc_mcontext;
6413     target_sigset_t uc_sigmask;
6414 };
6415
6416 struct target_rt_sigframe {
6417     uint32_t tramp[2]; /* not in kernel, which uses VDSO instead */
6418     struct target_siginfo info;
6419     struct target_ucontext uc;
6420 };
6421
6422 static abi_ulong get_sigframe(struct target_sigaction *ka,
6423                               CPURISCVState *regs, size_t framesize)
6424 {
6425     abi_ulong sp = regs->gpr[xSP];
6426     int onsigstack = on_sig_stack(sp);
6427
6428     /* redzone */
6429     /* This is the X/Open sanctioned signal stack switching.  */
6430     if ((ka->sa_flags & TARGET_SA_ONSTACK) != 0 && !onsigstack) {
6431         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
6432     }
6433
6434     sp -= framesize;
6435     sp &= ~3UL; /* align sp on 4-byte boundary */
6436
6437     /* If we are on the alternate signal stack and would overflow it, don't.
6438        Return an always-bogus address instead so we will die with SIGSEGV. */
6439     if (onsigstack && !likely(on_sig_stack(sp))) {
6440         return -1L;
6441     }
6442
6443     return sp;
6444 }
6445
6446 static void setup_sigcontext(struct target_sigcontext *sc, CPURISCVState *env)
6447 {
6448     int i;
6449
6450     __put_user(env->pc, &sc->pc);
6451
6452     for (i = 1; i < 32; i++) {
6453         __put_user(env->gpr[i], &sc->gpr[i - 1]);
6454     }
6455     for (i = 0; i < 32; i++) {
6456         __put_user(env->fpr[i], &sc->fpr[i]);
6457     }
6458
6459     uint32_t fcsr = csr_read_helper(env, CSR_FCSR); /*riscv_get_fcsr(env);*/
6460     __put_user(fcsr, &sc->fcsr);
6461 }
6462
6463 static void setup_ucontext(struct target_ucontext *uc,
6464                            CPURISCVState *env, target_sigset_t *set)
6465 {
6466     abi_ulong ss_sp = (target_ulong)target_sigaltstack_used.ss_sp;
6467     abi_ulong ss_flags = sas_ss_flags(env->gpr[xSP]);
6468     abi_ulong ss_size = target_sigaltstack_used.ss_size;
6469
6470     __put_user(0,    &(uc->uc_flags));
6471     __put_user(0,    &(uc->uc_link));
6472
6473     __put_user(ss_sp,    &(uc->uc_stack.ss_sp));
6474     __put_user(ss_flags, &(uc->uc_stack.ss_flags));
6475     __put_user(ss_size,  &(uc->uc_stack.ss_size));
6476
6477     int i;
6478     for (i = 0; i < TARGET_NSIG_WORDS; i++) {
6479         __put_user(set->sig[i], &(uc->uc_sigmask.sig[i]));
6480     }
6481
6482     setup_sigcontext(&uc->uc_mcontext, env);
6483 }
6484
6485 static inline void install_sigtramp(uint32_t *tramp)
6486 {
6487     __put_user(0x08b00893, tramp + 0);  /* li a7, 139 = __NR_rt_sigreturn */
6488     __put_user(0x00000073, tramp + 1);  /* ecall */
6489 }
6490
6491 static void setup_rt_frame(int sig, struct target_sigaction *ka,
6492                            target_siginfo_t *info,
6493                            target_sigset_t *set, CPURISCVState *env)
6494 {
6495     abi_ulong frame_addr;
6496     struct target_rt_sigframe *frame;
6497
6498     frame_addr = get_sigframe(ka, env, sizeof(*frame));
6499     trace_user_setup_rt_frame(env, frame_addr);
6500
6501     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
6502         goto badframe;
6503     }
6504
6505     setup_ucontext(&frame->uc, env, set);
6506     tswap_siginfo(&frame->info, info);
6507     install_sigtramp(frame->tramp);
6508
6509     env->pc = ka->_sa_handler;
6510     env->gpr[xSP] = frame_addr;
6511     env->gpr[xA0] = sig;
6512     env->gpr[xA1] = frame_addr + offsetof(struct target_rt_sigframe, info);
6513     env->gpr[xA2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
6514     env->gpr[xRA] = frame_addr + offsetof(struct target_rt_sigframe, tramp);
6515
6516     return;
6517
6518 badframe:
6519     unlock_user_struct(frame, frame_addr, 1);
6520     if (sig == TARGET_SIGSEGV) {
6521         ka->_sa_handler = TARGET_SIG_DFL;
6522     }
6523     force_sig(TARGET_SIGSEGV);
6524 }
6525
6526 static void restore_sigcontext(CPURISCVState *env, struct target_sigcontext *sc)
6527 {
6528     int i;
6529
6530     __get_user(env->pc, &sc->pc);
6531
6532     for (i = 1; i < 32; ++i) {
6533         __get_user(env->gpr[i], &sc->gpr[i - 1]);
6534     }
6535     for (i = 0; i < 32; ++i) {
6536         __get_user(env->fpr[i], &sc->fpr[i]);
6537     }
6538
6539     uint32_t fcsr;
6540     __get_user(fcsr, &sc->fcsr);
6541     csr_write_helper(env, fcsr, CSR_FCSR);
6542 }
6543
6544 static void restore_ucontext(CPURISCVState *env, struct target_ucontext *uc)
6545 {
6546     sigset_t blocked;
6547     target_sigset_t target_set;
6548     int i;
6549
6550     target_sigemptyset(&target_set);
6551     for (i = 0; i < TARGET_NSIG_WORDS; i++) {
6552         __get_user(target_set.sig[i], &(uc->uc_sigmask.sig[i]));
6553     }
6554
6555     target_to_host_sigset_internal(&blocked, &target_set);
6556     set_sigmask(&blocked);
6557
6558     restore_sigcontext(env, &uc->uc_mcontext);
6559 }
6560
6561 long do_rt_sigreturn(CPURISCVState *env)
6562 {
6563     struct target_rt_sigframe *frame;
6564     abi_ulong frame_addr;
6565
6566     frame_addr = env->gpr[xSP];
6567     trace_user_do_sigreturn(env, frame_addr);
6568     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
6569         goto badframe;
6570     }
6571
6572     restore_ucontext(env, &frame->uc);
6573
6574     if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
6575             uc.uc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT) {
6576         goto badframe;
6577     }
6578
6579     unlock_user_struct(frame, frame_addr, 0);
6580     return -TARGET_QEMU_ESIGRETURN;
6581
6582 badframe:
6583     unlock_user_struct(frame, frame_addr, 0);
6584     force_sig(TARGET_SIGSEGV);
6585     return 0;
6586 }
6587
6588 #elif defined(TARGET_HPPA)
6589
6590 struct target_sigcontext {
6591     abi_ulong sc_flags;
6592     abi_ulong sc_gr[32];
6593     uint64_t sc_fr[32];
6594     abi_ulong sc_iasq[2];
6595     abi_ulong sc_iaoq[2];
6596     abi_ulong sc_sar;
6597 };
6598
6599 struct target_ucontext {
6600     abi_uint tuc_flags;
6601     abi_ulong tuc_link;
6602     target_stack_t tuc_stack;
6603     abi_uint pad[1];
6604     struct target_sigcontext tuc_mcontext;
6605     target_sigset_t tuc_sigmask;
6606 };
6607
6608 struct target_rt_sigframe {
6609     abi_uint tramp[9];
6610     target_siginfo_t info;
6611     struct target_ucontext uc;
6612     /* hidden location of upper halves of pa2.0 64-bit gregs */
6613 };
6614
6615 static void setup_sigcontext(struct target_sigcontext *sc, CPUArchState *env)
6616 {
6617     int flags = 0;
6618     int i;
6619
6620     /* ??? if on_sig_stack, flags |= 1 (PARISC_SC_FLAG_ONSTACK).  */
6621
6622     if (env->iaoq_f < TARGET_PAGE_SIZE) {
6623         /* In the gateway page, executing a syscall.  */
6624         flags |= 2; /* PARISC_SC_FLAG_IN_SYSCALL */
6625         __put_user(env->gr[31], &sc->sc_iaoq[0]);
6626         __put_user(env->gr[31] + 4, &sc->sc_iaoq[1]);
6627     } else {
6628         __put_user(env->iaoq_f, &sc->sc_iaoq[0]);
6629         __put_user(env->iaoq_b, &sc->sc_iaoq[1]);
6630     }
6631     __put_user(0, &sc->sc_iasq[0]);
6632     __put_user(0, &sc->sc_iasq[1]);
6633     __put_user(flags, &sc->sc_flags);
6634
6635     __put_user(cpu_hppa_get_psw(env), &sc->sc_gr[0]);
6636     for (i = 1; i < 32; ++i) {
6637         __put_user(env->gr[i], &sc->sc_gr[i]);
6638     }
6639
6640     __put_user((uint64_t)env->fr0_shadow << 32, &sc->sc_fr[0]);
6641     for (i = 1; i < 32; ++i) {
6642         __put_user(env->fr[i], &sc->sc_fr[i]);
6643     }
6644
6645     __put_user(env->cr[CR_SAR], &sc->sc_sar);
6646 }
6647
6648 static void restore_sigcontext(CPUArchState *env, struct target_sigcontext *sc)
6649 {
6650     target_ulong psw;
6651     int i;
6652
6653     __get_user(psw, &sc->sc_gr[0]);
6654     cpu_hppa_put_psw(env, psw);
6655
6656     for (i = 1; i < 32; ++i) {
6657         __get_user(env->gr[i], &sc->sc_gr[i]);
6658     }
6659     for (i = 0; i < 32; ++i) {
6660         __get_user(env->fr[i], &sc->sc_fr[i]);
6661     }
6662     cpu_hppa_loaded_fr0(env);
6663
6664     __get_user(env->iaoq_f, &sc->sc_iaoq[0]);
6665     __get_user(env->iaoq_b, &sc->sc_iaoq[1]);
6666     __get_user(env->cr[CR_SAR], &sc->sc_sar);
6667 }
6668
6669 /* No, this doesn't look right, but it's copied straight from the kernel.  */
6670 #define PARISC_RT_SIGFRAME_SIZE32 \
6671     ((sizeof(struct target_rt_sigframe) + 48 + 64) & -64)
6672
6673 static void setup_rt_frame(int sig, struct target_sigaction *ka,
6674                            target_siginfo_t *info,
6675                            target_sigset_t *set, CPUArchState *env)
6676 {
6677     abi_ulong frame_addr, sp, haddr;
6678     struct target_rt_sigframe *frame;
6679     int i;
6680
6681     sp = env->gr[30];
6682     if (ka->sa_flags & TARGET_SA_ONSTACK) {
6683         if (sas_ss_flags(sp) == 0) {
6684             sp = (target_sigaltstack_used.ss_sp + 0x7f) & ~0x3f;
6685         }
6686     }
6687     frame_addr = QEMU_ALIGN_UP(sp, 64);
6688     sp = frame_addr + PARISC_RT_SIGFRAME_SIZE32;
6689
6690     trace_user_setup_rt_frame(env, frame_addr);
6691
6692     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
6693         goto give_sigsegv;
6694     }
6695
6696     tswap_siginfo(&frame->info, info);
6697     frame->uc.tuc_flags = 0;
6698     frame->uc.tuc_link = 0;
6699
6700     __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
6701     __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
6702                &frame->uc.tuc_stack.ss_flags);
6703     __put_user(target_sigaltstack_used.ss_size,
6704                &frame->uc.tuc_stack.ss_size);
6705
6706     for (i = 0; i < TARGET_NSIG_WORDS; i++) {
6707         __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
6708     }
6709
6710     setup_sigcontext(&frame->uc.tuc_mcontext, env);
6711
6712     __put_user(0x34190000, frame->tramp + 0); /* ldi 0,%r25 */
6713     __put_user(0x3414015a, frame->tramp + 1); /* ldi __NR_rt_sigreturn,%r20 */
6714     __put_user(0xe4008200, frame->tramp + 2); /* be,l 0x100(%sr2,%r0) */
6715     __put_user(0x08000240, frame->tramp + 3); /* nop */
6716
6717     unlock_user_struct(frame, frame_addr, 1);
6718
6719     env->gr[2] = h2g(frame->tramp);
6720     env->gr[30] = sp;
6721     env->gr[26] = sig;
6722     env->gr[25] = h2g(&frame->info);
6723     env->gr[24] = h2g(&frame->uc);
6724
6725     haddr = ka->_sa_handler;
6726     if (haddr & 2) {
6727         /* Function descriptor.  */
6728         target_ulong *fdesc, dest;
6729
6730         haddr &= -4;
6731         if (!lock_user_struct(VERIFY_READ, fdesc, haddr, 1)) {
6732             goto give_sigsegv;
6733         }
6734         __get_user(dest, fdesc);
6735         __get_user(env->gr[19], fdesc + 1);
6736         unlock_user_struct(fdesc, haddr, 1);
6737         haddr = dest;
6738     }
6739     env->iaoq_f = haddr;
6740     env->iaoq_b = haddr + 4;
6741     return;
6742
6743  give_sigsegv:
6744     force_sigsegv(sig);
6745 }
6746
6747 long do_rt_sigreturn(CPUArchState *env)
6748 {
6749     abi_ulong frame_addr = env->gr[30] - PARISC_RT_SIGFRAME_SIZE32;
6750     struct target_rt_sigframe *frame;
6751     sigset_t set;
6752
6753     trace_user_do_rt_sigreturn(env, frame_addr);
6754     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
6755         goto badframe;
6756     }
6757     target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
6758     set_sigmask(&set);
6759
6760     restore_sigcontext(env, &frame->uc.tuc_mcontext);
6761     unlock_user_struct(frame, frame_addr, 0);
6762
6763     if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
6764                                              uc.tuc_stack),
6765                        0, env->gr[30]) == -EFAULT) {
6766         goto badframe;
6767     }
6768
6769     unlock_user_struct(frame, frame_addr, 0);
6770     return -TARGET_QEMU_ESIGRETURN;
6771
6772  badframe:
6773     force_sig(TARGET_SIGSEGV);
6774     return -TARGET_QEMU_ESIGRETURN;
6775 }
6776
6777 #else
6778
6779 static void setup_frame(int sig, struct target_sigaction *ka,
6780                         target_sigset_t *set, CPUArchState *env)
6781 {
6782     fprintf(stderr, "setup_frame: not implemented\n");
6783 }
6784
6785 static void setup_rt_frame(int sig, struct target_sigaction *ka,
6786                            target_siginfo_t *info,
6787                            target_sigset_t *set, CPUArchState *env)
6788 {
6789     fprintf(stderr, "setup_rt_frame: not implemented\n");
6790 }
6791
6792 long do_sigreturn(CPUArchState *env)
6793 {
6794     fprintf(stderr, "do_sigreturn: not implemented\n");
6795     return -TARGET_ENOSYS;
6796 }
6797
6798 long do_rt_sigreturn(CPUArchState *env)
6799 {
6800     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
6801     return -TARGET_ENOSYS;
6802 }
6803
6804 #endif
6805
6806 static void handle_pending_signal(CPUArchState *cpu_env, int sig,
6807                                   struct emulated_sigtable *k)
6808 {
6809     CPUState *cpu = ENV_GET_CPU(cpu_env);
6810     abi_ulong handler;
6811     sigset_t set;
6812     target_sigset_t target_old_set;
6813     struct target_sigaction *sa;
6814     TaskState *ts = cpu->opaque;
6815
6816     trace_user_handle_signal(cpu_env, sig);
6817     /* dequeue signal */
6818     k->pending = 0;
6819
6820     sig = gdb_handlesig(cpu, sig);
6821     if (!sig) {
6822         sa = NULL;
6823         handler = TARGET_SIG_IGN;
6824     } else {
6825         sa = &sigact_table[sig - 1];
6826         handler = sa->_sa_handler;
6827     }
6828
6829     if (do_strace) {
6830         print_taken_signal(sig, &k->info);
6831     }
6832
6833     if (handler == TARGET_SIG_DFL) {
6834         /* default handler : ignore some signal. The other are job control or fatal */
6835         if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
6836             kill(getpid(),SIGSTOP);
6837         } else if (sig != TARGET_SIGCHLD &&
6838                    sig != TARGET_SIGURG &&
6839                    sig != TARGET_SIGWINCH &&
6840                    sig != TARGET_SIGCONT) {
6841             dump_core_and_abort(sig);
6842         }
6843     } else if (handler == TARGET_SIG_IGN) {
6844         /* ignore sig */
6845     } else if (handler == TARGET_SIG_ERR) {
6846         dump_core_and_abort(sig);
6847     } else {
6848         /* compute the blocked signals during the handler execution */
6849         sigset_t *blocked_set;
6850
6851         target_to_host_sigset(&set, &sa->sa_mask);
6852         /* SA_NODEFER indicates that the current signal should not be
6853            blocked during the handler */
6854         if (!(sa->sa_flags & TARGET_SA_NODEFER))
6855             sigaddset(&set, target_to_host_signal(sig));
6856
6857         /* save the previous blocked signal state to restore it at the
6858            end of the signal execution (see do_sigreturn) */
6859         host_to_target_sigset_internal(&target_old_set, &ts->signal_mask);
6860
6861         /* block signals in the handler */
6862         blocked_set = ts->in_sigsuspend ?
6863             &ts->sigsuspend_mask : &ts->signal_mask;
6864         sigorset(&ts->signal_mask, blocked_set, &set);
6865         ts->in_sigsuspend = 0;
6866
6867         /* if the CPU is in VM86 mode, we restore the 32 bit values */
6868 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
6869         {
6870             CPUX86State *env = cpu_env;
6871             if (env->eflags & VM_MASK)
6872                 save_v86_state(env);
6873         }
6874 #endif
6875         /* prepare the stack frame of the virtual CPU */
6876 #if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64) \
6877         || defined(TARGET_OPENRISC) || defined(TARGET_TILEGX) \
6878         || defined(TARGET_PPC64) || defined(TARGET_HPPA) \
6879         || defined(TARGET_NIOS2) || defined(TARGET_X86_64) \
6880         || defined(TARGET_RISCV)
6881         /* These targets do not have traditional signals.  */
6882         setup_rt_frame(sig, sa, &k->info, &target_old_set, cpu_env);
6883 #else
6884         if (sa->sa_flags & TARGET_SA_SIGINFO)
6885             setup_rt_frame(sig, sa, &k->info, &target_old_set, cpu_env);
6886         else
6887             setup_frame(sig, sa, &target_old_set, cpu_env);
6888 #endif
6889         if (sa->sa_flags & TARGET_SA_RESETHAND) {
6890             sa->_sa_handler = TARGET_SIG_DFL;
6891         }
6892     }
6893 }
6894
6895 void process_pending_signals(CPUArchState *cpu_env)
6896 {
6897     CPUState *cpu = ENV_GET_CPU(cpu_env);
6898     int sig;
6899     TaskState *ts = cpu->opaque;
6900     sigset_t set;
6901     sigset_t *blocked_set;
6902
6903     while (atomic_read(&ts->signal_pending)) {
6904         /* FIXME: This is not threadsafe.  */
6905         sigfillset(&set);
6906         sigprocmask(SIG_SETMASK, &set, 0);
6907
6908     restart_scan:
6909         sig = ts->sync_signal.pending;
6910         if (sig) {
6911             /* Synchronous signals are forced,
6912              * see force_sig_info() and callers in Linux
6913              * Note that not all of our queue_signal() calls in QEMU correspond
6914              * to force_sig_info() calls in Linux (some are send_sig_info()).
6915              * However it seems like a kernel bug to me to allow the process
6916              * to block a synchronous signal since it could then just end up
6917              * looping round and round indefinitely.
6918              */
6919             if (sigismember(&ts->signal_mask, target_to_host_signal_table[sig])
6920                 || sigact_table[sig - 1]._sa_handler == TARGET_SIG_IGN) {
6921                 sigdelset(&ts->signal_mask, target_to_host_signal_table[sig]);
6922                 sigact_table[sig - 1]._sa_handler = TARGET_SIG_DFL;
6923             }
6924
6925             handle_pending_signal(cpu_env, sig, &ts->sync_signal);
6926         }
6927
6928         for (sig = 1; sig <= TARGET_NSIG; sig++) {
6929             blocked_set = ts->in_sigsuspend ?
6930                 &ts->sigsuspend_mask : &ts->signal_mask;
6931
6932             if (ts->sigtab[sig - 1].pending &&
6933                 (!sigismember(blocked_set,
6934                               target_to_host_signal_table[sig]))) {
6935                 handle_pending_signal(cpu_env, sig, &ts->sigtab[sig - 1]);
6936                 /* Restart scan from the beginning, as handle_pending_signal
6937                  * might have resulted in a new synchronous signal (eg SIGSEGV).
6938                  */
6939                 goto restart_scan;
6940             }
6941         }
6942
6943         /* if no signal is pending, unblock signals and recheck (the act
6944          * of unblocking might cause us to take another host signal which
6945          * will set signal_pending again).
6946          */
6947         atomic_set(&ts->signal_pending, 0);
6948         ts->in_sigsuspend = 0;
6949         set = ts->signal_mask;
6950         sigdelset(&set, SIGSEGV);
6951         sigdelset(&set, SIGBUS);
6952         sigprocmask(SIG_SETMASK, &set, 0);
6953     }
6954     ts->in_sigsuspend = 0;
6955 }