git.maemo.org Git - qemu/blob - linux-user/signal.c

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