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