linux-user/signal.c

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