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
  31 #include "qemu.h"
  32 #include "qemu-common.h"
  33 #include "target_signal.h"
  34
  35 //#define DEBUG_SIGNAL
  36
  37 static struct target_sigaltstack target_sigaltstack_used = {
  38     .ss_sp = 0,
  39     .ss_size = 0,
  40     .ss_flags = TARGET_SS_DISABLE,
  41 };
  42
  43 static struct target_sigaction sigact_table[TARGET_NSIG];
  44
  45 static void host_signal_handler(int host_signum, siginfo_t *info,
  46                                 void *puc);
  47
  48 static uint8_t host_to_target_signal_table[65] = {
  49     [SIGHUP] = TARGET_SIGHUP,
  50     [SIGINT] = TARGET_SIGINT,
  51     [SIGQUIT] = TARGET_SIGQUIT,
  52     [SIGILL] = TARGET_SIGILL,
  53     [SIGTRAP] = TARGET_SIGTRAP,
  54     [SIGABRT] = TARGET_SIGABRT,
  55 /*    [SIGIOT] = TARGET_SIGIOT,*/
  56     [SIGBUS] = TARGET_SIGBUS,
  57     [SIGFPE] = TARGET_SIGFPE,
  58     [SIGKILL] = TARGET_SIGKILL,
  59     [SIGUSR1] = TARGET_SIGUSR1,
  60     [SIGSEGV] = TARGET_SIGSEGV,
  61     [SIGUSR2] = TARGET_SIGUSR2,
  62     [SIGPIPE] = TARGET_SIGPIPE,
  63     [SIGALRM] = TARGET_SIGALRM,
  64     [SIGTERM] = TARGET_SIGTERM,
  65 #ifdef SIGSTKFLT
  66     [SIGSTKFLT] = TARGET_SIGSTKFLT,
  67 #endif
  68     [SIGCHLD] = TARGET_SIGCHLD,
  69     [SIGCONT] = TARGET_SIGCONT,
  70     [SIGSTOP] = TARGET_SIGSTOP,
  71     [SIGTSTP] = TARGET_SIGTSTP,
  72     [SIGTTIN] = TARGET_SIGTTIN,
  73     [SIGTTOU] = TARGET_SIGTTOU,
  74     [SIGURG] = TARGET_SIGURG,
  75     [SIGXCPU] = TARGET_SIGXCPU,
  76     [SIGXFSZ] = TARGET_SIGXFSZ,
  77     [SIGVTALRM] = TARGET_SIGVTALRM,
  78     [SIGPROF] = TARGET_SIGPROF,
  79     [SIGWINCH] = TARGET_SIGWINCH,
  80     [SIGIO] = TARGET_SIGIO,
  81     [SIGPWR] = TARGET_SIGPWR,
  82     [SIGSYS] = TARGET_SIGSYS,
  83     /* next signals stay the same */
  84     /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with
  85        host libpthread signals.  This assumes noone actually uses SIGRTMAX :-/
  86        To fix this properly we need to do manual signal delivery multiplexed
  87        over a single host signal.  */
  88     [__SIGRTMIN] = __SIGRTMAX,
  89     [__SIGRTMAX] = __SIGRTMIN,
  90 };
  91 static uint8_t target_to_host_signal_table[65];
  92
  93 static inline int on_sig_stack(unsigned long sp)
  94 {
  95     return (sp - target_sigaltstack_used.ss_sp
  96             < target_sigaltstack_used.ss_size);
  97 }
  98
  99 static inline int sas_ss_flags(unsigned long sp)
 100 {
 101     return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE
 102             : on_sig_stack(sp) ? SS_ONSTACK : 0);
 103 }
 104
 105 static inline int host_to_target_signal(int sig)
 106 {
 107     if (sig > 64)
 108         return sig;
 109     return host_to_target_signal_table[sig];
 110 }
 111
 112 int target_to_host_signal(int sig)
 113 {
 114     if (sig > 64)
 115         return sig;
 116     return target_to_host_signal_table[sig];
 117 }
 118
 119 static inline void target_sigemptyset(target_sigset_t *set)
 120 {
 121     memset(set, 0, sizeof(*set));
 122 }
 123
 124 static inline void target_sigaddset(target_sigset_t *set, int signum)
 125 {
 126     signum--;
 127     abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
 128     set->sig[signum / TARGET_NSIG_BPW] |= mask;
 129 }
 130
 131 static inline int target_sigismember(const target_sigset_t *set, int signum)
 132 {
 133     signum--;
 134     abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
 135     return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0);
 136 }
 137
 138 static void host_to_target_sigset_internal(target_sigset_t *d,
 139                                            const sigset_t *s)
 140 {
 141     int i;
 142     target_sigemptyset(d);
 143     for (i = 1; i <= TARGET_NSIG; i++) {
 144         if (sigismember(s, i)) {
 145             target_sigaddset(d, host_to_target_signal(i));
 146         }
 147     }
 148 }
 149
 150 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
 151 {
 152     target_sigset_t d1;
 153     int i;
 154
 155     host_to_target_sigset_internal(&d1, s);
 156     for(i = 0;i < TARGET_NSIG_WORDS; i++)
 157         d->sig[i] = tswapl(d1.sig[i]);
 158 }
 159
 160 static void target_to_host_sigset_internal(sigset_t *d,
 161                                            const target_sigset_t *s)
 162 {
 163     int i;
 164     sigemptyset(d);
 165     for (i = 1; i <= TARGET_NSIG; i++) {
 166         if (target_sigismember(s, i)) {
 167             sigaddset(d, target_to_host_signal(i));
 168         }
 169      }
 170 }
 171
 172 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
 173 {
 174     target_sigset_t s1;
 175     int i;
 176
 177     for(i = 0;i < TARGET_NSIG_WORDS; i++)
 178         s1.sig[i] = tswapl(s->sig[i]);
 179     target_to_host_sigset_internal(d, &s1);
 180 }
 181
 182 void host_to_target_old_sigset(abi_ulong *old_sigset,
 183                                const sigset_t *sigset)
 184 {
 185     target_sigset_t d;
 186     host_to_target_sigset(&d, sigset);
 187     *old_sigset = d.sig[0];
 188 }
 189
 190 void target_to_host_old_sigset(sigset_t *sigset,
 191                                const abi_ulong *old_sigset)
 192 {
 193     target_sigset_t d;
 194     int i;
 195
 196     d.sig[0] = *old_sigset;
 197     for(i = 1;i < TARGET_NSIG_WORDS; i++)
 198         d.sig[i] = 0;
 199     target_to_host_sigset(sigset, &d);
 200 }
 201
 202 /* siginfo conversion */
 203
 204 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
 205                                                  const siginfo_t *info)
 206 {
 207     int sig;
 208     sig = host_to_target_signal(info->si_signo);
 209     tinfo->si_signo = sig;
 210     tinfo->si_errno = 0;
 211     tinfo->si_code = info->si_code;
 212     if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
 213         sig == SIGBUS || sig == SIGTRAP) {
 214         /* should never come here, but who knows. The information for
 215            the target is irrelevant */
 216         tinfo->_sifields._sigfault._addr = 0;
 217     } else if (sig == SIGIO) {
 218         tinfo->_sifields._sigpoll._fd = info->si_fd;
 219     } else if (sig >= TARGET_SIGRTMIN) {
 220         tinfo->_sifields._rt._pid = info->si_pid;
 221         tinfo->_sifields._rt._uid = info->si_uid;
 222         /* XXX: potential problem if 64 bit */
 223         tinfo->_sifields._rt._sigval.sival_ptr =
 224             (abi_ulong)(unsigned long)info->si_value.sival_ptr;
 225     }
 226 }
 227
 228 static void tswap_siginfo(target_siginfo_t *tinfo,
 229                           const target_siginfo_t *info)
 230 {
 231     int sig;
 232     sig = info->si_signo;
 233     tinfo->si_signo = tswap32(sig);
 234     tinfo->si_errno = tswap32(info->si_errno);
 235     tinfo->si_code = tswap32(info->si_code);
 236     if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
 237         sig == SIGBUS || sig == SIGTRAP) {
 238         tinfo->_sifields._sigfault._addr =
 239             tswapl(info->_sifields._sigfault._addr);
 240     } else if (sig == SIGIO) {
 241         tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd);
 242     } else if (sig >= TARGET_SIGRTMIN) {
 243         tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
 244         tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
 245         tinfo->_sifields._rt._sigval.sival_ptr =
 246             tswapl(info->_sifields._rt._sigval.sival_ptr);
 247     }
 248 }
 249
 250
 251 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
 252 {
 253     host_to_target_siginfo_noswap(tinfo, info);
 254     tswap_siginfo(tinfo, tinfo);
 255 }
 256
 257 /* XXX: we support only POSIX RT signals are used. */
 258 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
 259 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
 260 {
 261     info->si_signo = tswap32(tinfo->si_signo);
 262     info->si_errno = tswap32(tinfo->si_errno);
 263     info->si_code = tswap32(tinfo->si_code);
 264     info->si_pid = tswap32(tinfo->_sifields._rt._pid);
 265     info->si_uid = tswap32(tinfo->_sifields._rt._uid);
 266     info->si_value.sival_ptr =
 267             (void *)(long)tswapl(tinfo->_sifields._rt._sigval.sival_ptr);
 268 }
 269
 270 static int fatal_signal (int sig)
 271 {
 272     switch (sig) {
 273     case TARGET_SIGCHLD:
 274     case TARGET_SIGURG:
 275     case TARGET_SIGWINCH:
 276         /* Ignored by default.  */
 277         return 0;
 278     case TARGET_SIGCONT:
 279     case TARGET_SIGSTOP:
 280     case TARGET_SIGTSTP:
 281     case TARGET_SIGTTIN:
 282     case TARGET_SIGTTOU:
 283         /* Job control signals.  */
 284         return 0;
 285     default:
 286         return 1;
 287     }
 288 }
 289
 290 void signal_init(void)
 291 {
 292     struct sigaction act;
 293     struct sigaction oact;
 294     int i, j;
 295     int host_sig;
 296
 297     /* generate signal conversion tables */
 298     for(i = 1; i <= 64; i++) {
 299         if (host_to_target_signal_table[i] == 0)
 300             host_to_target_signal_table[i] = i;
 301     }
 302     for(i = 1; i <= 64; i++) {
 303         j = host_to_target_signal_table[i];
 304         target_to_host_signal_table[j] = i;
 305     }
 306
 307     /* set all host signal handlers. ALL signals are blocked during
 308        the handlers to serialize them. */
 309     memset(sigact_table, 0, sizeof(sigact_table));
 310
 311     sigfillset(&act.sa_mask);
 312     act.sa_flags = SA_SIGINFO;
 313     act.sa_sigaction = host_signal_handler;
 314     for(i = 1; i <= TARGET_NSIG; i++) {
 315         host_sig = target_to_host_signal(i);
 316         sigaction(host_sig, NULL, &oact);
 317         if (oact.sa_sigaction == (void *)SIG_IGN) {
 318             sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;
 319         } else if (oact.sa_sigaction == (void *)SIG_DFL) {
 320             sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;
 321         }
 322         /* If there's already a handler installed then something has
 323            gone horribly wrong, so don't even try to handle that case.  */
 324         /* Install some handlers for our own use.  We need at least
 325            SIGSEGV and SIGBUS, to detect exceptions.  We can not just
 326            trap all signals because it affects syscall interrupt
 327            behavior.  But do trap all default-fatal signals.  */
 328         if (fatal_signal (i))
 329             sigaction(host_sig, &act, NULL);
 330     }
 331 }
 332
 333 /* signal queue handling */
 334
 335 static inline struct sigqueue *alloc_sigqueue(CPUState *env)
 336 {
 337     TaskState *ts = env->opaque;
 338     struct sigqueue *q = ts->first_free;
 339     if (!q)
 340         return NULL;
 341     ts->first_free = q->next;
 342     return q;
 343 }
 344
 345 static inline void free_sigqueue(CPUState *env, struct sigqueue *q)
 346 {
 347     TaskState *ts = env->opaque;
 348     q->next = ts->first_free;
 349     ts->first_free = q;
 350 }
 351
 352 /* abort execution with signal */
 353 static void QEMU_NORETURN force_sig(int sig)
 354 {
 355     int host_sig;
 356     struct sigaction act;
 357     host_sig = target_to_host_signal(sig);
 358     fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",
 359             sig, strsignal(host_sig));
 360     gdb_signalled(thread_env, sig);
 361
 362     /* The proper exit code for dieing from an uncaught signal is
 363      * -<signal>.  The kernel doesn't allow exit() or _exit() to pass
 364      * a negative value.  To get the proper exit code we need to
 365      * actually die from an uncaught signal.  Here the default signal
 366      * handler is installed, we send ourself a signal and we wait for
 367      * it to arrive. */
 368     sigfillset(&act.sa_mask);
 369     act.sa_handler = SIG_DFL;
 370     sigaction(host_sig, &act, NULL);
 371
 372     /* For some reason raise(host_sig) doesn't send the signal when
 373      * statically linked on x86-64. */
 374     kill(getpid(), host_sig);
 375
 376     /* Make sure the signal isn't masked (just reuse the mask inside
 377     of act) */
 378     sigdelset(&act.sa_mask, host_sig);
 379     sigsuspend(&act.sa_mask);
 380
 381     /* unreachable */
 382     assert(0);
 383
 384 }
 385
 386 /* queue a signal so that it will be send to the virtual CPU as soon
 387    as possible */
 388 int queue_signal(CPUState *env, int sig, target_siginfo_t *info)
 389 {
 390     TaskState *ts = env->opaque;
 391     struct emulated_sigtable *k;
 392     struct sigqueue *q, **pq;
 393     abi_ulong handler;
 394     int queue;
 395
 396 #if defined(DEBUG_SIGNAL)
 397     fprintf(stderr, "queue_signal: sig=%d\n",
 398             sig);
 399 #endif
 400     k = &ts->sigtab[sig - 1];
 401     queue = gdb_queuesig ();
 402     handler = sigact_table[sig - 1]._sa_handler;
 403     if (!queue && handler == TARGET_SIG_DFL) {
 404         if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
 405             kill(getpid(),SIGSTOP);
 406             return 0;
 407         } else
 408         /* default handler : ignore some signal. The other are fatal */
 409         if (sig != TARGET_SIGCHLD &&
 410             sig != TARGET_SIGURG &&
 411             sig != TARGET_SIGWINCH &&
 412             sig != TARGET_SIGCONT) {
 413             force_sig(sig);
 414         } else {
 415             return 0; /* indicate ignored */
 416         }
 417     } else if (!queue && handler == TARGET_SIG_IGN) {
 418         /* ignore signal */
 419         return 0;
 420     } else if (!queue && handler == TARGET_SIG_ERR) {
 421         force_sig(sig);
 422     } else {
 423         pq = &k->first;
 424         if (sig < TARGET_SIGRTMIN) {
 425             /* if non real time signal, we queue exactly one signal */
 426             if (!k->pending)
 427                 q = &k->info;
 428             else
 429                 return 0;
 430         } else {
 431             if (!k->pending) {
 432                 /* first signal */
 433                 q = &k->info;
 434             } else {
 435                 q = alloc_sigqueue(env);
 436                 if (!q)
 437                     return -EAGAIN;
 438                 while (*pq != NULL)
 439                     pq = &(*pq)->next;
 440             }
 441         }
 442         *pq = q;
 443         q->info = *info;
 444         q->next = NULL;
 445         k->pending = 1;
 446         /* signal that a new signal is pending */
 447         ts->signal_pending = 1;
 448         return 1; /* indicates that the signal was queued */
 449     }
 450 }
 451
 452 static void host_signal_handler(int host_signum, siginfo_t *info,
 453                                 void *puc)
 454 {
 455     int sig;
 456     target_siginfo_t tinfo;
 457
 458     /* the CPU emulator uses some host signals to detect exceptions,
 459        we forward to it some signals */
 460     if ((host_signum == SIGSEGV || host_signum == SIGBUS)
 461         && info->si_code > 0) {
 462         if (cpu_signal_handler(host_signum, info, puc))
 463             return;
 464     }
 465
 466     /* get target signal number */
 467     sig = host_to_target_signal(host_signum);
 468     if (sig < 1 || sig > TARGET_NSIG)
 469         return;
 470 #if defined(DEBUG_SIGNAL)
 471     fprintf(stderr, "qemu: got signal %d\n", sig);
 472 #endif
 473     host_to_target_siginfo_noswap(&tinfo, info);
 474     if (queue_signal(thread_env, sig, &tinfo) == 1) {
 475         /* interrupt the virtual CPU as soon as possible */
 476         cpu_exit(thread_env);
 477     }
 478 }
 479
 480 /* do_sigaltstack() returns target values and errnos. */
 481 /* compare linux/kernel/signal.c:do_sigaltstack() */
 482 abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp)
 483 {
 484     int ret;
 485     struct target_sigaltstack oss;
 486
 487     /* XXX: test errors */
 488     if(uoss_addr)
 489     {
 490         __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp);
 491         __put_user(target_sigaltstack_used.ss_size, &oss.ss_size);
 492         __put_user(sas_ss_flags(sp), &oss.ss_flags);
 493     }
 494
 495     if(uss_addr)
 496     {
 497         struct target_sigaltstack *uss;
 498         struct target_sigaltstack ss;
 499
 500         ret = -TARGET_EFAULT;
 501         if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)
 502             || __get_user(ss.ss_sp, &uss->ss_sp)
 503             || __get_user(ss.ss_size, &uss->ss_size)
 504             || __get_user(ss.ss_flags, &uss->ss_flags))
 505             goto out;
 506         unlock_user_struct(uss, uss_addr, 0);
 507
 508         ret = -TARGET_EPERM;
 509         if (on_sig_stack(sp))
 510             goto out;
 511
 512         ret = -TARGET_EINVAL;
 513         if (ss.ss_flags != TARGET_SS_DISABLE
 514             && ss.ss_flags != TARGET_SS_ONSTACK
 515             && ss.ss_flags != 0)
 516             goto out;
 517
 518         if (ss.ss_flags == TARGET_SS_DISABLE) {
 519             ss.ss_size = 0;
 520             ss.ss_sp = 0;
 521         } else {
 522             ret = -TARGET_ENOMEM;
 523             if (ss.ss_size < MINSIGSTKSZ)
 524                 goto out;
 525         }
 526
 527         target_sigaltstack_used.ss_sp = ss.ss_sp;
 528         target_sigaltstack_used.ss_size = ss.ss_size;
 529     }
 530
 531     if (uoss_addr) {
 532         ret = -TARGET_EFAULT;
 533         if (copy_to_user(uoss_addr, &oss, sizeof(oss)))
 534             goto out;
 535     }
 536
 537     ret = 0;
 538 out:
 539     return ret;
 540 }
 541
 542 /* do_sigaction() return host values and errnos */
 543 int do_sigaction(int sig, const struct target_sigaction *act,
 544                  struct target_sigaction *oact)
 545 {
 546     struct target_sigaction *k;
 547     struct sigaction act1;
 548     int host_sig;
 549     int ret = 0;
 550
 551     if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP)
 552         return -EINVAL;
 553     k = &sigact_table[sig - 1];
 554 #if defined(DEBUG_SIGNAL)
 555     fprintf(stderr, "sigaction sig=%d act=0x%08x, oact=0x%08x\n",
 556             sig, (int)act, (int)oact);
 557 #endif
 558     if (oact) {
 559         oact->_sa_handler = tswapl(k->_sa_handler);
 560         oact->sa_flags = tswapl(k->sa_flags);
 561 #if !defined(TARGET_MIPS)
 562         oact->sa_restorer = tswapl(k->sa_restorer);
 563 #endif
 564         oact->sa_mask = k->sa_mask;
 565     }
 566     if (act) {
 567         /* FIXME: This is not threadsafe.  */
 568         k->_sa_handler = tswapl(act->_sa_handler);
 569         k->sa_flags = tswapl(act->sa_flags);
 570 #if !defined(TARGET_MIPS)
 571         k->sa_restorer = tswapl(act->sa_restorer);
 572 #endif
 573         k->sa_mask = act->sa_mask;
 574
 575         /* we update the host linux signal state */
 576         host_sig = target_to_host_signal(sig);
 577         if (host_sig != SIGSEGV && host_sig != SIGBUS) {
 578             sigfillset(&act1.sa_mask);
 579             act1.sa_flags = SA_SIGINFO;
 580             if (k->sa_flags & TARGET_SA_RESTART)
 581                 act1.sa_flags |= SA_RESTART;
 582             /* NOTE: it is important to update the host kernel signal
 583                ignore state to avoid getting unexpected interrupted
 584                syscalls */
 585             if (k->_sa_handler == TARGET_SIG_IGN) {
 586                 act1.sa_sigaction = (void *)SIG_IGN;
 587             } else if (k->_sa_handler == TARGET_SIG_DFL) {
 588                 if (fatal_signal (sig))
 589                     act1.sa_sigaction = host_signal_handler;
 590                 else
 591                     act1.sa_sigaction = (void *)SIG_DFL;
 592             } else {
 593                 act1.sa_sigaction = host_signal_handler;
 594             }
 595             ret = sigaction(host_sig, &act1, NULL);
 596         }
 597     }
 598     return ret;
 599 }
 600
 601 static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,
 602                                        const target_siginfo_t *info)
 603 {
 604     tswap_siginfo(tinfo, info);
 605     return 0;
 606 }
 607
 608 static inline int current_exec_domain_sig(int sig)
 609 {
 610     return /* current->exec_domain && current->exec_domain->signal_invmap
 611               && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig;
 612 }
 613
 614 #if defined(TARGET_I386) && TARGET_ABI_BITS == 32
 615
 616 /* from the Linux kernel */
 617
 618 struct target_fpreg {
 619         uint16_t significand[4];
 620         uint16_t exponent;
 621 };
 622
 623 struct target_fpxreg {
 624         uint16_t significand[4];
 625         uint16_t exponent;
 626         uint16_t padding[3];
 627 };
 628
 629 struct target_xmmreg {
 630         abi_ulong element[4];
 631 };
 632
 633 struct target_fpstate {
 634         /* Regular FPU environment */
 635         abi_ulong       cw;
 636         abi_ulong       sw;
 637         abi_ulong       tag;
 638         abi_ulong       ipoff;
 639         abi_ulong       cssel;
 640         abi_ulong       dataoff;
 641         abi_ulong       datasel;
 642         struct target_fpreg     _st[8];
 643         uint16_t        status;
 644         uint16_t        magic;          /* 0xffff = regular FPU data only */
 645
 646         /* FXSR FPU environment */
 647         abi_ulong       _fxsr_env[6];   /* FXSR FPU env is ignored */
 648         abi_ulong       mxcsr;
 649         abi_ulong       reserved;
 650         struct target_fpxreg    _fxsr_st[8];    /* FXSR FPU reg data is ignored */
 651         struct target_xmmreg    _xmm[8];
 652         abi_ulong       padding[56];
 653 };
 654
 655 #define X86_FXSR_MAGIC          0x0000
 656
 657 struct target_sigcontext {
 658         uint16_t gs, __gsh;
 659         uint16_t fs, __fsh;
 660         uint16_t es, __esh;
 661         uint16_t ds, __dsh;
 662         abi_ulong edi;
 663         abi_ulong esi;
 664         abi_ulong ebp;
 665         abi_ulong esp;
 666         abi_ulong ebx;
 667         abi_ulong edx;
 668         abi_ulong ecx;
 669         abi_ulong eax;
 670         abi_ulong trapno;
 671         abi_ulong err;
 672         abi_ulong eip;
 673         uint16_t cs, __csh;
 674         abi_ulong eflags;
 675         abi_ulong esp_at_signal;
 676         uint16_t ss, __ssh;
 677         abi_ulong fpstate; /* pointer */
 678         abi_ulong oldmask;
 679         abi_ulong cr2;
 680 };
 681
 682 struct target_ucontext {
 683         abi_ulong         tuc_flags;
 684         abi_ulong         tuc_link;
 685         target_stack_t    tuc_stack;
 686         struct target_sigcontext tuc_mcontext;
 687         target_sigset_t   tuc_sigmask;  /* mask last for extensibility */
 688 };
 689
 690 struct sigframe
 691 {
 692     abi_ulong pretcode;
 693     int sig;
 694     struct target_sigcontext sc;
 695     struct target_fpstate fpstate;
 696     abi_ulong extramask[TARGET_NSIG_WORDS-1];
 697     char retcode[8];
 698 };
 699
 700 struct rt_sigframe
 701 {
 702     abi_ulong pretcode;
 703     int sig;
 704     abi_ulong pinfo;
 705     abi_ulong puc;
 706     struct target_siginfo info;
 707     struct target_ucontext uc;
 708     struct target_fpstate fpstate;
 709     char retcode[8];
 710 };
 711
 712 /*
 713  * Set up a signal frame.
 714  */
 715
 716 /* XXX: save x87 state */
 717 static int
 718 setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
 719                  CPUX86State *env, abi_ulong mask, abi_ulong fpstate_addr)
 720 {
 721         int err = 0;
 722         uint16_t magic;
 723
 724         /* already locked in setup_frame() */
 725         err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
 726         err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
 727         err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
 728         err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
 729         err |= __put_user(env->regs[R_EDI], &sc->edi);
 730         err |= __put_user(env->regs[R_ESI], &sc->esi);
 731         err |= __put_user(env->regs[R_EBP], &sc->ebp);
 732         err |= __put_user(env->regs[R_ESP], &sc->esp);
 733         err |= __put_user(env->regs[R_EBX], &sc->ebx);
 734         err |= __put_user(env->regs[R_EDX], &sc->edx);
 735         err |= __put_user(env->regs[R_ECX], &sc->ecx);
 736         err |= __put_user(env->regs[R_EAX], &sc->eax);
 737         err |= __put_user(env->exception_index, &sc->trapno);
 738         err |= __put_user(env->error_code, &sc->err);
 739         err |= __put_user(env->eip, &sc->eip);
 740         err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
 741         err |= __put_user(env->eflags, &sc->eflags);
 742         err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);
 743         err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
 744
 745         cpu_x86_fsave(env, fpstate_addr, 1);
 746         fpstate->status = fpstate->sw;
 747         magic = 0xffff;
 748         err |= __put_user(magic, &fpstate->magic);
 749         err |= __put_user(fpstate_addr, &sc->fpstate);
 750
 751         /* non-iBCS2 extensions.. */
 752         err |= __put_user(mask, &sc->oldmask);
 753         err |= __put_user(env->cr[2], &sc->cr2);
 754         return err;
 755 }
 756
 757 /*
 758  * Determine which stack to use..
 759  */
 760
 761 static inline abi_ulong
 762 get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size)
 763 {
 764         unsigned long esp;
 765
 766         /* Default to using normal stack */
 767         esp = env->regs[R_ESP];
 768         /* This is the X/Open sanctioned signal stack switching.  */
 769         if (ka->sa_flags & TARGET_SA_ONSTACK) {
 770             if (sas_ss_flags(esp) == 0)
 771                 esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
 772         }
 773
 774         /* This is the legacy signal stack switching. */
 775         else
 776         if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
 777             !(ka->sa_flags & TARGET_SA_RESTORER) &&
 778             ka->sa_restorer) {
 779             esp = (unsigned long) ka->sa_restorer;
 780         }
 781         return (esp - frame_size) & -8ul;
 782 }
 783
 784 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */
 785 static void setup_frame(int sig, struct target_sigaction *ka,
 786                         target_sigset_t *set, CPUX86State *env)
 787 {
 788         abi_ulong frame_addr;
 789         struct sigframe *frame;
 790         int i, err = 0;
 791
 792         frame_addr = get_sigframe(ka, env, sizeof(*frame));
 793
 794         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
 795                 goto give_sigsegv;
 796
 797         err |= __put_user(current_exec_domain_sig(sig),
 798                           &frame->sig);
 799         if (err)
 800                 goto give_sigsegv;
 801
 802         setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0],
 803                          frame_addr + offsetof(struct sigframe, fpstate));
 804         if (err)
 805                 goto give_sigsegv;
 806
 807         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
 808             if (__put_user(set->sig[i], &frame->extramask[i - 1]))
 809                 goto give_sigsegv;
 810         }
 811
 812         /* Set up to return from userspace.  If provided, use a stub
 813            already in userspace.  */
 814         if (ka->sa_flags & TARGET_SA_RESTORER) {
 815                 err |= __put_user(ka->sa_restorer, &frame->pretcode);
 816         } else {
 817                 uint16_t val16;
 818                 abi_ulong retcode_addr;
 819                 retcode_addr = frame_addr + offsetof(struct sigframe, retcode);
 820                 err |= __put_user(retcode_addr, &frame->pretcode);
 821                 /* This is popl %eax ; movl $,%eax ; int $0x80 */
 822                 val16 = 0xb858;
 823                 err |= __put_user(val16, (uint16_t *)(frame->retcode+0));
 824                 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
 825                 val16 = 0x80cd;
 826                 err |= __put_user(val16, (uint16_t *)(frame->retcode+6));
 827         }
 828
 829         if (err)
 830                 goto give_sigsegv;
 831
 832         /* Set up registers for signal handler */
 833         env->regs[R_ESP] = frame_addr;
 834         env->eip = ka->_sa_handler;
 835
 836         cpu_x86_load_seg(env, R_DS, __USER_DS);
 837         cpu_x86_load_seg(env, R_ES, __USER_DS);
 838         cpu_x86_load_seg(env, R_SS, __USER_DS);
 839         cpu_x86_load_seg(env, R_CS, __USER_CS);
 840         env->eflags &= ~TF_MASK;
 841
 842         unlock_user_struct(frame, frame_addr, 1);
 843
 844         return;
 845
 846 give_sigsegv:
 847         unlock_user_struct(frame, frame_addr, 1);
 848         if (sig == TARGET_SIGSEGV)
 849                 ka->_sa_handler = TARGET_SIG_DFL;
 850         force_sig(TARGET_SIGSEGV /* , current */);
 851 }
 852
 853 /* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */
 854 static void setup_rt_frame(int sig, struct target_sigaction *ka,
 855                            target_siginfo_t *info,
 856                            target_sigset_t *set, CPUX86State *env)
 857 {
 858         abi_ulong frame_addr, addr;
 859         struct rt_sigframe *frame;
 860         int i, err = 0;
 861
 862         frame_addr = get_sigframe(ka, env, sizeof(*frame));
 863
 864         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
 865                 goto give_sigsegv;
 866
 867         err |= __put_user(current_exec_domain_sig(sig),
 868                           &frame->sig);
 869         addr = frame_addr + offsetof(struct rt_sigframe, info);
 870         err |= __put_user(addr, &frame->pinfo);
 871         addr = frame_addr + offsetof(struct rt_sigframe, uc);
 872         err |= __put_user(addr, &frame->puc);
 873         err |= copy_siginfo_to_user(&frame->info, info);
 874         if (err)
 875                 goto give_sigsegv;
 876
 877         /* Create the ucontext.  */
 878         err |= __put_user(0, &frame->uc.tuc_flags);
 879         err |= __put_user(0, &frame->uc.tuc_link);
 880         err |= __put_user(target_sigaltstack_used.ss_sp,
 881                           &frame->uc.tuc_stack.ss_sp);
 882         err |= __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
 883                           &frame->uc.tuc_stack.ss_flags);
 884         err |= __put_user(target_sigaltstack_used.ss_size,
 885                           &frame->uc.tuc_stack.ss_size);
 886         err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate,
 887                                 env, set->sig[0],
 888                                 frame_addr + offsetof(struct rt_sigframe, fpstate));
 889         for(i = 0; i < TARGET_NSIG_WORDS; i++) {
 890             if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
 891                 goto give_sigsegv;
 892         }
 893
 894         /* Set up to return from userspace.  If provided, use a stub
 895            already in userspace.  */
 896         if (ka->sa_flags & TARGET_SA_RESTORER) {
 897                 err |= __put_user(ka->sa_restorer, &frame->pretcode);
 898         } else {
 899                 uint16_t val16;
 900                 addr = frame_addr + offsetof(struct rt_sigframe, retcode);
 901                 err |= __put_user(addr, &frame->pretcode);
 902                 /* This is movl $,%eax ; int $0x80 */
 903                 err |= __put_user(0xb8, (char *)(frame->retcode+0));
 904                 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
 905                 val16 = 0x80cd;
 906                 err |= __put_user(val16, (uint16_t *)(frame->retcode+5));
 907         }
 908
 909         if (err)
 910                 goto give_sigsegv;
 911
 912         /* Set up registers for signal handler */
 913         env->regs[R_ESP] = frame_addr;
 914         env->eip = ka->_sa_handler;
 915
 916         cpu_x86_load_seg(env, R_DS, __USER_DS);
 917         cpu_x86_load_seg(env, R_ES, __USER_DS);
 918         cpu_x86_load_seg(env, R_SS, __USER_DS);
 919         cpu_x86_load_seg(env, R_CS, __USER_CS);
 920         env->eflags &= ~TF_MASK;
 921
 922         unlock_user_struct(frame, frame_addr, 1);
 923
 924         return;
 925
 926 give_sigsegv:
 927         unlock_user_struct(frame, frame_addr, 1);
 928         if (sig == TARGET_SIGSEGV)
 929                 ka->_sa_handler = TARGET_SIG_DFL;
 930         force_sig(TARGET_SIGSEGV /* , current */);
 931 }
 932
 933 static int
 934 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
 935 {
 936         unsigned int err = 0;
 937         abi_ulong fpstate_addr;
 938         unsigned int tmpflags;
 939
 940         cpu_x86_load_seg(env, R_GS, tswap16(sc->gs));
 941         cpu_x86_load_seg(env, R_FS, tswap16(sc->fs));
 942         cpu_x86_load_seg(env, R_ES, tswap16(sc->es));
 943         cpu_x86_load_seg(env, R_DS, tswap16(sc->ds));
 944
 945         env->regs[R_EDI] = tswapl(sc->edi);
 946         env->regs[R_ESI] = tswapl(sc->esi);
 947         env->regs[R_EBP] = tswapl(sc->ebp);
 948         env->regs[R_ESP] = tswapl(sc->esp);
 949         env->regs[R_EBX] = tswapl(sc->ebx);
 950         env->regs[R_EDX] = tswapl(sc->edx);
 951         env->regs[R_ECX] = tswapl(sc->ecx);
 952         env->eip = tswapl(sc->eip);
 953
 954         cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3);
 955         cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3);
 956
 957         tmpflags = tswapl(sc->eflags);
 958         env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
 959         //              regs->orig_eax = -1;            /* disable syscall checks */
 960
 961         fpstate_addr = tswapl(sc->fpstate);
 962         if (fpstate_addr != 0) {
 963                 if (!access_ok(VERIFY_READ, fpstate_addr,
 964                                sizeof(struct target_fpstate)))
 965                         goto badframe;
 966                 cpu_x86_frstor(env, fpstate_addr, 1);
 967         }
 968
 969         *peax = tswapl(sc->eax);
 970         return err;
 971 badframe:
 972         return 1;
 973 }
 974
 975 long do_sigreturn(CPUX86State *env)
 976 {
 977     struct sigframe *frame;
 978     abi_ulong frame_addr = env->regs[R_ESP] - 8;
 979     target_sigset_t target_set;
 980     sigset_t set;
 981     int eax, i;
 982
 983 #if defined(DEBUG_SIGNAL)
 984     fprintf(stderr, "do_sigreturn\n");
 985 #endif
 986     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
 987         goto badframe;
 988     /* set blocked signals */
 989     if (__get_user(target_set.sig[0], &frame->sc.oldmask))
 990         goto badframe;
 991     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
 992         if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
 993             goto badframe;
 994     }
 995
 996     target_to_host_sigset_internal(&set, &target_set);
 997     sigprocmask(SIG_SETMASK, &set, NULL);
 998
 999     /* restore registers */
