qemu/linux-user/signal.c

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