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