1000     if (restore_sigcontext(env, &frame->sc, &eax))
1001         goto badframe;
1002     unlock_user_struct(frame, frame_addr, 0);
1003     return eax;
1004
1005 badframe:
1006     unlock_user_struct(frame, frame_addr, 0);
1007     force_sig(TARGET_SIGSEGV);
1008     return 0;
1009 }
1010
1011 long do_rt_sigreturn(CPUX86State *env)
1012 {
1013         abi_ulong frame_addr;
1014         struct rt_sigframe *frame;
1015         sigset_t set;
1016         int eax;
1017
1018         frame_addr = env->regs[R_ESP] - 4;
1019         if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1020                 goto badframe;
1021         target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
1022         sigprocmask(SIG_SETMASK, &set, NULL);
1023
1024         if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))
1025                 goto badframe;
1026
1027         if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0,
1028                            get_sp_from_cpustate(env)) == -EFAULT)
1029                 goto badframe;
1030
1031         unlock_user_struct(frame, frame_addr, 0);
1032         return eax;
1033
1034 badframe:
1035         unlock_user_struct(frame, frame_addr, 0);
1036         force_sig(TARGET_SIGSEGV);
1037         return 0;
1038 }
1039
1040 #elif defined(TARGET_ARM)
1041
1042 struct target_sigcontext {
1043         abi_ulong trap_no;
1044         abi_ulong error_code;
1045         abi_ulong oldmask;
1046         abi_ulong arm_r0;
1047         abi_ulong arm_r1;
1048         abi_ulong arm_r2;
1049         abi_ulong arm_r3;
1050         abi_ulong arm_r4;
1051         abi_ulong arm_r5;
1052         abi_ulong arm_r6;
1053         abi_ulong arm_r7;
1054         abi_ulong arm_r8;
1055         abi_ulong arm_r9;
1056         abi_ulong arm_r10;
1057         abi_ulong arm_fp;
1058         abi_ulong arm_ip;
1059         abi_ulong arm_sp;
1060         abi_ulong arm_lr;
1061         abi_ulong arm_pc;
1062         abi_ulong arm_cpsr;
1063         abi_ulong fault_address;
1064 };
1065
1066 struct target_ucontext_v1 {
1067     abi_ulong tuc_flags;
1068     abi_ulong tuc_link;
1069     target_stack_t tuc_stack;
1070     struct target_sigcontext tuc_mcontext;
1071     target_sigset_t  tuc_sigmask;       /* mask last for extensibility */
1072 };
1073
1074 struct target_ucontext_v2 {
1075     abi_ulong tuc_flags;
1076     abi_ulong tuc_link;
1077     target_stack_t tuc_stack;
1078     struct target_sigcontext tuc_mcontext;
1079     target_sigset_t  tuc_sigmask;       /* mask last for extensibility */
1080     char __unused[128 - sizeof(sigset_t)];
1081     abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
1082 };
1083
1084 struct sigframe_v1
1085 {
1086     struct target_sigcontext sc;
1087     abi_ulong extramask[TARGET_NSIG_WORDS-1];
1088     abi_ulong retcode;
1089 };
1090
1091 struct sigframe_v2
1092 {
1093     struct target_ucontext_v2 uc;
1094     abi_ulong retcode;
1095 };
1096
1097 struct rt_sigframe_v1
1098 {
1099     abi_ulong pinfo;
1100     abi_ulong puc;
1101     struct target_siginfo info;
1102     struct target_ucontext_v1 uc;
1103     abi_ulong retcode;
1104 };
1105
1106 struct rt_sigframe_v2
1107 {
1108     struct target_siginfo info;
1109     struct target_ucontext_v2 uc;
1110     abi_ulong retcode;
1111 };
1112
1113 #define TARGET_CONFIG_CPU_32 1
1114
1115 /*
1116  * For ARM syscalls, we encode the syscall number into the instruction.
1117  */
1118 #define SWI_SYS_SIGRETURN       (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1119 #define SWI_SYS_RT_SIGRETURN    (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1120
1121 /*
1122  * For Thumb syscalls, we pass the syscall number via r7.  We therefore
1123  * need two 16-bit instructions.
1124  */
1125 #define SWI_THUMB_SIGRETURN     (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1126 #define SWI_THUMB_RT_SIGRETURN  (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1127
1128 static const abi_ulong retcodes[4] = {
1129         SWI_SYS_SIGRETURN,      SWI_THUMB_SIGRETURN,
1130         SWI_SYS_RT_SIGRETURN,   SWI_THUMB_RT_SIGRETURN
1131 };
1132
1133
1134 #define __get_user_error(x,p,e) __get_user(x, p)
1135
1136 static inline int valid_user_regs(CPUState *regs)
1137 {
1138     return 1;
1139 }
1140
1141 static void
1142 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1143                  CPUState *env, abi_ulong mask)
1144 {
1145         __put_user(env->regs[0], &sc->arm_r0);
1146         __put_user(env->regs[1], &sc->arm_r1);
1147         __put_user(env->regs[2], &sc->arm_r2);
1148         __put_user(env->regs[3], &sc->arm_r3);
1149         __put_user(env->regs[4], &sc->arm_r4);
1150         __put_user(env->regs[5], &sc->arm_r5);
1151         __put_user(env->regs[6], &sc->arm_r6);
1152         __put_user(env->regs[7], &sc->arm_r7);
1153         __put_user(env->regs[8], &sc->arm_r8);
1154         __put_user(env->regs[9], &sc->arm_r9);
1155         __put_user(env->regs[10], &sc->arm_r10);
1156         __put_user(env->regs[11], &sc->arm_fp);
1157         __put_user(env->regs[12], &sc->arm_ip);
1158         __put_user(env->regs[13], &sc->arm_sp);
1159         __put_user(env->regs[14], &sc->arm_lr);
1160         __put_user(env->regs[15], &sc->arm_pc);
1161 #ifdef TARGET_CONFIG_CPU_32
1162         __put_user(cpsr_read(env), &sc->arm_cpsr);
1163 #endif
1164
1165         __put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
1166         __put_user(/* current->thread.error_code */ 0, &sc->error_code);
1167         __put_user(/* current->thread.address */ 0, &sc->fault_address);
1168         __put_user(mask, &sc->oldmask);
1169 }
1170
1171 static inline abi_ulong
1172 get_sigframe(struct target_sigaction *ka, CPUState *regs, int framesize)
1173 {
1174         unsigned long sp = regs->regs[13];
1175
1176         /*
1177          * This is the X/Open sanctioned signal stack switching.
1178          */
1179         if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp))
1180             sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1181         /*
1182          * ATPCS B01 mandates 8-byte alignment
1183          */
1184         return (sp - framesize) & ~7;
1185 }
1186
1187 static int
1188 setup_return(CPUState *env, struct target_sigaction *ka,
1189              abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr)
1190 {
1191         abi_ulong handler = ka->_sa_handler;
1192         abi_ulong retcode;
1193         int thumb = handler & 1;
1194
1195         if (ka->sa_flags & TARGET_SA_RESTORER) {
1196                 retcode = ka->sa_restorer;
1197         } else {
1198                 unsigned int idx = thumb;
1199
1200                 if (ka->sa_flags & TARGET_SA_SIGINFO)
1201                         idx += 2;
1202
1203                 if (__put_user(retcodes[idx], rc))
1204                         return 1;
1205 #if 0
1206                 flush_icache_range((abi_ulong)rc,
1207                                    (abi_ulong)(rc + 1));
1208 #endif
1209                 retcode = rc_addr + thumb;
1210         }
1211
1212         env->regs[0] = usig;
1213         env->regs[13] = frame_addr;
1214         env->regs[14] = retcode;
1215         env->regs[15] = handler & (thumb ? ~1 : ~3);
1216         env->thumb = thumb;
1217
1218 #if 0
1219 #ifdef TARGET_CONFIG_CPU_32
1220         env->cpsr = cpsr;
1221 #endif
1222 #endif
1223
1224         return 0;
1225 }
1226
1227 static void setup_sigframe_v2(struct target_ucontext_v2 *uc,
1228                               target_sigset_t *set, CPUState *env)
1229 {
1230     struct target_sigaltstack stack;
1231     int i;
1232
1233     /* Clear all the bits of the ucontext we don't use.  */
1234     memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext));
1235
1236     memset(&stack, 0, sizeof(stack));
1237     __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1238     __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1239     __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1240     memcpy(&uc->tuc_stack, &stack, sizeof(stack));
1241
1242     setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
1243     /* FIXME: Save coprocessor signal frame.  */
1244     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1245         __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
1246     }
1247 }
1248
1249 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */
1250 static void setup_frame_v1(int usig, struct target_sigaction *ka,
1251                            target_sigset_t *set, CPUState *regs)
1252 {
1253         struct sigframe_v1 *frame;
1254         abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1255         int i;
1256
1257         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1258                 return;
1259
1260         setup_sigcontext(&frame->sc, regs, set->sig[0]);
1261
1262         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1263             if (__put_user(set->sig[i], &frame->extramask[i - 1]))
1264                 goto end;
1265         }
1266
1267         setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1268                      frame_addr + offsetof(struct sigframe_v1, retcode));
1269
1270 end:
1271         unlock_user_struct(frame, frame_addr, 1);
1272 }
1273
1274 static void setup_frame_v2(int usig, struct target_sigaction *ka,
1275                            target_sigset_t *set, CPUState *regs)
1276 {
1277         struct sigframe_v2 *frame;
1278         abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1279
1280         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1281                 return;
1282
1283         setup_sigframe_v2(&frame->uc, set, regs);
1284
1285         setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1286                      frame_addr + offsetof(struct sigframe_v2, retcode));
1287
1288         unlock_user_struct(frame, frame_addr, 1);
1289 }
1290
1291 static void setup_frame(int usig, struct target_sigaction *ka,
1292                         target_sigset_t *set, CPUState *regs)
1293 {
1294     if (get_osversion() >= 0x020612) {
1295         setup_frame_v2(usig, ka, set, regs);
1296     } else {
1297         setup_frame_v1(usig, ka, set, regs);
1298     }
1299 }
1300
1301 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
1302 static void setup_rt_frame_v1(int usig, struct target_sigaction *ka,
1303                               target_siginfo_t *info,
1304                               target_sigset_t *set, CPUState *env)
1305 {
1306         struct rt_sigframe_v1 *frame;
1307         abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
1308         struct target_sigaltstack stack;
1309         int i;
1310         abi_ulong info_addr, uc_addr;
1311
1312         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1313             return /* 1 */;
1314
1315         info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info);
1316         __put_user(info_addr, &frame->pinfo);
1317         uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);
1318         __put_user(uc_addr, &frame->puc);
1319         copy_siginfo_to_user(&frame->info, info);
1320
1321         /* Clear all the bits of the ucontext we don't use.  */
1322         memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));
1323
1324         memset(&stack, 0, sizeof(stack));
1325         __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1326         __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1327         __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1328         memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
1329
1330         setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]);
1331         for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1332             if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
1333                 goto end;
1334         }
1335
1336         setup_return(env, ka, &frame->retcode, frame_addr, usig,
1337                      frame_addr + offsetof(struct rt_sigframe_v1, retcode));
1338
1339         env->regs[1] = info_addr;
1340         env->regs[2] = uc_addr;
1341
1342 end:
1343         unlock_user_struct(frame, frame_addr, 1);
1344 }
1345
1346 static void setup_rt_frame_v2(int usig, struct target_sigaction *ka,
1347                               target_siginfo_t *info,
1348                               target_sigset_t *set, CPUState *env)
1349 {
1350         struct rt_sigframe_v2 *frame;
1351         abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
1352         abi_ulong info_addr, uc_addr;
1353
1354         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1355             return /* 1 */;
1356
1357         info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info);
1358         uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc);
1359         copy_siginfo_to_user(&frame->info, info);
1360
1361         setup_sigframe_v2(&frame->uc, set, env);
1362
1363         setup_return(env, ka, &frame->retcode, frame_addr, usig,
1364                      frame_addr + offsetof(struct rt_sigframe_v2, retcode));
1365
1366         env->regs[1] = info_addr;
1367         env->regs[2] = uc_addr;
1368
1369         unlock_user_struct(frame, frame_addr, 1);
1370 }
1371
1372 static void setup_rt_frame(int usig, struct target_sigaction *ka,
1373                            target_siginfo_t *info,
1374                            target_sigset_t *set, CPUState *env)
1375 {
1376     if (get_osversion() >= 0x020612) {
1377         setup_rt_frame_v2(usig, ka, info, set, env);
1378     } else {
1379         setup_rt_frame_v1(usig, ka, info, set, env);
1380     }
1381 }
1382
1383 static int
1384 restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
1385 {
1386         int err = 0;
1387         uint32_t cpsr;
1388
1389         __get_user_error(env->regs[0], &sc->arm_r0, err);
1390         __get_user_error(env->regs[1], &sc->arm_r1, err);
1391         __get_user_error(env->regs[2], &sc->arm_r2, err);
1392         __get_user_error(env->regs[3], &sc->arm_r3, err);
1393         __get_user_error(env->regs[4], &sc->arm_r4, err);
1394         __get_user_error(env->regs[5], &sc->arm_r5, err);
1395         __get_user_error(env->regs[6], &sc->arm_r6, err);
1396         __get_user_error(env->regs[7], &sc->arm_r7, err);
1397         __get_user_error(env->regs[8], &sc->arm_r8, err);
1398         __get_user_error(env->regs[9], &sc->arm_r9, err);
1399         __get_user_error(env->regs[10], &sc->arm_r10, err);
1400         __get_user_error(env->regs[11], &sc->arm_fp, err);
1401         __get_user_error(env->regs[12], &sc->arm_ip, err);
1402         __get_user_error(env->regs[13], &sc->arm_sp, err);
1403         __get_user_error(env->regs[14], &sc->arm_lr, err);
1404         __get_user_error(env->regs[15], &sc->arm_pc, err);
1405 #ifdef TARGET_CONFIG_CPU_32
1406         __get_user_error(cpsr, &sc->arm_cpsr, err);
1407         cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC);
1408 #endif
1409
1410         err |= !valid_user_regs(env);
1411
1412         return err;
1413 }
1414
1415 static long do_sigreturn_v1(CPUState *env)
1416 {
1417         abi_ulong frame_addr;
1418         struct sigframe_v1 *frame;
1419         target_sigset_t set;
1420         sigset_t host_set;
1421         int i;
1422
1423         /*
1424          * Since we stacked the signal on a 64-bit boundary,
1425          * then 'sp' should be word aligned here.  If it's
1426          * not, then the user is trying to mess with us.
1427          */
1428         if (env->regs[13] & 7)
1429                 goto badframe;
1430
1431         frame_addr = env->regs[13];
1432         if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1433                 goto badframe;
1434
1435         if (__get_user(set.sig[0], &frame->sc.oldmask))
1436             goto badframe;
1437         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1438             if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1439                 goto badframe;
1440         }
1441
1442         target_to_host_sigset_internal(&host_set, &set);
1443         sigprocmask(SIG_SETMASK, &host_set, NULL);
1444
1445         if (restore_sigcontext(env, &frame->sc))
1446                 goto badframe;
1447
1448 #if 0
1449         /* Send SIGTRAP if we're single-stepping */
1450         if (ptrace_cancel_bpt(current))
1451                 send_sig(SIGTRAP, current, 1);
1452 #endif
1453         unlock_user_struct(frame, frame_addr, 0);
1454         return env->regs[0];
1455
1456 badframe:
1457         unlock_user_struct(frame, frame_addr, 0);
1458         force_sig(SIGSEGV /* , current */);
1459         return 0;
1460 }
1461
1462 static int do_sigframe_return_v2(CPUState *env, target_ulong frame_addr,
1463                                  struct target_ucontext_v2 *uc)
1464 {
1465     sigset_t host_set;
1466
1467     target_to_host_sigset(&host_set, &uc->tuc_sigmask);
1468     sigprocmask(SIG_SETMASK, &host_set, NULL);
1469
1470     if (restore_sigcontext(env, &uc->tuc_mcontext))
1471         return 1;
1472
1473     if (do_sigaltstack(frame_addr + offsetof(struct target_ucontext_v2, tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1474         return 1;
1475
1476 #if 0
1477     /* Send SIGTRAP if we're single-stepping */
1478     if (ptrace_cancel_bpt(current))
1479             send_sig(SIGTRAP, current, 1);
1480 #endif
1481
1482     return 0;
1483 }
1484
1485 static long do_sigreturn_v2(CPUState *env)
1486 {
1487         abi_ulong frame_addr;
1488         struct sigframe_v2 *frame;
1489
1490         /*
1491          * Since we stacked the signal on a 64-bit boundary,
1492          * then 'sp' should be word aligned here.  If it's
1493          * not, then the user is trying to mess with us.
1494          */
1495         if (env->regs[13] & 7)
1496                 goto badframe;
1497
1498         frame_addr = env->regs[13];
1499         if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1500                 goto badframe;
1501
1502         if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
1503                 goto badframe;
1504
1505         unlock_user_struct(frame, frame_addr, 0);
1506         return env->regs[0];
1507
1508 badframe:
1509         unlock_user_struct(frame, frame_addr, 0);
1510         force_sig(SIGSEGV /* , current */);
1511         return 0;
1512 }
1513
1514 long do_sigreturn(CPUState *env)
1515 {
1516     if (get_osversion() >= 0x020612) {
1517         return do_sigreturn_v2(env);
1518     } else {
1519         return do_sigreturn_v1(env);
1520     }
1521 }
1522
1523 static long do_rt_sigreturn_v1(CPUState *env)
1524 {
1525         abi_ulong frame_addr;
1526         struct rt_sigframe_v1 *frame;
1527         sigset_t host_set;
1528
1529         /*
1530          * Since we stacked the signal on a 64-bit boundary,
1531          * then 'sp' should be word aligned here.  If it's
1532          * not, then the user is trying to mess with us.
1533          */
1534         if (env->regs[13] & 7)
1535                 goto badframe;
1536
1537         frame_addr = env->regs[13];
1538         if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1539                 goto badframe;
1540
1541         target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
1542         sigprocmask(SIG_SETMASK, &host_set, NULL);
1543
1544         if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
1545                 goto badframe;
1546
1547         if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1548                 goto badframe;
1549
1550 #if 0
1551         /* Send SIGTRAP if we're single-stepping */
1552         if (ptrace_cancel_bpt(current))
1553                 send_sig(SIGTRAP, current, 1);
1554 #endif
1555         unlock_user_struct(frame, frame_addr, 0);
1556         return env->regs[0];
1557
1558 badframe:
1559         unlock_user_struct(frame, frame_addr, 0);
1560         force_sig(SIGSEGV /* , current */);
1561         return 0;
1562 }
1563
1564 static long do_rt_sigreturn_v2(CPUState *env)
1565 {
1566         abi_ulong frame_addr;
1567         struct rt_sigframe_v2 *frame;
1568
1569         /*
1570          * Since we stacked the signal on a 64-bit boundary,
1571          * then 'sp' should be word aligned here.  If it's
1572          * not, then the user is trying to mess with us.
1573          */
1574         if (env->regs[13] & 7)
1575                 goto badframe;
1576
1577         frame_addr = env->regs[13];
1578         if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1579                 goto badframe;
1580
1581         if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
1582                 goto badframe;
1583
1584         unlock_user_struct(frame, frame_addr, 0);
1585         return env->regs[0];
1586
1587 badframe:
1588         unlock_user_struct(frame, frame_addr, 0);
1589         force_sig(SIGSEGV /* , current */);
1590         return 0;
1591 }
1592
1593 long do_rt_sigreturn(CPUState *env)
1594 {
1595     if (get_osversion() >= 0x020612) {
1596         return do_rt_sigreturn_v2(env);
1597     } else {
1598         return do_rt_sigreturn_v1(env);
1599     }
1600 }
1601
1602 #elif defined(TARGET_SPARC)
1603
1604 #define __SUNOS_MAXWIN   31
1605
1606 /* This is what SunOS does, so shall I. */
1607 struct target_sigcontext {
1608         abi_ulong sigc_onstack;      /* state to restore */
1609
1610         abi_ulong sigc_mask;         /* sigmask to restore */
1611         abi_ulong sigc_sp;           /* stack pointer */
1612         abi_ulong sigc_pc;           /* program counter */
1613         abi_ulong sigc_npc;          /* next program counter */
1614         abi_ulong sigc_psr;          /* for condition codes etc */
1615         abi_ulong sigc_g1;           /* User uses these two registers */
1616         abi_ulong sigc_o0;           /* within the trampoline code. */
1617
1618         /* Now comes information regarding the users window set
1619          * at the time of the signal.
1620          */
1621         abi_ulong sigc_oswins;       /* outstanding windows */
1622
1623         /* stack ptrs for each regwin buf */
1624         char *sigc_spbuf[__SUNOS_MAXWIN];
1625
1626         /* Windows to restore after signal */
1627         struct {
1628                 abi_ulong locals[8];
1629                 abi_ulong ins[8];
1630         } sigc_wbuf[__SUNOS_MAXWIN];
1631 };
1632 /* A Sparc stack frame */
1633 struct sparc_stackf {
1634         abi_ulong locals[8];
1635         abi_ulong ins[6];
1636         struct sparc_stackf *fp;
1637         abi_ulong callers_pc;
1638         char *structptr;
1639         abi_ulong xargs[6];
1640         abi_ulong xxargs[1];
1641 };
1642
1643 typedef struct {
1644         struct {
1645                 abi_ulong psr;
1646                 abi_ulong pc;
1647                 abi_ulong npc;
1648                 abi_ulong y;
1649                 abi_ulong u_regs[16]; /* globals and ins */
1650         }               si_regs;
1651         int             si_mask;
1652 } __siginfo_t;
1653
1654 typedef struct {
1655         unsigned   long si_float_regs [32];
1656         unsigned   long si_fsr;
1657         unsigned   long si_fpqdepth;
1658         struct {
1659                 unsigned long *insn_addr;
1660                 unsigned long insn;
1661         } si_fpqueue [16];
1662 } qemu_siginfo_fpu_t;
1663
1664
1665 struct target_signal_frame {
1666         struct sparc_stackf     ss;
1667         __siginfo_t             info;
1668         abi_ulong               fpu_save;
1669         abi_ulong               insns[2] __attribute__ ((aligned (8)));
1670         abi_ulong               extramask[TARGET_NSIG_WORDS - 1];
1671         abi_ulong               extra_size; /* Should be 0 */
1672         qemu_siginfo_fpu_t      fpu_state;
1673 };
1674 struct target_rt_signal_frame {
1675         struct sparc_stackf     ss;
1676         siginfo_t               info;
1677         abi_ulong               regs[20];
1678         sigset_t                mask;
1679         abi_ulong               fpu_save;
1680         unsigned int            insns[2];
1681         stack_t                 stack;
1682         unsigned int            extra_size; /* Should be 0 */
1683         qemu_siginfo_fpu_t      fpu_state;
1684 };
1685
1686 #define UREG_O0        16
1687 #define UREG_O6        22
1688 #define UREG_I0        0
1689 #define UREG_I1        1
1690 #define UREG_I2        2
1691 #define UREG_I3        3
1692 #define UREG_I4        4
1693 #define UREG_I5        5
1694 #define UREG_I6        6
1695 #define UREG_I7        7
1696 #define UREG_L0        8
1697 #define UREG_FP        UREG_I6
1698 #define UREG_SP        UREG_O6
1699
1700 static inline abi_ulong get_sigframe(struct target_sigaction *sa,
1701                                      CPUState *env, unsigned long framesize)
1702 {
1703         abi_ulong sp;
1704
1705         sp = env->regwptr[UREG_FP];
1706
1707         /* This is the X/Open sanctioned signal stack switching.  */
1708         if (sa->sa_flags & TARGET_SA_ONSTACK) {
1709             if (!on_sig_stack(sp)
1710                 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7))
1711                 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1712         }
1713         return sp - framesize;
1714 }
1715
1716 static int
1717 setup___siginfo(__siginfo_t *si, CPUState *env, abi_ulong mask)
1718 {
1719         int err = 0, i;
1720
1721         err |= __put_user(env->psr, &si->si_regs.psr);
1722         err |= __put_user(env->pc, &si->si_regs.pc);
1723         err |= __put_user(env->npc, &si->si_regs.npc);
1724         err |= __put_user(env->y, &si->si_regs.y);
1725         for (i=0; i < 8; i++) {
1726                 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
1727         }
1728         for (i=0; i < 8; i++) {
1729                 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
1730         }
1731         err |= __put_user(mask, &si->si_mask);
1732         return err;
1733 }
1734
1735 #if 0
1736 static int
1737 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1738                  CPUState *env, unsigned long mask)
1739 {
1740         int err = 0;
1741
1742         err |= __put_user(mask, &sc->sigc_mask);
1743         err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
1744         err |= __put_user(env->pc, &sc->sigc_pc);
1745         err |= __put_user(env->npc, &sc->sigc_npc);
1746         err |= __put_user(env->psr, &sc->sigc_psr);
1747         err |= __put_user(env->gregs[1], &sc->sigc_g1);
1748         err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
1749
1750         return err;
1751 }
1752 #endif
1753 #define NF_ALIGNEDSZ  (((sizeof(struct target_signal_frame) + 7) & (~7)))
1754
1755 static void setup_frame(int sig, struct target_sigaction *ka,
1756                         target_sigset_t *set, CPUState *env)
1757 {
1758         abi_ulong sf_addr;
1759         struct target_signal_frame *sf;
1760         int sigframe_size, err, i;
1761
1762         /* 1. Make sure everything is clean */
1763         //synchronize_user_stack();
1764
1765         sigframe_size = NF_ALIGNEDSZ;
1766         sf_addr = get_sigframe(ka, env, sigframe_size);
1767
1768         sf = lock_user(VERIFY_WRITE, sf_addr,
1769                        sizeof(struct target_signal_frame), 0);
1770         if (!sf)
1771                 goto sigsegv;
1772
1773         //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1774 #if 0
1775         if (invalid_frame_pointer(sf, sigframe_size))
1776                 goto sigill_and_return;
1777 #endif
1778         /* 2. Save the current process state */
1779         err = setup___siginfo(&sf->info, env, set->sig[0]);
1780         err |= __put_user(0, &sf->extra_size);
1781
1782         //err |= save_fpu_state(regs, &sf->fpu_state);
1783         //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1784
1785         err |= __put_user(set->sig[0], &sf->info.si_mask);
1786         for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1787                 err |= __put_user(set->sig[i + 1], &sf->extramask[i]);
1788         }
1789
1790         for (i = 0; i < 8; i++) {
1791                 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
1792         }
1793         for (i = 0; i < 8; i++) {
1794                 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
1795         }
1796         if (err)
1797                 goto sigsegv;
1798
1799         /* 3. signal handler back-trampoline and parameters */
1800         env->regwptr[UREG_FP] = sf_addr;
1801         env->regwptr[UREG_I0] = sig;
1802         env->regwptr[UREG_I1] = sf_addr +
1803                 offsetof(struct target_signal_frame, info);
1804         env->regwptr[UREG_I2] = sf_addr +
1805                 offsetof(struct target_signal_frame, info);
1806
1807         /* 4. signal handler */
1808         env->pc = ka->_sa_handler;
1809         env->npc = (env->pc + 4);
1810         /* 5. return to kernel instructions */
1811         if (ka->sa_restorer)
1812                 env->regwptr[UREG_I7] = ka->sa_restorer;
1813         else {
1814                 uint32_t val32;
1815
1816                 env->regwptr[UREG_I7] = sf_addr +
1817                         offsetof(struct target_signal_frame, insns) - 2 * 4;
1818
1819                 /* mov __NR_sigreturn, %g1 */
1820                 val32 = 0x821020d8;
1821                 err |= __put_user(val32, &sf->insns[0]);
1822
1823                 /* t 0x10 */
1824                 val32 = 0x91d02010;
1825                 err |= __put_user(val32, &sf->insns[1]);
1826                 if (err)
1827                         goto sigsegv;
1828
1829                 /* Flush instruction space. */
1830                 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
1831                 //              tb_flush(env);
1832         }
1833         unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
1834         return;
1835 #if 0
1836 sigill_and_return:
1837         force_sig(TARGET_SIGILL);
1838 #endif
1839 sigsegv:
1840         //fprintf(stderr, "force_sig\n");
1841         unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
1842         force_sig(TARGET_SIGSEGV);
1843 }
1844 static inline int
1845 restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu)
1846 {
1847         int err;
1848 #if 0
1849 #ifdef CONFIG_SMP
1850         if (current->flags & PF_USEDFPU)
1851                 regs->psr &= ~PSR_EF;
1852 #else
1853         if (current == last_task_used_math) {
1854                 last_task_used_math = 0;
1855                 regs->psr &= ~PSR_EF;
1856         }
1857 #endif
1858         current->used_math = 1;
1859         current->flags &= ~PF_USEDFPU;
1860 #endif
1861 #if 0
1862         if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
1863                 return -EFAULT;
1864 #endif
1865
1866 #if 0
1867         /* XXX: incorrect */
1868         err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0],
1869                                      (sizeof(unsigned long) * 32));
1870 #endif
1871         err |= __get_user(env->fsr, &fpu->si_fsr);
1872 #if 0
1873         err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
1874         if (current->thread.fpqdepth != 0)
1875                 err |= __copy_from_user(&current->thread.fpqueue[0],
1876                                         &fpu->si_fpqueue[0],
1877                                         ((sizeof(unsigned long) +
1878                                         (sizeof(unsigned long *)))*16));
1879 #endif
1880         return err;
1881 }
1882
1883
1884 static void setup_rt_frame(int sig, struct target_sigaction *ka,
1885                            target_siginfo_t *info,
1886                            target_sigset_t *set, CPUState *env)
1887 {
1888     fprintf(stderr, "setup_rt_frame: not implemented\n");
1889 }
1890
1891 long do_sigreturn(CPUState *env)
1892 {
1893         abi_ulong sf_addr;
1894         struct target_signal_frame *sf;
1895         uint32_t up_psr, pc, npc;
1896         target_sigset_t set;
1897         sigset_t host_set;
1898         abi_ulong fpu_save_addr;
1899         int err, i;
1900
1901         sf_addr = env->regwptr[UREG_FP];
1902         if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1))
1903                 goto segv_and_exit;
1904 #if 0
1905         fprintf(stderr, "sigreturn\n");
1906         fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1907 #endif
1908         //cpu_dump_state(env, stderr, fprintf, 0);
1909
1910         /* 1. Make sure we are not getting garbage from the user */
1911
1912         if (sf_addr & 3)
1913                 goto segv_and_exit;
1914
1915         err = __get_user(pc,  &sf->info.si_regs.pc);
1916         err |= __get_user(npc, &sf->info.si_regs.npc);
1917
1918         if ((pc | npc) & 3)
1919                 goto segv_and_exit;
1920
1921         /* 2. Restore the state */
1922         err |= __get_user(up_psr, &sf->info.si_regs.psr);
1923
1924         /* User can only change condition codes and FPU enabling in %psr. */
1925         env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
1926                   | (env->psr & ~(PSR_ICC /* | PSR_EF */));
1927
1928         env->pc = pc;
1929         env->npc = npc;
1930         err |= __get_user(env->y, &sf->info.si_regs.y);
1931         for (i=0; i < 8; i++) {
1932                 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
1933         }
1934         for (i=0; i < 8; i++) {
1935                 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
1936         }
1937
1938         err |= __get_user(fpu_save_addr, &sf->fpu_save);
1939
1940         //if (fpu_save)
1941         //        err |= restore_fpu_state(env, fpu_save);
1942
1943         /* This is pretty much atomic, no amount locking would prevent
1944          * the races which exist anyways.
1945          */
1946         err |= __get_user(set.sig[0], &sf->info.si_mask);
1947         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1948             err |= (__get_user(set.sig[i], &sf->extramask[i - 1]));
1949         }
1950
1951         target_to_host_sigset_internal(&host_set, &set);
1952         sigprocmask(SIG_SETMASK, &host_set, NULL);
1953
1954         if (err)
1955                 goto segv_and_exit;
1956         unlock_user_struct(sf, sf_addr, 0);
1957         return env->regwptr[0];
1958
1959 segv_and_exit:
1960         unlock_user_struct(sf, sf_addr, 0);
1961         force_sig(TARGET_SIGSEGV);
1962 }
1963
1964 long do_rt_sigreturn(CPUState *env)
1965 {
1966     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1967     return -TARGET_ENOSYS;
1968 }
1969
1970 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
1971 #define MC_TSTATE 0
1972 #define MC_PC 1
1973 #define MC_NPC 2
1974 #define MC_Y 3
1975 #define MC_G1 4
1976 #define MC_G2 5
1977 #define MC_G3 6
1978 #define MC_G4 7
1979 #define MC_G5 8
1980 #define MC_G6 9
1981 #define MC_G7 10
1982 #define MC_O0 11
1983 #define MC_O1 12
1984 #define MC_O2 13
1985 #define MC_O3 14
1986 #define MC_O4 15
1987 #define MC_O5 16
1988 #define MC_O6 17
1989 #define MC_O7 18
1990 #define MC_NGREG 19
1991
1992 typedef abi_ulong target_mc_greg_t;
1993 typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG];
1994
1995 struct target_mc_fq {
1996     abi_ulong *mcfq_addr;
1997     uint32_t mcfq_insn;
1998 };
1999
2000 struct target_mc_fpu {
2001     union {
2002         uint32_t sregs[32];
2003         uint64_t dregs[32];
2004         //uint128_t qregs[16];
2005     } mcfpu_fregs;
2006     abi_ulong mcfpu_fsr;
2007     abi_ulong mcfpu_fprs;
2008     abi_ulong mcfpu_gsr;
2009     struct target_mc_fq *mcfpu_fq;
2010     unsigned char mcfpu_qcnt;
2011     unsigned char mcfpu_qentsz;
2012     unsigned char mcfpu_enab;
2013 };
2014 typedef struct target_mc_fpu target_mc_fpu_t;
2015
2016 typedef struct {
2017     target_mc_gregset_t mc_gregs;
2018     target_mc_greg_t mc_fp;
2019     target_mc_greg_t mc_i7;
2020     target_mc_fpu_t mc_fpregs;
2021 } target_mcontext_t;
2022
2023 struct target_ucontext {
2024     struct target_ucontext *uc_link;
2025     abi_ulong uc_flags;
2026     target_sigset_t uc_sigmask;
2027     target_mcontext_t uc_mcontext;
2028 };
2029
2030 /* A V9 register window */
2031 struct target_reg_window {
2032     abi_ulong locals[8];
2033     abi_ulong ins[8];
2034 };
2035
2036 #define TARGET_STACK_BIAS 2047
2037
2038 /* {set, get}context() needed for 64-bit SparcLinux userland. */
2039 void sparc64_set_context(CPUSPARCState *env)
2040 {
2041     abi_ulong ucp_addr;
2042     struct target_ucontext *ucp;
2043     target_mc_gregset_t *grp;
2044     abi_ulong pc, npc, tstate;
2045     abi_ulong fp, i7, w_addr;
2046     unsigned char fenab;
2047     int err;
2048     unsigned int i;
2049
2050     ucp_addr = env->regwptr[UREG_I0];
2051     if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1))
2052         goto do_sigsegv;
2053     grp  = &ucp->uc_mcontext.mc_gregs;
2054     err  = __get_user(pc, &((*grp)[MC_PC]));
2055     err |= __get_user(npc, &((*grp)[MC_NPC]));
2056     if (err || ((pc | npc) & 3))
2057         goto do_sigsegv;
2058     if (env->regwptr[UREG_I1]) {
2059         target_sigset_t target_set;
2060         sigset_t set;
2061
2062         if (TARGET_NSIG_WORDS == 1) {
2063             if (__get_user(target_set.sig[0], &ucp->uc_sigmask.sig[0]))
2064                 goto do_sigsegv;
2065         } else {
2066             abi_ulong *src, *dst;
2067             src = ucp->uc_sigmask.sig;
2068             dst = target_set.sig;
2069             for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
2070                  i++, dst++, src++)
2071                 err |= __get_user(*dst, src);
2072             if (err)
2073                 goto do_sigsegv;
2074         }
2075         target_to_host_sigset_internal(&set, &target_set);
2076         sigprocmask(SIG_SETMASK, &set, NULL);
2077     }
2078     env->pc = pc;
2079     env->npc = npc;
2080     err |= __get_user(env->y, &((*grp)[MC_Y]));
2081     err |= __get_user(tstate, &((*grp)[MC_TSTATE]));
2082     env->asi = (tstate >> 24) & 0xff;
2083     PUT_CCR(env, tstate >> 32);
2084     PUT_CWP64(env, tstate & 0x1f);
2085     err |= __get_user(env->gregs[1], (&(*grp)[MC_G1]));
2086     err |= __get_user(env->gregs[2], (&(*grp)[MC_G2]));
2087     err |= __get_user(env->gregs[3], (&(*grp)[MC_G3]));
2088     err |= __get_user(env->gregs[4], (&(*grp)[MC_G4]));
2089     err |= __get_user(env->gregs[5], (&(*grp)[MC_G5]));
2090     err |= __get_user(env->gregs[6], (&(*grp)[MC_G6]));
2091     err |= __get_user(env->gregs[7], (&(*grp)[MC_G7]));
2092     err |= __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0]));
2093     err |= __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1]));
2094     err |= __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2]));
2095     err |= __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3]));
2096     err |= __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4]));
2097     err |= __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5]));
2098     err |= __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6]));
2099     err |= __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7]));
2100
2101     err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp));
2102     err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7));
2103
2104     w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2105     if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2106                  abi_ulong) != 0)
2107         goto do_sigsegv;
2108     if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2109                  abi_ulong) != 0)
2110         goto do_sigsegv;
2111     err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));
2112     err |= __get_user(env->fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));
2113     {
2114         uint32_t *src, *dst;
2115         src = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2116         dst = env->fpr;
2117         /* XXX: check that the CPU storage is the same as user context */
2118         for (i = 0; i < 64; i++, dst++, src++)
2119             err |= __get_user(*dst, src);
2120     }
2121     err |= __get_user(env->fsr,
2122                       &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr));
2123     err |= __get_user(env->gsr,
2124                       &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr));
2125     if (err)
2126         goto do_sigsegv;
2127     unlock_user_struct(ucp, ucp_addr, 0);
2128     return;
2129  do_sigsegv:
2130     unlock_user_struct(ucp, ucp_addr, 0);
2131     force_sig(SIGSEGV);
2132 }
2133
2134 void sparc64_get_context(CPUSPARCState *env)
2135 {
2136     abi_ulong ucp_addr;
2137     struct target_ucontext *ucp;
2138     target_mc_gregset_t *grp;
2139     target_mcontext_t *mcp;
2140     abi_ulong fp, i7, w_addr;
2141     int err;
2142     unsigned int i;
2143     target_sigset_t target_set;
2144     sigset_t set;
2145
2146     ucp_addr = env->regwptr[UREG_I0];
2147     if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0))
2148         goto do_sigsegv;
2149
2150     mcp = &ucp->uc_mcontext;
2151     grp = &mcp->mc_gregs;
2152
2153     /* Skip over the trap instruction, first. */
2154     env->pc = env->npc;
2155     env->npc += 4;
2156
2157     err = 0;
2158
2159     sigprocmask(0, NULL, &set);
2160     host_to_target_sigset_internal(&target_set, &set);
2161     if (TARGET_NSIG_WORDS == 1) {
2162         err |= __put_user(target_set.sig[0],
2163                           (abi_ulong *)&ucp->uc_sigmask);
2164     } else {
2165         abi_ulong *src, *dst;
2166         src = target_set.sig;
2167         dst = ucp->uc_sigmask.sig;
2168         for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
2169              i++, dst++, src++)
2170             err |= __put_user(*src, dst);
2171         if (err)
2172             goto do_sigsegv;
2173     }
2174
2175     /* XXX: tstate must be saved properly */
2176     //    err |= __put_user(env->tstate, &((*grp)[MC_TSTATE]));
2177     err |= __put_user(env->pc, &((*grp)[MC_PC]));
2178     err |= __put_user(env->npc, &((*grp)[MC_NPC]));
2179     err |= __put_user(env->y, &((*grp)[MC_Y]));
2180     err |= __put_user(env->gregs[1], &((*grp)[MC_G1]));
2181     err |= __put_user(env->gregs[2], &((*grp)[MC_G2]));
2182     err |= __put_user(env->gregs[3], &((*grp)[MC_G3]));
2183     err |= __put_user(env->gregs[4], &((*grp)[MC_G4]));
2184     err |= __put_user(env->gregs[5], &((*grp)[MC_G5]));
2185     err |= __put_user(env->gregs[6], &((*grp)[MC_G6]));
2186     err |= __put_user(env->gregs[7], &((*grp)[MC_G7]));
2187     err |= __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0]));
2188     err |= __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1]));
2189     err |= __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2]));
2190     err |= __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3]));
2191     err |= __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4]));
2192     err |= __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5]));
2193     err |= __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6]));
2194     err |= __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7]));
2195
2196     w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2197     fp = i7 = 0;
2198     if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2199                  abi_ulong) != 0)
2200         goto do_sigsegv;
2201     if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2202                  abi_ulong) != 0)
2203         goto do_sigsegv;
2204     err |= __put_user(fp, &(mcp->mc_fp));
2205     err |= __put_user(i7, &(mcp->mc_i7));
2206
2207     {
2208         uint32_t *src, *dst;
2209         src = env->fpr;
2210         dst = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2211         /* XXX: check that the CPU storage is the same as user context */
2212         for (i = 0; i < 64; i++, dst++, src++)
2213             err |= __put_user(*src, dst);
2214     }
2215     err |= __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr));
2216     err |= __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr));
2217     err |= __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs));
2218
2219     if (err)
2220         goto do_sigsegv;
2221     unlock_user_struct(ucp, ucp_addr, 1);
2222     return;
2223  do_sigsegv:
2224     unlock_user_struct(ucp, ucp_addr, 1);
2225     force_sig(SIGSEGV);
2226 }
2227 #endif
2228 #elif defined(TARGET_ABI_MIPSN64)
2229
2230 # warning signal handling not implemented
2231
2232 static void setup_frame(int sig, struct target_sigaction *ka,
2233                         target_sigset_t *set, CPUState *env)
2234 {
2235     fprintf(stderr, "setup_frame: not implemented\n");
2236 }
2237
2238 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2239                            target_siginfo_t *info,
2240                            target_sigset_t *set, CPUState *env)
2241 {
2242     fprintf(stderr, "setup_rt_frame: not implemented\n");
2243 }
2244
2245 long do_sigreturn(CPUState *env)
2246 {
2247     fprintf(stderr, "do_sigreturn: not implemented\n");
2248     return -TARGET_ENOSYS;
2249 }
2250
2251 long do_rt_sigreturn(CPUState *env)
2252 {
2253     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2254     return -TARGET_ENOSYS;
2255 }
2256
2257 #elif defined(TARGET_ABI_MIPSN32)
2258
2259 # warning signal handling not implemented
2260
2261 static void setup_frame(int sig, struct target_sigaction *ka,
2262                         target_sigset_t *set, CPUState *env)
2263 {
2264     fprintf(stderr, "setup_frame: not implemented\n");
2265 }
2266
2267 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2268                            target_siginfo_t *info,
2269                            target_sigset_t *set, CPUState *env)
2270 {
2271     fprintf(stderr, "setup_rt_frame: not implemented\n");
2272 }
2273
2274 long do_sigreturn(CPUState *env)
2275 {
2276     fprintf(stderr, "do_sigreturn: not implemented\n");
2277     return -TARGET_ENOSYS;
2278 }
2279
2280 long do_rt_sigreturn(CPUState *env)
2281 {
2282     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2283     return -TARGET_ENOSYS;
2284 }
2285
2286 #elif defined(TARGET_ABI_MIPSO32)
2287
2288 struct target_sigcontext {
2289     uint32_t   sc_regmask;     /* Unused */
2290     uint32_t   sc_status;
2291     uint64_t   sc_pc;
2292     uint64_t   sc_regs[32];
2293     uint64_t   sc_fpregs[32];
2294     uint32_t   sc_ownedfp;     /* Unused */
2295     uint32_t   sc_fpc_csr;
2296     uint32_t   sc_fpc_eir;     /* Unused */
2297     uint32_t   sc_used_math;
2298     uint32_t   sc_dsp;         /* dsp status, was sc_ssflags */
2299     uint64_t   sc_mdhi;
2300     uint64_t   sc_mdlo;
2301     target_ulong   sc_hi1;         /* Was sc_cause */
2302     target_ulong   sc_lo1;         /* Was sc_badvaddr */
2303     target_ulong   sc_hi2;         /* Was sc_sigset[4] */
2304     target_ulong   sc_lo2;
2305     target_ulong   sc_hi3;
2306     target_ulong   sc_lo3;
2307 };
2308
2309 struct sigframe {
2310     uint32_t sf_ass[4];                 /* argument save space for o32 */
2311     uint32_t sf_code[2];                        /* signal trampoline */
2312     struct target_sigcontext sf_sc;
2313     target_sigset_t sf_mask;
2314 };
2315
2316 /* Install trampoline to jump back from signal handler */
2317 static inline int install_sigtramp(unsigned int *tramp,   unsigned int syscall)
2318 {
2319     int err;
2320
2321     /*
2322     * Set up the return code ...
2323     *
2324     *         li      v0, __NR__foo_sigreturn
2325     *         syscall
2326     */
2327
2328     err = __put_user(0x24020000 + syscall, tramp + 0);
2329     err |= __put_user(0x0000000c          , tramp + 1);
2330     /* flush_cache_sigtramp((unsigned long) tramp); */
2331     return err;
2332 }
2333
2334 static inline int
2335 setup_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2336 {
2337     int err = 0;
2338
2339     err |= __put_user(regs->active_tc.PC, &sc->sc_pc);
2340
2341 #define save_gp_reg(i) do {                                             \
2342         err |= __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);     \
2343     } while(0)
2344     __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
2345     save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
2346     save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
2347     save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
2348     save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
2349     save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
2350     save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
2351     save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
2352     save_gp_reg(31);
2353 #undef save_gp_reg
2354
2355     err |= __put_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2356     err |= __put_user(regs->active_tc.LO[0], &sc->sc_mdlo);
2357
2358     /* Not used yet, but might be useful if we ever have DSP suppport */
2359 #if 0
2360     if (cpu_has_dsp) {
2361         err |= __put_user(mfhi1(), &sc->sc_hi1);
2362         err |= __put_user(mflo1(), &sc->sc_lo1);
2363         err |= __put_user(mfhi2(), &sc->sc_hi2);
2364         err |= __put_user(mflo2(), &sc->sc_lo2);
2365         err |= __put_user(mfhi3(), &sc->sc_hi3);
2366         err |= __put_user(mflo3(), &sc->sc_lo3);
2367         err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2368     }
2369     /* same with 64 bit */
2370 #ifdef CONFIG_64BIT
2371     err |= __put_user(regs->hi, &sc->sc_hi[0]);
2372     err |= __put_user(regs->lo, &sc->sc_lo[0]);
2373     if (cpu_has_dsp) {
2374         err |= __put_user(mfhi1(), &sc->sc_hi[1]);
2375         err |= __put_user(mflo1(), &sc->sc_lo[1]);
2376         err |= __put_user(mfhi2(), &sc->sc_hi[2]);
2377         err |= __put_user(mflo2(), &sc->sc_lo[2]);
2378         err |= __put_user(mfhi3(), &sc->sc_hi[3]);
2379         err |= __put_user(mflo3(), &sc->sc_lo[3]);
2380         err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2381     }
2382 #endif
2383 #endif
2384
2385 #if 0
2386     err |= __put_user(!!used_math(), &sc->sc_used_math);
2387
2388     if (!used_math())
2389         goto out;
2390
2391     /*
2392     * Save FPU state to signal context.  Signal handler will "inherit"
2393     * current FPU state.
2394     */
2395     preempt_disable();
2396
2397     if (!is_fpu_owner()) {
2398         own_fpu();
2399         restore_fp(current);
2400     }
2401     err |= save_fp_context(sc);
2402
2403     preempt_enable();
2404     out:
2405 #endif
2406     return err;
2407 }
2408
2409 static inline int
2410 restore_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2411 {
2412     int err = 0;
2413
2414     err |= __get_user(regs->CP0_EPC, &sc->sc_pc);
2415
2416     err |= __get_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2417     err |= __get_user(regs->active_tc.LO[0], &sc->sc_mdlo);
2418
2419 #define restore_gp_reg(i) do {                                                          \
2420         err |= __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);             \
2421     } while(0)
2422     restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
2423     restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
2424     restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
2425     restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
2426     restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
2427     restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
2428     restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
2429     restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
2430     restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
2431     restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
2432     restore_gp_reg(31);
2433 #undef restore_gp_reg
2434
2435 #if 0
2436     if (cpu_has_dsp) {
2437         err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
2438         err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
2439         err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
2440         err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
2441         err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
2442         err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
2443         err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2444     }
2445 #ifdef CONFIG_64BIT
2446     err |= __get_user(regs->hi, &sc->sc_hi[0]);
2447     err |= __get_user(regs->lo, &sc->sc_lo[0]);
2448     if (cpu_has_dsp) {
2449         err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg);
2450         err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg);
2451         err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg);
2452         err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg);
2453         err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg);
2454         err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg);
2455         err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2456     }
2457 #endif
2458
2459     err |= __get_user(used_math, &sc->sc_used_math);
2460     conditional_used_math(used_math);
2461
2462     preempt_disable();
2463
2464     if (used_math()) {
2465         /* restore fpu context if we have used it before */
2466         own_fpu();
2467         err |= restore_fp_context(sc);
2468     } else {
2469         /* signal handler may have used FPU.  Give it up. */
2470         lose_fpu();
2471     }
2472
2473     preempt_enable();
2474 #endif
2475     return err;
2476 }
2477 /*
2478  * Determine which stack to use..
2479  */
2480 static inline abi_ulong
2481 get_sigframe(struct target_sigaction *ka, CPUState *regs, size_t frame_size)
2482 {
2483     unsigned long sp;
2484
2485     /* Default to using normal stack */
2486     sp = regs->active_tc.gpr[29];
2487
2488     /*
2489      * FPU emulator may have it's own trampoline active just
2490      * above the user stack, 16-bytes before the next lowest
2491      * 16 byte boundary.  Try to avoid trashing it.
2492      */
2493     sp -= 32;
2494
2495     /* This is the X/Open sanctioned signal stack switching.  */
2496     if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
2497         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2498     }
2499
2500     return (sp - frame_size) & ~7;
2501 }
2502
2503 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */
2504 static void setup_frame(int sig, struct target_sigaction * ka,
2505                         target_sigset_t *set, CPUState *regs)
2506 {
2507     struct sigframe *frame;
2508     abi_ulong frame_addr;
2509     int i;
2510
2511     frame_addr = get_sigframe(ka, regs, sizeof(*frame));
2512     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2513         goto give_sigsegv;
2514
2515     install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
2516
2517     if(setup_sigcontext(regs, &frame->sf_sc))
2518         goto give_sigsegv;
2519
2520     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2521         if(__put_user(set->sig[i], &frame->sf_mask.sig[i]))
2522             goto give_sigsegv;
2523     }
2524
2525     /*
2526     * Arguments to signal handler:
2527     *
2528     *   a0 = signal number
2529     *   a1 = 0 (should be cause)
2530     *   a2 = pointer to struct sigcontext
2531     *
2532     * $25 and PC point to the signal handler, $29 points to the
2533     * struct sigframe.
2534     */
2535     regs->active_tc.gpr[ 4] = sig;
2536     regs->active_tc.gpr[ 5] = 0;
2537     regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc);
2538     regs->active_tc.gpr[29] = frame_addr;
2539     regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code);
2540     /* The original kernel code sets CP0_EPC to the handler
2541     * since it returns to userland using eret
2542     * we cannot do this here, and we must set PC directly */
2543     regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler;
2544     unlock_user_struct(frame, frame_addr, 1);
2545     return;
2546
2547 give_sigsegv:
2548     unlock_user_struct(frame, frame_addr, 1);
2549     force_sig(TARGET_SIGSEGV/*, current*/);
2550     return;
2551 }
2552
2553 long do_sigreturn(CPUState *regs)
2554 {
2555     struct sigframe *frame;
2556     abi_ulong frame_addr;
2557     sigset_t blocked;
2558     target_sigset_t target_set;
2559     int i;
2560
2561 #if defined(DEBUG_SIGNAL)
2562     fprintf(stderr, "do_sigreturn\n");
2563 #endif
2564     frame_addr = regs->active_tc.gpr[29];
2565     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2566         goto badframe;
2567
2568     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2569         if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i]))
2570             goto badframe;
2571     }
2572
2573     target_to_host_sigset_internal(&blocked, &target_set);
2574     sigprocmask(SIG_SETMASK, &blocked, NULL);
2575
2576     if (restore_sigcontext(regs, &frame->sf_sc))
2577         goto badframe;
2578
2579 #if 0
2580     /*
2581      * Don't let your children do this ...
2582      */
2583     __asm__ __volatile__(
2584         "move\t$29, %0\n\t"
2585         "j\tsyscall_exit"
2586         :/* no outputs */
2587         :"r" (&regs));
2588     /* Unreached */
2589 #endif
2590
2591     regs->active_tc.PC = regs->CP0_EPC;
2592     /* I am not sure this is right, but it seems to work
2593     * maybe a problem with nested signals ? */
2594     regs->CP0_EPC = 0;
2595     return 0;
2596
2597 badframe:
2598     force_sig(TARGET_SIGSEGV/*, current*/);
2599     return 0;
2600 }
2601
2602 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2603                            target_siginfo_t *info,
2604                            target_sigset_t *set, CPUState *env)
2605 {
2606     fprintf(stderr, "setup_rt_frame: not implemented\n");
2607 }
2608
2609 long do_rt_sigreturn(CPUState *env)
2610 {
2611     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2612     return -TARGET_ENOSYS;
2613 }
2614
2615 #elif defined(TARGET_SH4)
2616
2617 /*
2618  * code and data structures from linux kernel:
2619  * include/asm-sh/sigcontext.h
2620  * arch/sh/kernel/signal.c
2621  */
2622
2623 struct target_sigcontext {
2624     target_ulong  oldmask;
2625
2626     /* CPU registers */
2627     target_ulong  sc_gregs[16];
2628     target_ulong  sc_pc;
2629     target_ulong  sc_pr;
2630     target_ulong  sc_sr;
2631     target_ulong  sc_gbr;
2632     target_ulong  sc_mach;
2633     target_ulong  sc_macl;
2634
2635     /* FPU registers */
2636     target_ulong  sc_fpregs[16];
2637     target_ulong  sc_xfpregs[16];
2638     unsigned int sc_fpscr;
2639     unsigned int sc_fpul;
2640     unsigned int sc_ownedfp;
2641 };
2642
2643 struct target_sigframe
2644 {
2645     struct target_sigcontext sc;
2646     target_ulong extramask[TARGET_NSIG_WORDS-1];
2647     uint16_t retcode[3];
2648 };
2649
2650
2651 struct target_ucontext {
2652     target_ulong uc_flags;
2653     struct target_ucontext *uc_link;
2654     target_stack_t uc_stack;
2655     struct target_sigcontext uc_mcontext;
2656     target_sigset_t uc_sigmask; /* mask last for extensibility */
2657 };
2658
2659 struct target_rt_sigframe
2660 {
2661     struct target_siginfo info;
2662     struct target_ucontext uc;
2663     uint16_t retcode[3];
2664 };
2665
2666
2667 #define MOVW(n)  (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
2668 #define TRAP_NOARG 0xc310         /* Syscall w/no args (NR in R3) SH3/4 */
2669
2670 static abi_ulong get_sigframe(struct target_sigaction *ka,
2671                          unsigned long sp, size_t frame_size)
2672 {
2673     if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) {
2674         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2675     }
2676
2677     return (sp - frame_size) & -8ul;
2678 }
2679
2680 static int setup_sigcontext(struct target_sigcontext *sc,
2681                             CPUState *regs, unsigned long mask)
2682 {
2683     int err = 0;
2684
2685 #define COPY(x)         err |= __put_user(regs->x, &sc->sc_##x)
2686     COPY(gregs[0]); COPY(gregs[1]);
2687     COPY(gregs[2]); COPY(gregs[3]);
2688     COPY(gregs[4]); COPY(gregs[5]);
2689     COPY(gregs[6]); COPY(gregs[7]);
2690     COPY(gregs[8]); COPY(gregs[9]);
2691     COPY(gregs[10]); COPY(gregs[11]);
2692     COPY(gregs[12]); COPY(gregs[13]);
2693     COPY(gregs[14]); COPY(gregs[15]);
2694     COPY(gbr); COPY(mach);
2695     COPY(macl); COPY(pr);
2696     COPY(sr); COPY(pc);
2697 #undef COPY
2698
2699     /* todo: save FPU registers here */
2700
2701     /* non-iBCS2 extensions.. */
2702     err |= __put_user(mask, &sc->oldmask);
2703
2704     return err;
2705 }
2706
2707 static int restore_sigcontext(CPUState *regs,
2708                               struct target_sigcontext *sc)
2709 {
2710     unsigned int err = 0;
2711
2712 #define COPY(x)         err |= __get_user(regs->x, &sc->sc_##x)
2713     COPY(gregs[1]);
2714     COPY(gregs[2]); COPY(gregs[3]);
2715     COPY(gregs[4]); COPY(gregs[5]);
2716     COPY(gregs[6]); COPY(gregs[7]);
2717     COPY(gregs[8]); COPY(gregs[9]);
2718     COPY(gregs[10]); COPY(gregs[11]);
2719     COPY(gregs[12]); COPY(gregs[13]);
2720     COPY(gregs[14]); COPY(gregs[15]);
2721     COPY(gbr); COPY(mach);
2722     COPY(macl); COPY(pr);
2723     COPY(sr); COPY(pc);
2724 #undef COPY
2725
2726     /* todo: restore FPU registers here */
2727
2728     regs->tra = -1;         /* disable syscall checks */
2729     return err;
2730 }
2731
2732 static void setup_frame(int sig, struct target_sigaction *ka,
2733                         target_sigset_t *set, CPUState *regs)
2734 {
2735     struct target_sigframe *frame;
2736     abi_ulong frame_addr;
2737     int i;
2738     int err = 0;
2739     int signal;
2740
2741     frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
2742     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2743         goto give_sigsegv;
2744
2745     signal = current_exec_domain_sig(sig);
2746
2747     err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
2748
2749     for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
2750         err |= __put_user(set->sig[i + 1], &frame->extramask[i]);
2751     }
2752
2753     /* Set up to return from userspace.  If provided, use a stub
2754        already in userspace.  */
2755     if (ka->sa_flags & TARGET_SA_RESTORER) {
2756         regs->pr = (unsigned long) ka->sa_restorer;
2757     } else {
2758         /* Generate return code (system call to sigreturn) */
2759         err |= __put_user(MOVW(2), &frame->retcode[0]);
2760         err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
2761         err |= __put_user((TARGET_NR_sigreturn), &frame->retcode[2]);
2762         regs->pr = (unsigned long) frame->retcode;
2763     }
2764
2765     if (err)
2766         goto give_sigsegv;
2767
2768     /* Set up registers for signal handler */
2769     regs->gregs[15] = (unsigned long) frame;
2770     regs->gregs[4] = signal; /* Arg for signal handler */
2771     regs->gregs[5] = 0;
2772     regs->gregs[6] = (unsigned long) &frame->sc;
2773     regs->pc = (unsigned long) ka->_sa_handler;
2774
2775     unlock_user_struct(frame, frame_addr, 1);
2776     return;
2777
2778 give_sigsegv:
2779     unlock_user_struct(frame, frame_addr, 1);
2780     force_sig(SIGSEGV);
2781 }
2782
2783 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2784                            target_siginfo_t *info,
2785                            target_sigset_t *set, CPUState *regs)
2786 {
2787     struct target_rt_sigframe *frame;
2788     abi_ulong frame_addr;
2789     int i;
2790     int err = 0;
2791     int signal;
2792
2793     frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
2794     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2795         goto give_sigsegv;
2796
2797     signal = current_exec_domain_sig(sig);
2798
2799     err |= copy_siginfo_to_user(&frame->info, info);
2800
2801     /* Create the ucontext.  */
2802     err |= __put_user(0, &frame->uc.uc_flags);
2803     err |= __put_user(0, (unsigned long *)&frame->uc.uc_link);
2804     err |= __put_user((unsigned long)target_sigaltstack_used.ss_sp,
2805                       &frame->uc.uc_stack.ss_sp);
2806     err |= __put_user(sas_ss_flags(regs->gregs[15]),
2807                       &frame->uc.uc_stack.ss_flags);
2808     err |= __put_user(target_sigaltstack_used.ss_size,
2809                       &frame->uc.uc_stack.ss_size);
2810     err |= setup_sigcontext(&frame->uc.uc_mcontext,
2811                             regs, set->sig[0]);
2812     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2813         err |= __put_user(set->sig[i], &frame->uc.uc_sigmask.sig[i]);
2814     }
2815
2816     /* Set up to return from userspace.  If provided, use a stub
2817        already in userspace.  */
2818     if (ka->sa_flags & TARGET_SA_RESTORER) {
2819         regs->pr = (unsigned long) ka->sa_restorer;
2820     } else {
2821         /* Generate return code (system call to sigreturn) */
2822         err |= __put_user(MOVW(2), &frame->retcode[0]);
2823         err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
2824         err |= __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]);
2825         regs->pr = (unsigned long) frame->retcode;
2826     }
2827
2828     if (err)
2829         goto give_sigsegv;
2830
2831     /* Set up registers for signal handler */
2832     regs->gregs[15] = (unsigned long) frame;
2833     regs->gregs[4] = signal; /* Arg for signal handler */
2834     regs->gregs[5] = (unsigned long) &frame->info;
2835     regs->gregs[6] = (unsigned long) &frame->uc;
2836     regs->pc = (unsigned long) ka->_sa_handler;
2837
2838     unlock_user_struct(frame, frame_addr, 1);
2839     return;
2840
2841 give_sigsegv:
2842     unlock_user_struct(frame, frame_addr, 1);
2843     force_sig(SIGSEGV);
2844 }
2845
2846 long do_sigreturn(CPUState *regs)
2847 {
2848     struct target_sigframe *frame;
2849     abi_ulong frame_addr;
2850     sigset_t blocked;
2851     target_sigset_t target_set;
2852     int i;
2853     int err = 0;
2854
2855 #if defined(DEBUG_SIGNAL)
2856     fprintf(stderr, "do_sigreturn\n");
2857 #endif
2858     frame_addr = regs->gregs[15];
2859     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2860         goto badframe;
2861
2862     err |= __get_user(target_set.sig[0], &frame->sc.oldmask);
2863     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
2864         err |= (__get_user(target_set.sig[i], &frame->extramask[i - 1]));
2865     }
2866
2867     if (err)
2868         goto badframe;
2869
2870     target_to_host_sigset_internal(&blocked, &target_set);
2871     sigprocmask(SIG_SETMASK, &blocked, NULL);
2872
2873     if (restore_sigcontext(regs, &frame->sc))
2874         goto badframe;
2875
2876     unlock_user_struct(frame, frame_addr, 0);
2877     return regs->gregs[0];
2878
2879 badframe:
2880     unlock_user_struct(frame, frame_addr, 0);
2881     force_sig(TARGET_SIGSEGV);
2882     return 0;
2883 }
2884
2885 long do_rt_sigreturn(CPUState *regs)
2886 {
2887     struct target_rt_sigframe *frame;
2888     abi_ulong frame_addr;
2889     sigset_t blocked;
2890
2891 #if defined(DEBUG_SIGNAL)
2892     fprintf(stderr, "do_rt_sigreturn\n");
2893 #endif
2894     frame_addr = regs->gregs[15];
2895     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2896         goto badframe;
2897
2898     target_to_host_sigset(&blocked, &frame->uc.uc_sigmask);
2899     sigprocmask(SIG_SETMASK, &blocked, NULL);
2900
2901     if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
2902         goto badframe;
2903
2904     if (do_sigaltstack(frame_addr +
2905                        offsetof(struct target_rt_sigframe, uc.uc_stack),
2906                        0, get_sp_from_cpustate(regs)) == -EFAULT)
2907         goto badframe;
2908
2909     unlock_user_struct(frame, frame_addr, 0);
2910     return regs->gregs[0];
2911
2912 badframe:
2913     unlock_user_struct(frame, frame_addr, 0);
2914     force_sig(TARGET_SIGSEGV);
2915     return 0;
2916 }
2917 #elif defined(TARGET_CRIS)
2918
2919 struct target_sigcontext {
2920         struct target_pt_regs regs;  /* needs to be first */
2921         uint32_t oldmask;
2922         uint32_t usp;    /* usp before stacking this gunk on it */
2923 };
2924
2925 /* Signal frames. */
2926 struct target_signal_frame {
2927         struct target_sigcontext sc;
2928         uint32_t extramask[TARGET_NSIG_WORDS - 1];
2929         uint8_t retcode[8];       /* Trampoline code. */
2930 };
2931
2932 struct rt_signal_frame {
2933         struct siginfo *pinfo;
2934         void *puc;
2935         struct siginfo info;
2936         struct ucontext uc;
2937         uint8_t retcode[8];       /* Trampoline code. */
2938 };
2939
2940 static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env)
2941 {
2942         __put_user(env->regs[0], &sc->regs.r0);
2943         __put_user(env->regs[1], &sc->regs.r1);
2944         __put_user(env->regs[2], &sc->regs.r2);
2945         __put_user(env->regs[3], &sc->regs.r3);
2946         __put_user(env->regs[4], &sc->regs.r4);
2947         __put_user(env->regs[5], &sc->regs.r5);
2948         __put_user(env->regs[6], &sc->regs.r6);
2949         __put_user(env->regs[7], &sc->regs.r7);
2950         __put_user(env->regs[8], &sc->regs.r8);
2951         __put_user(env->regs[9], &sc->regs.r9);
2952         __put_user(env->regs[10], &sc->regs.r10);
2953         __put_user(env->regs[11], &sc->regs.r11);
2954         __put_user(env->regs[12], &sc->regs.r12);
2955         __put_user(env->regs[13], &sc->regs.r13);
2956         __put_user(env->regs[14], &sc->usp);
2957         __put_user(env->regs[15], &sc->regs.acr);
2958         __put_user(env->pregs[PR_MOF], &sc->regs.mof);
2959         __put_user(env->pregs[PR_SRP], &sc->regs.srp);
2960         __put_user(env->pc, &sc->regs.erp);
2961 }
2962
2963 static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env)
2964 {
2965         __get_user(env->regs[0], &sc->regs.r0);
2966         __get_user(env->regs[1], &sc->regs.r1);
2967         __get_user(env->regs[2], &sc->regs.r2);
2968         __get_user(env->regs[3], &sc->regs.r3);
2969         __get_user(env->regs[4], &sc->regs.r4);
2970         __get_user(env->regs[5], &sc->regs.r5);
2971         __get_user(env->regs[6], &sc->regs.r6);
2972         __get_user(env->regs[7], &sc->regs.r7);
2973         __get_user(env->regs[8], &sc->regs.r8);
2974         __get_user(env->regs[9], &sc->regs.r9);
2975         __get_user(env->regs[10], &sc->regs.r10);
2976         __get_user(env->regs[11], &sc->regs.r11);
2977         __get_user(env->regs[12], &sc->regs.r12);
2978         __get_user(env->regs[13], &sc->regs.r13);
2979         __get_user(env->regs[14], &sc->usp);
2980         __get_user(env->regs[15], &sc->regs.acr);
2981         __get_user(env->pregs[PR_MOF], &sc->regs.mof);
2982         __get_user(env->pregs[PR_SRP], &sc->regs.srp);
2983         __get_user(env->pc, &sc->regs.erp);
2984 }
2985
2986 static abi_ulong get_sigframe(CPUState *env, int framesize)
2987 {
2988         abi_ulong sp;
2989         /* Align the stack downwards to 4.  */
2990         sp = (env->regs[R_SP] & ~3);
2991         return sp - framesize;
2992 }
2993
2994 static void setup_frame(int sig, struct target_sigaction *ka,
2995                         target_sigset_t *set, CPUState *env)
2996 {
2997         struct target_signal_frame *frame;
2998         abi_ulong frame_addr;
2999         int err = 0;
3000         int i;
3001
3002         frame_addr = get_sigframe(env, sizeof *frame);
3003         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3004                 goto badframe;
3005
3006         /*
3007          * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
3008          * use this trampoline anymore but it sets it up for GDB.
3009          * In QEMU, using the trampoline simplifies things a bit so we use it.
3010          *
3011          * This is movu.w __NR_sigreturn, r9; break 13;
3012          */
3013         err |= __put_user(0x9c5f, frame->retcode+0);
3014         err |= __put_user(TARGET_NR_sigreturn,
3015                           frame->retcode+2);
3016         err |= __put_user(0xe93d, frame->retcode+4);
3017
3018         /* Save the mask.  */
3019         err |= __put_user(set->sig[0], &frame->sc.oldmask);
3020         if (err)
3021                 goto badframe;
3022
3023         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3024                 if (__put_user(set->sig[i], &frame->extramask[i - 1]))
3025                         goto badframe;
3026         }
3027
3028         setup_sigcontext(&frame->sc, env);
3029
3030         /* Move the stack and setup the arguments for the handler.  */
3031         env->regs[R_SP] = (uint32_t) (unsigned long) frame;
3032         env->regs[10] = sig;
3033         env->pc = (unsigned long) ka->_sa_handler;
3034         /* Link SRP so the guest returns through the trampoline.  */
3035         env->pregs[PR_SRP] = (uint32_t) (unsigned long) &frame->retcode[0];
3036
3037         unlock_user_struct(frame, frame_addr, 1);
3038         return;
3039   badframe:
3040         unlock_user_struct(frame, frame_addr, 1);
3041         force_sig(TARGET_SIGSEGV);
3042 }
3043
3044 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3045                            target_siginfo_t *info,
3046                            target_sigset_t *set, CPUState *env)
3047 {
3048     fprintf(stderr, "CRIS setup_rt_frame: not implemented\n");
3049 }
3050
3051 long do_sigreturn(CPUState *env)
3052 {
3053         struct target_signal_frame *frame;
3054         abi_ulong frame_addr;
3055         target_sigset_t target_set;
3056         sigset_t set;
3057         int i;
3058
3059         frame_addr = env->regs[R_SP];
3060         /* Make sure the guest isn't playing games.  */
3061         if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3062                 goto badframe;
3063
3064         /* Restore blocked signals */
3065         if (__get_user(target_set.sig[0], &frame->sc.oldmask))
3066                 goto badframe;
3067         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3068                 if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3069                         goto badframe;
3070         }
3071         target_to_host_sigset_internal(&set, &target_set);
3072         sigprocmask(SIG_SETMASK, &set, NULL);
3073
3074         restore_sigcontext(&frame->sc, env);
3075         unlock_user_struct(frame, frame_addr, 0);
3076         return env->regs[10];
3077   badframe:
3078         unlock_user_struct(frame, frame_addr, 0);
3079         force_sig(TARGET_SIGSEGV);
3080 }
3081
3082 long do_rt_sigreturn(CPUState *env)
3083 {
3084     fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n");
3085     return -TARGET_ENOSYS;
3086 }
3087
3088 #else
3089
3090 static void setup_frame(int sig, struct target_sigaction *ka,
3091                         target_sigset_t *set, CPUState *env)
3092 {
3093     fprintf(stderr, "setup_frame: not implemented\n");
3094 }
3095
3096 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3097                            target_siginfo_t *info,
3098                            target_sigset_t *set, CPUState *env)
3099 {
3100     fprintf(stderr, "setup_rt_frame: not implemented\n");
3101 }
3102
3103 long do_sigreturn(CPUState *env)
3104 {
3105     fprintf(stderr, "do_sigreturn: not implemented\n");
3106     return -TARGET_ENOSYS;
3107 }
3108
3109 long do_rt_sigreturn(CPUState *env)
3110 {
3111     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
3112     return -TARGET_ENOSYS;
3113 }
3114
3115 #endif
3116
3117 void process_pending_signals(CPUState *cpu_env)
3118 {
3119     int sig;
3120     abi_ulong handler;
3121     sigset_t set, old_set;
3122     target_sigset_t target_old_set;
3123     struct emulated_sigtable *k;
3124     struct target_sigaction *sa;
3125     struct sigqueue *q;
3126     TaskState *ts = cpu_env->opaque;
3127
3128     if (!ts->signal_pending)
3129         return;
3130
3131     /* FIXME: This is not threadsafe.  */
3132     k = ts->sigtab;
3133     for(sig = 1; sig <= TARGET_NSIG; sig++) {
3134         if (k->pending)
3135             goto handle_signal;
3136         k++;
3137     }
3138     /* if no signal is pending, just return */
3139     ts->signal_pending = 0;
3140     return;
3141
3142  handle_signal:
3143 #ifdef DEBUG_SIGNAL
3144     fprintf(stderr, "qemu: process signal %d\n", sig);
3145 #endif
3146     /* dequeue signal */
3147     q = k->first;
3148     k->first = q->next;
3149     if (!k->first)
3150         k->pending = 0;
3151
3152     sig = gdb_handlesig (cpu_env, sig);
3153     if (!sig) {
3154         sa = NULL;
3155         handler = TARGET_SIG_IGN;
3156     } else {
3157         sa = &sigact_table[sig - 1];
3158         handler = sa->_sa_handler;
3159     }
3160
3161     if (handler == TARGET_SIG_DFL) {
3162         /* default handler : ignore some signal. The other are job control or fatal */
3163         if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
3164             kill(getpid(),SIGSTOP);
3165         } else if (sig != TARGET_SIGCHLD &&
3166                    sig != TARGET_SIGURG &&
3167                    sig != TARGET_SIGWINCH &&
3168                    sig != TARGET_SIGCONT) {
3169             force_sig(sig);
3170         }
3171     } else if (handler == TARGET_SIG_IGN) {
3172         /* ignore sig */
3173     } else if (handler == TARGET_SIG_ERR) {
3174         force_sig(sig);
3175     } else {
3176         /* compute the blocked signals during the handler execution */
3177         target_to_host_sigset(&set, &sa->sa_mask);
3178         /* SA_NODEFER indicates that the current signal should not be
3179            blocked during the handler */
3180         if (!(sa->sa_flags & TARGET_SA_NODEFER))
3181             sigaddset(&set, target_to_host_signal(sig));
3182
3183         /* block signals in the handler using Linux */
3184         sigprocmask(SIG_BLOCK, &set, &old_set);
3185         /* save the previous blocked signal state to restore it at the
3186            end of the signal execution (see do_sigreturn) */
3187         host_to_target_sigset_internal(&target_old_set, &old_set);
3188
3189         /* if the CPU is in VM86 mode, we restore the 32 bit values */
3190 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
3191         {
3192             CPUX86State *env = cpu_env;
3193             if (env->eflags & VM_MASK)
3194                 save_v86_state(env);
3195         }
3196 #endif
3197         /* prepare the stack frame of the virtual CPU */
3198         if (sa->sa_flags & TARGET_SA_SIGINFO)
3199             setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
3200         else
3201             setup_frame(sig, sa, &target_old_set, cpu_env);
3202         if (sa->sa_flags & TARGET_SA_RESETHAND)
3203             sa->_sa_handler = TARGET_SIG_DFL;
3204     }
3205     if (q != &k->info)
3206         free_sigqueue(cpu_env, q);
3207 }