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

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