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