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

   1 /*
   2  *  Emulation of Linux signals
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <stdarg.h>
  24 #include <unistd.h>
  25 #include <signal.h>
  26 #include <errno.h>
  27 #include <sys/ucontext.h>
  28
  29 #include "qemu.h"
  30
  31 //#define DEBUG_SIGNAL
  32
  33 #define MAX_SIGQUEUE_SIZE 1024
  34
  35 struct sigqueue {
  36     struct sigqueue *next;
  37     target_siginfo_t info;
  38 };
  39
  40 struct emulated_sigaction {
  41     struct target_sigaction sa;
  42     int pending; /* true if signal is pending */
  43     struct sigqueue *first;
  44     struct sigqueue info; /* in order to always have memory for the
  45                              first signal, we put it here */
  46 };
  47
  48 static struct emulated_sigaction sigact_table[TARGET_NSIG];
  49 static struct sigqueue sigqueue_table[MAX_SIGQUEUE_SIZE]; /* siginfo queue */
  50 static struct sigqueue *first_free; /* first free siginfo queue entry */
  51 static int signal_pending; /* non zero if a signal may be pending */
  52
  53 static void host_signal_handler(int host_signum, siginfo_t *info,
  54                                 void *puc);
  55
  56 static uint8_t host_to_target_signal_table[65] = {
  57     [SIGHUP] = TARGET_SIGHUP,
  58     [SIGINT] = TARGET_SIGINT,
  59     [SIGQUIT] = TARGET_SIGQUIT,
  60     [SIGILL] = TARGET_SIGILL,
  61     [SIGTRAP] = TARGET_SIGTRAP,
  62     [SIGABRT] = TARGET_SIGABRT,
  63 /*    [SIGIOT] = TARGET_SIGIOT,*/
  64     [SIGBUS] = TARGET_SIGBUS,
  65     [SIGFPE] = TARGET_SIGFPE,
  66     [SIGKILL] = TARGET_SIGKILL,
  67     [SIGUSR1] = TARGET_SIGUSR1,
  68     [SIGSEGV] = TARGET_SIGSEGV,
  69     [SIGUSR2] = TARGET_SIGUSR2,
  70     [SIGPIPE] = TARGET_SIGPIPE,
  71     [SIGALRM] = TARGET_SIGALRM,
  72     [SIGTERM] = TARGET_SIGTERM,
  73 #ifdef SIGSTKFLT
  74     [SIGSTKFLT] = TARGET_SIGSTKFLT,
  75 #endif
  76     [SIGCHLD] = TARGET_SIGCHLD,
  77     [SIGCONT] = TARGET_SIGCONT,
  78     [SIGSTOP] = TARGET_SIGSTOP,
  79     [SIGTSTP] = TARGET_SIGTSTP,
  80     [SIGTTIN] = TARGET_SIGTTIN,
  81     [SIGTTOU] = TARGET_SIGTTOU,
  82     [SIGURG] = TARGET_SIGURG,
  83     [SIGXCPU] = TARGET_SIGXCPU,
  84     [SIGXFSZ] = TARGET_SIGXFSZ,
  85     [SIGVTALRM] = TARGET_SIGVTALRM,
  86     [SIGPROF] = TARGET_SIGPROF,
  87     [SIGWINCH] = TARGET_SIGWINCH,
  88     [SIGIO] = TARGET_SIGIO,
  89     [SIGPWR] = TARGET_SIGPWR,
  90     [SIGSYS] = TARGET_SIGSYS,
  91     /* next signals stay the same */
  92 };
  93 static uint8_t target_to_host_signal_table[65];
  94
  95 static inline int host_to_target_signal(int sig)
  96 {
  97     return host_to_target_signal_table[sig];
  98 }
  99
 100 static inline int target_to_host_signal(int sig)
 101 {
 102     return target_to_host_signal_table[sig];
 103 }
 104
 105 static void host_to_target_sigset_internal(target_sigset_t *d,
 106                                            const sigset_t *s)
 107 {
 108     int i;
 109     unsigned long sigmask;
 110     uint32_t target_sigmask;
 111
 112     sigmask = ((unsigned long *)s)[0];
 113     target_sigmask = 0;
 114     for(i = 0; i < 32; i++) {
 115         if (sigmask & (1 << i))
 116             target_sigmask |= 1 << (host_to_target_signal(i + 1) - 1);
 117     }
 118 #if TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 32
 119     d->sig[0] = target_sigmask;
 120     for(i = 1;i < TARGET_NSIG_WORDS; i++) {
 121         d->sig[i] = ((unsigned long *)s)[i];
 122     }
 123 #elif TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2
 124     d->sig[0] = target_sigmask;
 125     d->sig[1] = sigmask >> 32;
 126 #else
 127 #warning host_to_target_sigset
 128 #endif
 129 }
 130
 131 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
 132 {
 133     target_sigset_t d1;
 134     int i;
 135
 136     host_to_target_sigset_internal(&d1, s);
 137     for(i = 0;i < TARGET_NSIG_WORDS; i++)
 138         d->sig[i] = tswapl(d1.sig[i]);
 139 }
 140
 141 void target_to_host_sigset_internal(sigset_t *d, const target_sigset_t *s)
 142 {
 143     int i;
 144     unsigned long sigmask;
 145     target_ulong target_sigmask;
 146
 147     target_sigmask = s->sig[0];
 148     sigmask = 0;
 149     for(i = 0; i < 32; i++) {
 150         if (target_sigmask & (1 << i))
 151             sigmask |= 1 << (target_to_host_signal(i + 1) - 1);
 152     }
 153 #if TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 32
 154     ((unsigned long *)d)[0] = sigmask;
 155     for(i = 1;i < TARGET_NSIG_WORDS; i++) {
 156         ((unsigned long *)d)[i] = s->sig[i];
 157     }
 158 #elif TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 64 && TARGET_NSIG_WORDS == 2
 159     ((unsigned long *)d)[0] = sigmask | ((unsigned long)(s->sig[1]) << 32);
 160 #else
 161 #warning target_to_host_sigset
 162 #endif /* TARGET_LONG_BITS */
 163 }
 164
 165 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
 166 {
 167     target_sigset_t s1;
 168     int i;
 169
 170     for(i = 0;i < TARGET_NSIG_WORDS; i++)
 171         s1.sig[i] = tswapl(s->sig[i]);
 172     target_to_host_sigset_internal(d, &s1);
 173 }
 174
 175 void host_to_target_old_sigset(target_ulong *old_sigset,
 176                                const sigset_t *sigset)
 177 {
 178     target_sigset_t d;
 179     host_to_target_sigset(&d, sigset);
 180     *old_sigset = d.sig[0];
 181 }
 182
 183 void target_to_host_old_sigset(sigset_t *sigset,
 184                                const target_ulong *old_sigset)
 185 {
 186     target_sigset_t d;
 187     int i;
 188
 189     d.sig[0] = *old_sigset;
 190     for(i = 1;i < TARGET_NSIG_WORDS; i++)
 191         d.sig[i] = 0;
 192     target_to_host_sigset(sigset, &d);
 193 }
 194
 195 /* siginfo conversion */
 196
 197 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
 198                                                  const siginfo_t *info)
 199 {
 200     int sig;
 201     sig = host_to_target_signal(info->si_signo);
 202     tinfo->si_signo = sig;
 203     tinfo->si_errno = 0;
 204     tinfo->si_code = 0;
 205     if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
 206         sig == SIGBUS || sig == SIGTRAP) {
 207         /* should never come here, but who knows. The information for
 208            the target is irrelevant */
 209         tinfo->_sifields._sigfault._addr = 0;
 210     } else if (sig >= TARGET_SIGRTMIN) {
 211         tinfo->_sifields._rt._pid = info->si_pid;
 212         tinfo->_sifields._rt._uid = info->si_uid;
 213         /* XXX: potential problem if 64 bit */
 214         tinfo->_sifields._rt._sigval.sival_ptr =
 215             (target_ulong)info->si_value.sival_ptr;
 216     }
 217 }
 218
 219 static void tswap_siginfo(target_siginfo_t *tinfo,
 220                           const target_siginfo_t *info)
 221 {
 222     int sig;
 223     sig = info->si_signo;
 224     tinfo->si_signo = tswap32(sig);
 225     tinfo->si_errno = tswap32(info->si_errno);
 226     tinfo->si_code = tswap32(info->si_code);
 227     if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
 228         sig == SIGBUS || sig == SIGTRAP) {
 229         tinfo->_sifields._sigfault._addr =
 230             tswapl(info->_sifields._sigfault._addr);
 231     } else if (sig >= TARGET_SIGRTMIN) {
 232         tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
 233         tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
 234         tinfo->_sifields._rt._sigval.sival_ptr =
 235             tswapl(info->_sifields._rt._sigval.sival_ptr);
 236     }
 237 }
 238
 239
 240 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
 241 {
 242     host_to_target_siginfo_noswap(tinfo, info);
 243     tswap_siginfo(tinfo, tinfo);
 244 }
 245
 246 /* XXX: we support only POSIX RT signals are used. */
 247 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
 248 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
 249 {
 250     info->si_signo = tswap32(tinfo->si_signo);
 251     info->si_errno = tswap32(tinfo->si_errno);
 252     info->si_code = tswap32(tinfo->si_code);
 253     info->si_pid = tswap32(tinfo->_sifields._rt._pid);
 254     info->si_uid = tswap32(tinfo->_sifields._rt._uid);
 255     info->si_value.sival_ptr =
 256         (void *)tswapl(tinfo->_sifields._rt._sigval.sival_ptr);
 257 }
 258
 259 void signal_init(void)
 260 {
 261     struct sigaction act;
 262     int i, j;
 263
 264     /* generate signal conversion tables */
 265     for(i = 1; i <= 64; i++) {
 266         if (host_to_target_signal_table[i] == 0)
 267             host_to_target_signal_table[i] = i;
 268     }
 269     for(i = 1; i <= 64; i++) {
 270         j = host_to_target_signal_table[i];
 271         target_to_host_signal_table[j] = i;
 272     }
 273
 274     /* set all host signal handlers. ALL signals are blocked during
 275        the handlers to serialize them. */
 276     sigfillset(&act.sa_mask);
 277     act.sa_flags = SA_SIGINFO;
 278     act.sa_sigaction = host_signal_handler;
 279     for(i = 1; i < NSIG; i++) {
 280         sigaction(i, &act, NULL);
 281     }
 282
 283     memset(sigact_table, 0, sizeof(sigact_table));
 284
 285     first_free = &sigqueue_table[0];
 286     for(i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++)
 287         sigqueue_table[i].next = &sigqueue_table[i + 1];
 288     sigqueue_table[MAX_SIGQUEUE_SIZE - 1].next = NULL;
 289 }
 290
 291 /* signal queue handling */
 292
 293 static inline struct sigqueue *alloc_sigqueue(void)
 294 {
 295     struct sigqueue *q = first_free;
 296     if (!q)
 297         return NULL;
 298     first_free = q->next;
 299     return q;
 300 }
 301
 302 static inline void free_sigqueue(struct sigqueue *q)
 303 {
 304     q->next = first_free;
 305     first_free = q;
 306 }
 307
 308 /* abort execution with signal */
 309 void __attribute((noreturn)) force_sig(int sig)
 310 {
 311     int host_sig;
 312     host_sig = target_to_host_signal(sig);
 313     fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",
 314             sig, strsignal(host_sig));
 315 #if 1
 316     _exit(-host_sig);
 317 #else
 318     {
 319         struct sigaction act;
 320         sigemptyset(&act.sa_mask);
 321         act.sa_flags = SA_SIGINFO;
 322         act.sa_sigaction = SIG_DFL;
 323         sigaction(SIGABRT, &act, NULL);
 324         abort();
 325     }
 326 #endif
 327 }
 328
 329 /* queue a signal so that it will be send to the virtual CPU as soon
 330    as possible */
 331 int queue_signal(int sig, target_siginfo_t *info)
 332 {
 333     struct emulated_sigaction *k;
 334     struct sigqueue *q, **pq;
 335     target_ulong handler;
 336
 337 #if defined(DEBUG_SIGNAL)
 338     fprintf(stderr, "queue_signal: sig=%d\n",
 339             sig);
 340 #endif
 341     k = &sigact_table[sig - 1];
 342     handler = k->sa._sa_handler;
 343     if (handler == TARGET_SIG_DFL) {
 344         /* default handler : ignore some signal. The other are fatal */
 345         if (sig != TARGET_SIGCHLD &&
 346             sig != TARGET_SIGURG &&
 347             sig != TARGET_SIGWINCH) {
 348             force_sig(sig);
 349         } else {
 350             return 0; /* indicate ignored */
 351         }
 352     } else if (handler == TARGET_SIG_IGN) {
 353         /* ignore signal */
 354         return 0;
 355     } else if (handler == TARGET_SIG_ERR) {
 356         force_sig(sig);
 357     } else {
 358         pq = &k->first;
 359         if (sig < TARGET_SIGRTMIN) {
 360             /* if non real time signal, we queue exactly one signal */
 361             if (!k->pending)
 362                 q = &k->info;
 363             else
 364                 return 0;
 365         } else {
 366             if (!k->pending) {
 367                 /* first signal */
 368                 q = &k->info;
 369             } else {
 370                 q = alloc_sigqueue();
 371                 if (!q)
 372                     return -EAGAIN;
 373                 while (*pq != NULL)
 374                     pq = &(*pq)->next;
 375             }
 376         }
 377         *pq = q;
 378         q->info = *info;
 379         q->next = NULL;
 380         k->pending = 1;
 381         /* signal that a new signal is pending */
 382         signal_pending = 1;
 383         return 1; /* indicates that the signal was queued */
 384     }
 385 }
 386
 387 static void host_signal_handler(int host_signum, siginfo_t *info,
 388                                 void *puc)
 389 {
 390     int sig;
 391     target_siginfo_t tinfo;
 392
 393     /* the CPU emulator uses some host signals to detect exceptions,
 394        we we forward to it some signals */
 395     if (host_signum == SIGSEGV || host_signum == SIGBUS
 396 #if defined(TARGET_I386) && defined(USE_CODE_COPY)
 397         || host_signum == SIGFPE
 398 #endif
 399         ) {
 400         if (cpu_signal_handler(host_signum, info, puc))
 401             return;
 402     }
 403
 404     /* get target signal number */
 405     sig = host_to_target_signal(host_signum);
 406     if (sig < 1 || sig > TARGET_NSIG)
 407         return;
 408 #if defined(DEBUG_SIGNAL)
 409     fprintf(stderr, "qemu: got signal %d\n", sig);
 410 #endif
 411     host_to_target_siginfo_noswap(&tinfo, info);
 412     if (queue_signal(sig, &tinfo) == 1) {
 413         /* interrupt the virtual CPU as soon as possible */
 414         cpu_interrupt(global_env, CPU_INTERRUPT_EXIT);
 415     }
 416 }
 417
 418 int do_sigaction(int sig, const struct target_sigaction *act,
 419                  struct target_sigaction *oact)
 420 {
 421     struct emulated_sigaction *k;
 422     struct sigaction act1;
 423     int host_sig;
 424
 425     if (sig < 1 || sig > TARGET_NSIG || sig == SIGKILL || sig == SIGSTOP)
 426         return -EINVAL;
 427     k = &sigact_table[sig - 1];
 428 #if defined(DEBUG_SIGNAL)
 429     fprintf(stderr, "sigaction sig=%d act=0x%08x, oact=0x%08x\n",
 430             sig, (int)act, (int)oact);
 431 #endif
 432     if (oact) {
 433         oact->_sa_handler = tswapl(k->sa._sa_handler);
 434         oact->sa_flags = tswapl(k->sa.sa_flags);
 435 #if !defined(TARGET_MIPS)
 436         oact->sa_restorer = tswapl(k->sa.sa_restorer);
 437 #endif
 438         oact->sa_mask = k->sa.sa_mask;
 439     }
 440     if (act) {
 441         k->sa._sa_handler = tswapl(act->_sa_handler);
 442         k->sa.sa_flags = tswapl(act->sa_flags);
 443 #if !defined(TARGET_MIPS)
 444         k->sa.sa_restorer = tswapl(act->sa_restorer);
 445 #endif
 446         k->sa.sa_mask = act->sa_mask;
 447
 448         /* we update the host linux signal state */
 449         host_sig = target_to_host_signal(sig);
 450         if (host_sig != SIGSEGV && host_sig != SIGBUS) {
 451             sigfillset(&act1.sa_mask);
 452             act1.sa_flags = SA_SIGINFO;
 453             if (k->sa.sa_flags & TARGET_SA_RESTART)
 454                 act1.sa_flags |= SA_RESTART;
 455             /* NOTE: it is important to update the host kernel signal
 456                ignore state to avoid getting unexpected interrupted
 457                syscalls */
 458             if (k->sa._sa_handler == TARGET_SIG_IGN) {
 459                 act1.sa_sigaction = (void *)SIG_IGN;
 460             } else if (k->sa._sa_handler == TARGET_SIG_DFL) {
 461                 act1.sa_sigaction = (void *)SIG_DFL;
 462             } else {
 463                 act1.sa_sigaction = host_signal_handler;
 464             }
 465             sigaction(host_sig, &act1, NULL);
 466         }
 467     }
 468     return 0;
 469 }
 470
 471 #ifndef offsetof
 472 #define offsetof(type, field) ((size_t) &((type *)0)->field)
 473 #endif
 474
 475 static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,
 476                                        const target_siginfo_t *info)
 477 {
 478     tswap_siginfo(tinfo, info);
 479     return 0;
 480 }
 481
 482 #ifdef TARGET_I386
 483
 484 /* from the Linux kernel */
 485
 486 struct target_fpreg {
 487         uint16_t significand[4];
 488         uint16_t exponent;
 489 };
 490
 491 struct target_fpxreg {
 492         uint16_t significand[4];
 493         uint16_t exponent;
 494         uint16_t padding[3];
 495 };
 496
 497 struct target_xmmreg {
 498         target_ulong element[4];
 499 };
 500
 501 struct target_fpstate {
 502         /* Regular FPU environment */
 503         target_ulong    cw;
 504         target_ulong    sw;
 505         target_ulong    tag;
 506         target_ulong    ipoff;
 507         target_ulong    cssel;
 508         target_ulong    dataoff;
 509         target_ulong    datasel;
 510         struct target_fpreg     _st[8];
 511         uint16_t        status;
 512         uint16_t        magic;          /* 0xffff = regular FPU data only */
 513
 514         /* FXSR FPU environment */
 515         target_ulong    _fxsr_env[6];   /* FXSR FPU env is ignored */
 516         target_ulong    mxcsr;
 517         target_ulong    reserved;
 518         struct target_fpxreg    _fxsr_st[8];    /* FXSR FPU reg data is ignored */
 519         struct target_xmmreg    _xmm[8];
 520         target_ulong    padding[56];
 521 };
 522
 523 #define X86_FXSR_MAGIC          0x0000
 524
 525 struct target_sigcontext {
 526         uint16_t gs, __gsh;
 527         uint16_t fs, __fsh;
 528         uint16_t es, __esh;
 529         uint16_t ds, __dsh;
 530         target_ulong edi;
 531         target_ulong esi;
 532         target_ulong ebp;
 533         target_ulong esp;
 534         target_ulong ebx;
 535         target_ulong edx;
 536         target_ulong ecx;
 537         target_ulong eax;
 538         target_ulong trapno;
 539         target_ulong err;
 540         target_ulong eip;
 541         uint16_t cs, __csh;
 542         target_ulong eflags;
 543         target_ulong esp_at_signal;
 544         uint16_t ss, __ssh;
 545         target_ulong fpstate; /* pointer */
 546         target_ulong oldmask;
 547         target_ulong cr2;
 548 };
 549
 550 typedef struct target_sigaltstack {
 551         target_ulong ss_sp;
 552         int ss_flags;
 553         target_ulong ss_size;
 554 } target_stack_t;
 555
 556 struct target_ucontext {
 557         target_ulong      tuc_flags;
 558         target_ulong      tuc_link;
 559         target_stack_t    tuc_stack;
 560         struct target_sigcontext tuc_mcontext;
 561         target_sigset_t   tuc_sigmask;  /* mask last for extensibility */
 562 };
 563
 564 struct sigframe
 565 {
 566     target_ulong pretcode;
 567     int sig;
 568     struct target_sigcontext sc;
 569     struct target_fpstate fpstate;
 570     target_ulong extramask[TARGET_NSIG_WORDS-1];
 571     char retcode[8];
 572 };
 573
 574 struct rt_sigframe
 575 {
 576     target_ulong pretcode;
 577     int sig;
 578     target_ulong pinfo;
 579     target_ulong puc;
 580     struct target_siginfo info;
 581     struct target_ucontext uc;
 582     struct target_fpstate fpstate;
 583     char retcode[8];
 584 };
 585
 586 /*
 587  * Set up a signal frame.
 588  */
 589
 590 /* XXX: save x87 state */
 591 static int
 592 setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
 593                  CPUX86State *env, unsigned long mask)
 594 {
 595         int err = 0;
 596
 597         err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
 598         err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
 599         err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
 600         err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
 601         err |= __put_user(env->regs[R_EDI], &sc->edi);
 602         err |= __put_user(env->regs[R_ESI], &sc->esi);
 603         err |= __put_user(env->regs[R_EBP], &sc->ebp);
 604         err |= __put_user(env->regs[R_ESP], &sc->esp);
 605         err |= __put_user(env->regs[R_EBX], &sc->ebx);
 606         err |= __put_user(env->regs[R_EDX], &sc->edx);
 607         err |= __put_user(env->regs[R_ECX], &sc->ecx);
 608         err |= __put_user(env->regs[R_EAX], &sc->eax);
 609         err |= __put_user(env->exception_index, &sc->trapno);
 610         err |= __put_user(env->error_code, &sc->err);
 611         err |= __put_user(env->eip, &sc->eip);
 612         err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
 613         err |= __put_user(env->eflags, &sc->eflags);
 614         err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);
 615         err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
 616
 617         cpu_x86_fsave(env, (void *)fpstate, 1);
 618         fpstate->status = fpstate->sw;
 619         err |= __put_user(0xffff, &fpstate->magic);
 620         err |= __put_user(fpstate, &sc->fpstate);
 621
 622         /* non-iBCS2 extensions.. */
 623         err |= __put_user(mask, &sc->oldmask);
 624         err |= __put_user(env->cr[2], &sc->cr2);
 625         return err;
 626 }
 627
 628 /*
 629  * Determine which stack to use..
 630  */
 631
 632 static inline void *
 633 get_sigframe(struct emulated_sigaction *ka, CPUX86State *env, size_t frame_size)
 634 {
 635         unsigned long esp;
 636
 637         /* Default to using normal stack */
 638         esp = env->regs[R_ESP];
 639 #if 0
 640         /* This is the X/Open sanctioned signal stack switching.  */
 641         if (ka->sa.sa_flags & SA_ONSTACK) {
 642                 if (sas_ss_flags(esp) == 0)
 643                         esp = current->sas_ss_sp + current->sas_ss_size;
 644         }
 645
 646         /* This is the legacy signal stack switching. */
 647         else
 648 #endif
 649         if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
 650             !(ka->sa.sa_flags & TARGET_SA_RESTORER) &&
 651             ka->sa.sa_restorer) {
 652             esp = (unsigned long) ka->sa.sa_restorer;
 653         }
 654         return g2h((esp - frame_size) & -8ul);
 655 }
 656
 657 static void setup_frame(int sig, struct emulated_sigaction *ka,
 658                         target_sigset_t *set, CPUX86State *env)
 659 {
 660         struct sigframe *frame;
 661         int i, err = 0;
 662
 663         frame = get_sigframe(ka, env, sizeof(*frame));
 664
 665         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 666                 goto give_sigsegv;
 667         err |= __put_user((/*current->exec_domain
 668                            && current->exec_domain->signal_invmap
 669                            && sig < 32
 670                            ? current->exec_domain->signal_invmap[sig]
 671                            : */ sig),
 672                           &frame->sig);
 673         if (err)
 674                 goto give_sigsegv;
 675
 676         setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0]);
 677         if (err)
 678                 goto give_sigsegv;
 679
 680         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
 681             if (__put_user(set->sig[i], &frame->extramask[i - 1]))
 682                 goto give_sigsegv;
 683         }
 684
 685         /* Set up to return from userspace.  If provided, use a stub
 686            already in userspace.  */
 687         if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
 688                 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
 689         } else {
 690                 err |= __put_user(frame->retcode, &frame->pretcode);
 691                 /* This is popl %eax ; movl $,%eax ; int $0x80 */
 692                 err |= __put_user(0xb858, (short *)(frame->retcode+0));
 693 #if defined(TARGET_X86_64)
 694 #warning "Fix this !"
 695 #else
 696                 err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
 697 #endif
 698                 err |= __put_user(0x80cd, (short *)(frame->retcode+6));
 699         }
 700
 701         if (err)
 702                 goto give_sigsegv;
 703
 704         /* Set up registers for signal handler */
 705         env->regs[R_ESP] = h2g(frame);
 706         env->eip = (unsigned long) ka->sa._sa_handler;
 707
 708         cpu_x86_load_seg(env, R_DS, __USER_DS);
 709         cpu_x86_load_seg(env, R_ES, __USER_DS);
 710         cpu_x86_load_seg(env, R_SS, __USER_DS);
 711         cpu_x86_load_seg(env, R_CS, __USER_CS);
 712         env->eflags &= ~TF_MASK;
 713
 714         return;
 715
 716 give_sigsegv:
 717         if (sig == TARGET_SIGSEGV)
 718                 ka->sa._sa_handler = TARGET_SIG_DFL;
 719         force_sig(TARGET_SIGSEGV /* , current */);
 720 }
 721
 722 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
 723                            target_siginfo_t *info,
 724                            target_sigset_t *set, CPUX86State *env)
 725 {
 726         struct rt_sigframe *frame;
 727         int i, err = 0;
 728
 729         frame = get_sigframe(ka, env, sizeof(*frame));
 730
 731         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 732                 goto give_sigsegv;
 733
 734         err |= __put_user((/*current->exec_domain
 735                            && current->exec_domain->signal_invmap
 736                            && sig < 32
 737                            ? current->exec_domain->signal_invmap[sig]
 738                            : */sig),
 739                           &frame->sig);
 740         err |= __put_user((target_ulong)&frame->info, &frame->pinfo);
 741         err |= __put_user((target_ulong)&frame->uc, &frame->puc);
 742         err |= copy_siginfo_to_user(&frame->info, info);
 743         if (err)
 744                 goto give_sigsegv;
 745
 746         /* Create the ucontext.  */
 747         err |= __put_user(0, &frame->uc.tuc_flags);
 748         err |= __put_user(0, &frame->uc.tuc_link);
 749         err |= __put_user(/*current->sas_ss_sp*/ 0,
 750                           &frame->uc.tuc_stack.ss_sp);
 751         err |= __put_user(/* sas_ss_flags(regs->esp) */ 0,
 752                           &frame->uc.tuc_stack.ss_flags);
 753         err |= __put_user(/* current->sas_ss_size */ 0,
 754                           &frame->uc.tuc_stack.ss_size);
 755         err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate,
 756                                 env, set->sig[0]);
 757         for(i = 0; i < TARGET_NSIG_WORDS; i++) {
 758             if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
 759                 goto give_sigsegv;
 760         }
 761
 762         /* Set up to return from userspace.  If provided, use a stub
 763            already in userspace.  */
 764         if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
 765                 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
 766         } else {
 767                 err |= __put_user(frame->retcode, &frame->pretcode);
 768                 /* This is movl $,%eax ; int $0x80 */
 769                 err |= __put_user(0xb8, (char *)(frame->retcode+0));
 770                 err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
 771                 err |= __put_user(0x80cd, (short *)(frame->retcode+5));
 772         }
 773
 774         if (err)
 775                 goto give_sigsegv;
 776
 777         /* Set up registers for signal handler */
 778         env->regs[R_ESP] = (unsigned long) frame;
 779         env->eip = (unsigned long) ka->sa._sa_handler;
 780
 781         cpu_x86_load_seg(env, R_DS, __USER_DS);
 782         cpu_x86_load_seg(env, R_ES, __USER_DS);
 783         cpu_x86_load_seg(env, R_SS, __USER_DS);
 784         cpu_x86_load_seg(env, R_CS, __USER_CS);
 785         env->eflags &= ~TF_MASK;
 786
 787         return;
 788
 789 give_sigsegv:
 790         if (sig == TARGET_SIGSEGV)
 791                 ka->sa._sa_handler = TARGET_SIG_DFL;
 792         force_sig(TARGET_SIGSEGV /* , current */);
 793 }
 794
 795 static int
 796 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
 797 {
 798         unsigned int err = 0;
 799
 800         cpu_x86_load_seg(env, R_GS, lduw(&sc->gs));
 801         cpu_x86_load_seg(env, R_FS, lduw(&sc->fs));
 802         cpu_x86_load_seg(env, R_ES, lduw(&sc->es));
 803         cpu_x86_load_seg(env, R_DS, lduw(&sc->ds));
 804
 805         env->regs[R_EDI] = ldl(&sc->edi);
 806         env->regs[R_ESI] = ldl(&sc->esi);
 807         env->regs[R_EBP] = ldl(&sc->ebp);
 808         env->regs[R_ESP] = ldl(&sc->esp);
 809         env->regs[R_EBX] = ldl(&sc->ebx);
 810         env->regs[R_EDX] = ldl(&sc->edx);
 811         env->regs[R_ECX] = ldl(&sc->ecx);
 812         env->eip = ldl(&sc->eip);
 813
 814         cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3);
 815         cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3);
 816
 817         {
 818                 unsigned int tmpflags;
 819                 tmpflags = ldl(&sc->eflags);
 820                 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
 821                 //              regs->orig_eax = -1;            /* disable syscall checks */
 822         }
 823
 824         {
 825                 struct _fpstate * buf;
 826                 buf = (void *)ldl(&sc->fpstate);
 827                 if (buf) {
 828 #if 0
 829                         if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
 830                                 goto badframe;
 831 #endif
 832                         cpu_x86_frstor(env, (void *)buf, 1);
 833                 }
 834         }
 835
 836         *peax = ldl(&sc->eax);
 837         return err;
 838 #if 0
 839 badframe:
 840         return 1;
 841 #endif
 842 }
 843
 844 long do_sigreturn(CPUX86State *env)
 845 {
 846     struct sigframe *frame = (struct sigframe *)g2h(env->regs[R_ESP] - 8);
 847     target_sigset_t target_set;
 848     sigset_t set;
 849     int eax, i;
 850
 851 #if defined(DEBUG_SIGNAL)
 852     fprintf(stderr, "do_sigreturn\n");
 853 #endif
 854     /* set blocked signals */
 855     if (__get_user(target_set.sig[0], &frame->sc.oldmask))
 856         goto badframe;
 857     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
 858         if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
 859             goto badframe;
 860     }
 861
 862     target_to_host_sigset_internal(&set, &target_set);
 863     sigprocmask(SIG_SETMASK, &set, NULL);
 864
 865     /* restore registers */
 866     if (restore_sigcontext(env, &frame->sc, &eax))
 867         goto badframe;
 868     return eax;
 869
 870 badframe:
 871     force_sig(TARGET_SIGSEGV);
 872     return 0;
 873 }
 874
 875 long do_rt_sigreturn(CPUX86State *env)
 876 {
 877         struct rt_sigframe *frame = (struct rt_sigframe *)g2h(env->regs[R_ESP] - 4);
 878         sigset_t set;
 879         //      stack_t st;
 880         int eax;
 881
 882 #if 0
 883         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 884                 goto badframe;
 885 #endif
 886         target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
 887         sigprocmask(SIG_SETMASK, &set, NULL);
 888
 889         if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))
 890                 goto badframe;
 891
 892 #if 0
 893         if (__copy_from_user(&st, &frame->uc.tuc_stack, sizeof(st)))
 894                 goto badframe;
 895         /* It is more difficult to avoid calling this function than to
 896            call it and ignore errors.  */
 897         do_sigaltstack(&st, NULL, regs->esp);
 898 #endif
 899         return eax;
 900
 901 badframe:
 902         force_sig(TARGET_SIGSEGV);
 903         return 0;
 904 }
 905
 906 #elif defined(TARGET_ARM)
 907
 908 struct target_sigcontext {
 909         target_ulong trap_no;
 910         target_ulong error_code;
 911         target_ulong oldmask;
 912         target_ulong arm_r0;
 913         target_ulong arm_r1;
 914         target_ulong arm_r2;
 915         target_ulong arm_r3;
 916         target_ulong arm_r4;
 917         target_ulong arm_r5;
 918         target_ulong arm_r6;
 919         target_ulong arm_r7;
 920         target_ulong arm_r8;
 921         target_ulong arm_r9;
 922         target_ulong arm_r10;
 923         target_ulong arm_fp;
 924         target_ulong arm_ip;
 925         target_ulong arm_sp;
 926         target_ulong arm_lr;
 927         target_ulong arm_pc;
 928         target_ulong arm_cpsr;
 929         target_ulong fault_address;
 930 };
 931
 932 typedef struct target_sigaltstack {
 933         target_ulong ss_sp;
 934         int ss_flags;
 935         target_ulong ss_size;
 936 } target_stack_t;
 937
 938 struct target_ucontext {
 939     target_ulong tuc_flags;
 940     target_ulong tuc_link;
 941     target_stack_t tuc_stack;
 942     struct target_sigcontext tuc_mcontext;
 943     target_sigset_t  tuc_sigmask;       /* mask last for extensibility */
 944 };
 945
 946 struct sigframe
 947 {
 948     struct target_sigcontext sc;
 949     target_ulong extramask[TARGET_NSIG_WORDS-1];
 950     target_ulong retcode;
 951 };
 952
 953 struct rt_sigframe
 954 {
 955     struct target_siginfo *pinfo;
 956     void *puc;
 957     struct target_siginfo info;
 958     struct target_ucontext uc;
 959     target_ulong retcode;
 960 };
 961
 962 #define TARGET_CONFIG_CPU_32 1
 963
 964 /*
 965  * For ARM syscalls, we encode the syscall number into the instruction.
 966  */
 967 #define SWI_SYS_SIGRETURN       (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
 968 #define SWI_SYS_RT_SIGRETURN    (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
 969
 970 /*
 971  * For Thumb syscalls, we pass the syscall number via r7.  We therefore
 972  * need two 16-bit instructions.
 973  */
 974 #define SWI_THUMB_SIGRETURN     (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
 975 #define SWI_THUMB_RT_SIGRETURN  (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
 976
 977 static const target_ulong retcodes[4] = {
 978         SWI_SYS_SIGRETURN,      SWI_THUMB_SIGRETURN,
 979         SWI_SYS_RT_SIGRETURN,   SWI_THUMB_RT_SIGRETURN
 980 };
 981
 982
 983 #define __put_user_error(x,p,e) __put_user(x, p)
 984 #define __get_user_error(x,p,e) __get_user(x, p)
 985
 986 static inline int valid_user_regs(CPUState *regs)
 987 {
 988     return 1;
 989 }
 990
 991 static int
 992 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
 993                  CPUState *env, unsigned long mask)
 994 {
 995         int err = 0;
 996
 997         __put_user_error(env->regs[0], &sc->arm_r0, err);
 998         __put_user_error(env->regs[1], &sc->arm_r1, err);
 999         __put_user_error(env->regs[2], &sc->arm_r2, err);
1000         __put_user_error(env->regs[3], &sc->arm_r3, err);
1001         __put_user_error(env->regs[4], &sc->arm_r4, err);
1002         __put_user_error(env->regs[5], &sc->arm_r5, err);
1003         __put_user_error(env->regs[6], &sc->arm_r6, err);
1004         __put_user_error(env->regs[7], &sc->arm_r7, err);
1005         __put_user_error(env->regs[8], &sc->arm_r8, err);
1006         __put_user_error(env->regs[9], &sc->arm_r9, err);
1007         __put_user_error(env->regs[10], &sc->arm_r10, err);
1008         __put_user_error(env->regs[11], &sc->arm_fp, err);
1009         __put_user_error(env->regs[12], &sc->arm_ip, err);
1010         __put_user_error(env->regs[13], &sc->arm_sp, err);
1011         __put_user_error(env->regs[14], &sc->arm_lr, err);
1012         __put_user_error(env->regs[15], &sc->arm_pc, err);
1013 #ifdef TARGET_CONFIG_CPU_32
1014         __put_user_error(cpsr_read(env), &sc->arm_cpsr, err);
1015 #endif
1016
1017         __put_user_error(/* current->thread.trap_no */ 0, &sc->trap_no, err);
1018         __put_user_error(/* current->thread.error_code */ 0, &sc->error_code, err);
1019         __put_user_error(/* current->thread.address */ 0, &sc->fault_address, err);
1020         __put_user_error(mask, &sc->oldmask, err);
1021
1022         return err;
1023 }
1024
1025 static inline void *
1026 get_sigframe(struct emulated_sigaction *ka, CPUState *regs, int framesize)
1027 {
1028         unsigned long sp = regs->regs[13];
1029
1030 #if 0
1031         /*
1032          * This is the X/Open sanctioned signal stack switching.
1033          */
1034         if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
1035                 sp = current->sas_ss_sp + current->sas_ss_size;
1036 #endif
1037         /*
1038          * ATPCS B01 mandates 8-byte alignment
1039          */
1040         return g2h((sp - framesize) & ~7);
1041 }
1042
1043 static int
1044 setup_return(CPUState *env, struct emulated_sigaction *ka,
1045              target_ulong *rc, void *frame, int usig)
1046 {
1047         target_ulong handler = (target_ulong)ka->sa._sa_handler;
1048         target_ulong retcode;
1049         int thumb = 0;
1050 #if defined(TARGET_CONFIG_CPU_32)
1051 #if 0
1052         target_ulong cpsr = env->cpsr;
1053
1054         /*
1055          * Maybe we need to deliver a 32-bit signal to a 26-bit task.
1056          */
1057         if (ka->sa.sa_flags & SA_THIRTYTWO)
1058                 cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
1059
1060 #ifdef CONFIG_ARM_THUMB
1061         if (elf_hwcap & HWCAP_THUMB) {
1062                 /*
1063                  * The LSB of the handler determines if we're going to
1064                  * be using THUMB or ARM mode for this signal handler.
1065                  */
1066                 thumb = handler & 1;
1067
1068                 if (thumb)
1069                         cpsr |= T_BIT;
1070                 else
1071                         cpsr &= ~T_BIT;
1072         }
1073 #endif
1074 #endif
1075 #endif /* TARGET_CONFIG_CPU_32 */
1076
1077         if (ka->sa.sa_flags & TARGET_SA_RESTORER) {
1078                 retcode = (target_ulong)ka->sa.sa_restorer;
1079         } else {
1080                 unsigned int idx = thumb;
1081
1082                 if (ka->sa.sa_flags & TARGET_SA_SIGINFO)
1083                         idx += 2;
1084
1085                 if (__put_user(retcodes[idx], rc))
1086                         return 1;
1087 #if 0
1088                 flush_icache_range((target_ulong)rc,
1089                                    (target_ulong)(rc + 1));
1090 #endif
1091                 retcode = ((target_ulong)rc) + thumb;
1092         }
1093
1094         env->regs[0] = usig;
1095         env->regs[13] = h2g(frame);
1096         env->regs[14] = retcode;
1097         env->regs[15] = handler & (thumb ? ~1 : ~3);
1098
1099 #if 0
1100 #ifdef TARGET_CONFIG_CPU_32
1101         env->cpsr = cpsr;
1102 #endif
1103 #endif
1104
1105         return 0;
1106 }
1107
1108 static void setup_frame(int usig, struct emulated_sigaction *ka,
1109                         target_sigset_t *set, CPUState *regs)
1110 {
1111         struct sigframe *frame = get_sigframe(ka, regs, sizeof(*frame));
1112         int i, err = 0;
1113
1114         err |= setup_sigcontext(&frame->sc, /*&frame->fpstate,*/ regs, set->sig[0]);
1115
1116         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1117             if (__put_user(set->sig[i], &frame->extramask[i - 1]))
1118                 return;
1119         }
1120
1121         if (err == 0)
1122             err = setup_return(regs, ka, &frame->retcode, frame, usig);
1123         //      return err;
1124 }
1125
1126 static void setup_rt_frame(int usig, struct emulated_sigaction *ka,
1127                            target_siginfo_t *info,
1128                            target_sigset_t *set, CPUState *env)
1129 {
1130         struct rt_sigframe *frame = get_sigframe(ka, env, sizeof(*frame));
1131         int i, err = 0;
1132
1133         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
1134             return /* 1 */;
1135
1136         __put_user_error(&frame->info, (target_ulong *)&frame->pinfo, err);
1137         __put_user_error(&frame->uc, (target_ulong *)&frame->puc, err);
1138         err |= copy_siginfo_to_user(&frame->info, info);
1139
1140         /* Clear all the bits of the ucontext we don't use.  */
1141         memset(&frame->uc, 0, offsetof(struct target_ucontext, tuc_mcontext));
1142
1143         err |= setup_sigcontext(&frame->uc.tuc_mcontext, /*&frame->fpstate,*/
1144                                 env, set->sig[0]);
1145         for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1146             if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
1147                 return;
1148         }
1149
1150         if (err == 0)
1151                 err = setup_return(env, ka, &frame->retcode, frame, usig);
1152
1153         if (err == 0) {
1154                 /*
1155                  * For realtime signals we must also set the second and third
1156                  * arguments for the signal handler.
1157                  *   -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
1158                  */
1159             env->regs[1] = (target_ulong)frame->pinfo;
1160             env->regs[2] = (target_ulong)frame->puc;
1161         }
1162
1163         //      return err;
1164 }
1165
1166 static int
1167 restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
1168 {
1169         int err = 0;
1170         uint32_t cpsr;
1171
1172         __get_user_error(env->regs[0], &sc->arm_r0, err);
1173         __get_user_error(env->regs[1], &sc->arm_r1, err);
1174         __get_user_error(env->regs[2], &sc->arm_r2, err);
1175         __get_user_error(env->regs[3], &sc->arm_r3, err);
1176         __get_user_error(env->regs[4], &sc->arm_r4, err);
1177         __get_user_error(env->regs[5], &sc->arm_r5, err);
1178         __get_user_error(env->regs[6], &sc->arm_r6, err);
1179         __get_user_error(env->regs[7], &sc->arm_r7, err);
1180         __get_user_error(env->regs[8], &sc->arm_r8, err);
1181         __get_user_error(env->regs[9], &sc->arm_r9, err);
1182         __get_user_error(env->regs[10], &sc->arm_r10, err);
1183         __get_user_error(env->regs[11], &sc->arm_fp, err);
1184         __get_user_error(env->regs[12], &sc->arm_ip, err);
1185         __get_user_error(env->regs[13], &sc->arm_sp, err);
1186         __get_user_error(env->regs[14], &sc->arm_lr, err);
1187         __get_user_error(env->regs[15], &sc->arm_pc, err);
1188 #ifdef TARGET_CONFIG_CPU_32
1189         __get_user_error(cpsr, &sc->arm_cpsr, err);
1190         cpsr_write(env, cpsr, 0xffffffff);
1191 #endif
1192
1193         err |= !valid_user_regs(env);
1194
1195         return err;
1196 }
1197
1198 long do_sigreturn(CPUState *env)
1199 {
1200         struct sigframe *frame;
1201         target_sigset_t set;
1202         sigset_t host_set;
1203         int i;
1204
1205         /*
1206          * Since we stacked the signal on a 64-bit boundary,
1207          * then 'sp' should be word aligned here.  If it's
1208          * not, then the user is trying to mess with us.
1209          */
1210         if (env->regs[13] & 7)
1211                 goto badframe;
1212
1213         frame = (struct sigframe *)g2h(env->regs[13]);
1214
1215 #if 0
1216         if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
1217                 goto badframe;
1218 #endif
1219         if (__get_user(set.sig[0], &frame->sc.oldmask))
1220             goto badframe;
1221         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1222             if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1223                 goto badframe;
1224         }
1225
1226         target_to_host_sigset_internal(&host_set, &set);
1227         sigprocmask(SIG_SETMASK, &host_set, NULL);
1228
1229         if (restore_sigcontext(env, &frame->sc))
1230                 goto badframe;
1231
1232 #if 0
1233         /* Send SIGTRAP if we're single-stepping */
1234         if (ptrace_cancel_bpt(current))
1235                 send_sig(SIGTRAP, current, 1);
1236 #endif
1237         return env->regs[0];
1238
1239 badframe:
1240         force_sig(SIGSEGV /* , current */);
1241         return 0;
1242 }
1243
1244 long do_rt_sigreturn(CPUState *env)
1245 {
1246         struct rt_sigframe *frame;
1247         sigset_t host_set;
1248
1249         /*
1250          * Since we stacked the signal on a 64-bit boundary,
1251          * then 'sp' should be word aligned here.  If it's
1252          * not, then the user is trying to mess with us.
1253          */
1254         if (env->regs[13] & 7)
1255                 goto badframe;
1256
1257         frame = (struct rt_sigframe *)env->regs[13];
1258
1259 #if 0
1260         if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
1261                 goto badframe;
1262 #endif
1263         target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
1264         sigprocmask(SIG_SETMASK, &host_set, NULL);
1265
1266         if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
1267                 goto badframe;
1268
1269 #if 0
1270         /* Send SIGTRAP if we're single-stepping */
1271         if (ptrace_cancel_bpt(current))
1272                 send_sig(SIGTRAP, current, 1);
1273 #endif
1274         return env->regs[0];
1275
1276 badframe:
1277         force_sig(SIGSEGV /* , current */);
1278         return 0;
1279 }
1280
1281 #elif defined(TARGET_SPARC)
1282
1283 #define __SUNOS_MAXWIN   31
1284
1285 /* This is what SunOS does, so shall I. */
1286 struct target_sigcontext {
1287         target_ulong sigc_onstack;      /* state to restore */
1288
1289         target_ulong sigc_mask;         /* sigmask to restore */
1290         target_ulong sigc_sp;           /* stack pointer */
1291         target_ulong sigc_pc;           /* program counter */
1292         target_ulong sigc_npc;          /* next program counter */
1293         target_ulong sigc_psr;          /* for condition codes etc */
1294         target_ulong sigc_g1;           /* User uses these two registers */
1295         target_ulong sigc_o0;           /* within the trampoline code. */
1296
1297         /* Now comes information regarding the users window set
1298          * at the time of the signal.
1299          */
1300         target_ulong sigc_oswins;       /* outstanding windows */
1301
1302         /* stack ptrs for each regwin buf */
1303         char *sigc_spbuf[__SUNOS_MAXWIN];
1304
1305         /* Windows to restore after signal */
1306         struct {
1307                 target_ulong locals[8];
1308                 target_ulong ins[8];
1309         } sigc_wbuf[__SUNOS_MAXWIN];
1310 };
1311 /* A Sparc stack frame */
1312 struct sparc_stackf {
1313         target_ulong locals[8];
1314         target_ulong ins[6];
1315         struct sparc_stackf *fp;
1316         target_ulong callers_pc;
1317         char *structptr;
1318         target_ulong xargs[6];
1319         target_ulong xxargs[1];
1320 };
1321
1322 typedef struct {
1323         struct {
1324                 target_ulong psr;
1325                 target_ulong pc;
1326                 target_ulong npc;
1327                 target_ulong y;
1328                 target_ulong u_regs[16]; /* globals and ins */
1329         }               si_regs;
1330         int             si_mask;
1331 } __siginfo_t;
1332
1333 typedef struct {
1334         unsigned   long si_float_regs [32];
1335         unsigned   long si_fsr;
1336         unsigned   long si_fpqdepth;
1337         struct {
1338                 unsigned long *insn_addr;
1339                 unsigned long insn;
1340         } si_fpqueue [16];
1341 } qemu_siginfo_fpu_t;
1342
1343
1344 struct target_signal_frame {
1345         struct sparc_stackf     ss;
1346         __siginfo_t             info;
1347         qemu_siginfo_fpu_t      *fpu_save;
1348         target_ulong            insns[2] __attribute__ ((aligned (8)));
1349         target_ulong            extramask[TARGET_NSIG_WORDS - 1];
1350         target_ulong            extra_size; /* Should be 0 */
1351         qemu_siginfo_fpu_t      fpu_state;
1352 };
1353 struct target_rt_signal_frame {
1354         struct sparc_stackf     ss;
1355         siginfo_t               info;
1356         target_ulong            regs[20];
1357         sigset_t                mask;
1358         qemu_siginfo_fpu_t      *fpu_save;
1359         unsigned int            insns[2];
1360         stack_t                 stack;
1361         unsigned int            extra_size; /* Should be 0 */
1362         qemu_siginfo_fpu_t      fpu_state;
1363 };
1364
1365 #define UREG_O0        16
1366 #define UREG_O6        22
1367 #define UREG_I0        0
1368 #define UREG_I1        1
1369 #define UREG_I2        2
1370 #define UREG_I6        6
1371 #define UREG_I7        7
1372 #define UREG_L0        8
1373 #define UREG_FP        UREG_I6
1374 #define UREG_SP        UREG_O6
1375
1376 static inline void *get_sigframe(struct emulated_sigaction *sa, CPUState *env, unsigned long framesize)
1377 {
1378         unsigned long sp;
1379
1380         sp = env->regwptr[UREG_FP];
1381 #if 0
1382
1383         /* This is the X/Open sanctioned signal stack switching.  */
1384         if (sa->sa_flags & TARGET_SA_ONSTACK) {
1385                 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
1386                         sp = current->sas_ss_sp + current->sas_ss_size;
1387         }
1388 #endif
1389         return g2h(sp - framesize);
1390 }
1391
1392 static int
1393 setup___siginfo(__siginfo_t *si, CPUState *env, target_ulong mask)
1394 {
1395         int err = 0, i;
1396
1397         err |= __put_user(env->psr, &si->si_regs.psr);
1398         err |= __put_user(env->pc, &si->si_regs.pc);
1399         err |= __put_user(env->npc, &si->si_regs.npc);
1400         err |= __put_user(env->y, &si->si_regs.y);
1401         for (i=0; i < 8; i++) {
1402                 err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
1403         }
1404         for (i=0; i < 8; i++) {
1405                 err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
1406         }
1407         err |= __put_user(mask, &si->si_mask);
1408         return err;
1409 }
1410
1411 #if 0
1412 static int
1413 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1414                  CPUState *env, unsigned long mask)
1415 {
1416         int err = 0;
1417
1418         err |= __put_user(mask, &sc->sigc_mask);
1419         err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
1420         err |= __put_user(env->pc, &sc->sigc_pc);
1421         err |= __put_user(env->npc, &sc->sigc_npc);
1422         err |= __put_user(env->psr, &sc->sigc_psr);
1423         err |= __put_user(env->gregs[1], &sc->sigc_g1);
1424         err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
1425
1426         return err;
1427 }
1428 #endif
1429 #define NF_ALIGNEDSZ  (((sizeof(struct target_signal_frame) + 7) & (~7)))
1430
1431 static void setup_frame(int sig, struct emulated_sigaction *ka,
1432                         target_sigset_t *set, CPUState *env)
1433 {
1434         struct target_signal_frame *sf;
1435         int sigframe_size, err, i;
1436
1437         /* 1. Make sure everything is clean */
1438         //synchronize_user_stack();
1439
1440         sigframe_size = NF_ALIGNEDSZ;
1441
1442         sf = (struct target_signal_frame *)
1443                 get_sigframe(ka, env, sigframe_size);
1444
1445         //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1446 #if 0
1447         if (invalid_frame_pointer(sf, sigframe_size))
1448                 goto sigill_and_return;
1449 #endif
1450         /* 2. Save the current process state */
1451         err = setup___siginfo(&sf->info, env, set->sig[0]);
1452         err |= __put_user(0, &sf->extra_size);
1453
1454         //err |= save_fpu_state(regs, &sf->fpu_state);
1455         //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1456
1457         err |= __put_user(set->sig[0], &sf->info.si_mask);
1458         for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1459                 err |= __put_user(set->sig[i + 1], &sf->extramask[i]);
1460         }
1461
1462         for (i = 0; i < 8; i++) {
1463                 err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
1464         }
1465         for (i = 0; i < 8; i++) {
1466                 err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
1467         }
1468         if (err)
1469                 goto sigsegv;
1470
1471         /* 3. signal handler back-trampoline and parameters */
1472         env->regwptr[UREG_FP] = h2g(sf);
1473         env->regwptr[UREG_I0] = sig;
1474         env->regwptr[UREG_I1] = h2g(&sf->info);
1475         env->regwptr[UREG_I2] = h2g(&sf->info);
1476
1477         /* 4. signal handler */
1478         env->pc = (unsigned long) ka->sa._sa_handler;
1479         env->npc = (env->pc + 4);
1480         /* 5. return to kernel instructions */
1481         if (ka->sa.sa_restorer)
1482                 env->regwptr[UREG_I7] = (unsigned long)ka->sa.sa_restorer;
1483         else {
1484                 env->regwptr[UREG_I7] = h2g(&(sf->insns[0]) - 2);
1485
1486                 /* mov __NR_sigreturn, %g1 */
1487                 err |= __put_user(0x821020d8, &sf->insns[0]);
1488
1489                 /* t 0x10 */
1490                 err |= __put_user(0x91d02010, &sf->insns[1]);
1491                 if (err)
1492                         goto sigsegv;
1493
1494                 /* Flush instruction space. */
1495                 //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
1496                 //              tb_flush(env);
1497         }
1498         return;
1499
1500         //sigill_and_return:
1501         force_sig(TARGET_SIGILL);
1502 sigsegv:
1503         //fprintf(stderr, "force_sig\n");
1504         force_sig(TARGET_SIGSEGV);
1505 }
1506 static inline int
1507 restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu)
1508 {
1509         int err;
1510 #if 0
1511 #ifdef CONFIG_SMP
1512         if (current->flags & PF_USEDFPU)
1513                 regs->psr &= ~PSR_EF;
1514 #else
1515         if (current == last_task_used_math) {
1516                 last_task_used_math = 0;
1517                 regs->psr &= ~PSR_EF;
1518         }
1519 #endif
1520         current->used_math = 1;
1521         current->flags &= ~PF_USEDFPU;
1522 #endif
1523 #if 0
1524         if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
1525                 return -EFAULT;
1526 #endif
1527
1528 #if 0
1529         /* XXX: incorrect */
1530         err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0],
1531                                      (sizeof(unsigned long) * 32));
1532 #endif
1533         err |= __get_user(env->fsr, &fpu->si_fsr);
1534 #if 0
1535         err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
1536         if (current->thread.fpqdepth != 0)
1537                 err |= __copy_from_user(&current->thread.fpqueue[0],
1538                                         &fpu->si_fpqueue[0],
1539                                         ((sizeof(unsigned long) +
1540                                         (sizeof(unsigned long *)))*16));
1541 #endif
1542         return err;
1543 }
1544
1545
1546 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1547                            target_siginfo_t *info,
1548                            target_sigset_t *set, CPUState *env)
1549 {
1550     fprintf(stderr, "setup_rt_frame: not implemented\n");
1551 }
1552
1553 long do_sigreturn(CPUState *env)
1554 {
1555         struct target_signal_frame *sf;
1556         uint32_t up_psr, pc, npc;
1557         target_sigset_t set;
1558         sigset_t host_set;
1559         target_ulong fpu_save;
1560         int err, i;
1561
1562         sf = (struct target_signal_frame *)g2h(env->regwptr[UREG_FP]);
1563 #if 0
1564         fprintf(stderr, "sigreturn\n");
1565         fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1566 #endif
1567         //cpu_dump_state(env, stderr, fprintf, 0);
1568
1569         /* 1. Make sure we are not getting garbage from the user */
1570 #if 0
1571         if (verify_area (VERIFY_READ, sf, sizeof (*sf)))
1572                 goto segv_and_exit;
1573 #endif
1574
1575         if (((uint) sf) & 3)
1576                 goto segv_and_exit;
1577
1578         err = __get_user(pc,  &sf->info.si_regs.pc);
1579         err |= __get_user(npc, &sf->info.si_regs.npc);
1580
1581         if ((pc | npc) & 3)
1582                 goto segv_and_exit;
1583
1584         /* 2. Restore the state */
1585         err |= __get_user(up_psr, &sf->info.si_regs.psr);
1586
1587         /* User can only change condition codes and FPU enabling in %psr. */
1588         env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
1589                   | (env->psr & ~(PSR_ICC /* | PSR_EF */));
1590
1591         env->pc = pc;
1592         env->npc = npc;
1593         err |= __get_user(env->y, &sf->info.si_regs.y);
1594         for (i=0; i < 8; i++) {
1595                 err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
1596         }
1597         for (i=0; i < 8; i++) {
1598                 err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
1599         }
1600
1601         err |= __get_user(fpu_save, (target_ulong *)&sf->fpu_save);
1602
1603         //if (fpu_save)
1604         //        err |= restore_fpu_state(env, fpu_save);
1605
1606         /* This is pretty much atomic, no amount locking would prevent
1607          * the races which exist anyways.
1608          */
1609         err |= __get_user(set.sig[0], &sf->info.si_mask);
1610         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1611             err |= (__get_user(set.sig[i], &sf->extramask[i - 1]));
1612         }
1613
1614         target_to_host_sigset_internal(&host_set, &set);
1615         sigprocmask(SIG_SETMASK, &host_set, NULL);
1616
1617         if (err)
1618                 goto segv_and_exit;
1619
1620         return env->regwptr[0];
1621
1622 segv_and_exit:
1623         force_sig(TARGET_SIGSEGV);
1624 }
1625
1626 long do_rt_sigreturn(CPUState *env)
1627 {
1628     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1629     return -ENOSYS;
1630 }
1631
1632 #elif defined(TARGET_MIPS)
1633
1634 struct target_sigcontext {
1635     uint32_t   sc_regmask;     /* Unused */
1636     uint32_t   sc_status;
1637     uint64_t   sc_pc;
1638     uint64_t   sc_regs[32];
1639     uint64_t   sc_fpregs[32];
1640     uint32_t   sc_ownedfp;     /* Unused */
1641     uint32_t   sc_fpc_csr;
1642     uint32_t   sc_fpc_eir;     /* Unused */
1643     uint32_t   sc_used_math;
1644     uint32_t   sc_dsp;         /* dsp status, was sc_ssflags */
1645     uint64_t   sc_mdhi;
1646     uint64_t   sc_mdlo;
1647     target_ulong   sc_hi1;         /* Was sc_cause */
1648     target_ulong   sc_lo1;         /* Was sc_badvaddr */
1649     target_ulong   sc_hi2;         /* Was sc_sigset[4] */
1650     target_ulong   sc_lo2;
1651     target_ulong   sc_hi3;
1652     target_ulong   sc_lo3;
1653 };
1654
1655 struct sigframe {
1656     uint32_t sf_ass[4];                 /* argument save space for o32 */
1657     uint32_t sf_code[2];                        /* signal trampoline */
1658     struct target_sigcontext sf_sc;
1659     target_sigset_t sf_mask;
1660 };
1661
1662 /* Install trampoline to jump back from signal handler */
1663 static inline int install_sigtramp(unsigned int *tramp,   unsigned int syscall)
1664 {
1665     int err;
1666
1667     /*
1668     * Set up the return code ...
1669     *
1670     *         li      v0, __NR__foo_sigreturn
1671     *         syscall
1672     */
1673
1674     err = __put_user(0x24020000 + syscall, tramp + 0);
1675     err |= __put_user(0x0000000c          , tramp + 1);
1676     /* flush_cache_sigtramp((unsigned long) tramp); */
1677     return err;
1678 }
1679
1680 static inline int
1681 setup_sigcontext(CPUState *regs, struct target_sigcontext *sc)
1682 {
1683     int err = 0;
1684
1685     err |= __put_user(regs->PC, &sc->sc_pc);
1686
1687 #define save_gp_reg(i) do {                                     \
1688         err |= __put_user(regs->gpr[i], &sc->sc_regs[i]);       \
1689     } while(0)
1690     __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
1691     save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
1692     save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
1693     save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
1694     save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
1695     save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
1696     save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
1697     save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
1698     save_gp_reg(31);
1699 #undef save_gp_reg
1700
1701     err |= __put_user(regs->HI, &sc->sc_mdhi);
1702     err |= __put_user(regs->LO, &sc->sc_mdlo);
1703
1704     /* Not used yet, but might be useful if we ever have DSP suppport */
1705 #if 0
1706     if (cpu_has_dsp) {
1707         err |= __put_user(mfhi1(), &sc->sc_hi1);
1708         err |= __put_user(mflo1(), &sc->sc_lo1);
1709         err |= __put_user(mfhi2(), &sc->sc_hi2);
1710         err |= __put_user(mflo2(), &sc->sc_lo2);
1711         err |= __put_user(mfhi3(), &sc->sc_hi3);
1712         err |= __put_user(mflo3(), &sc->sc_lo3);
1713         err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
1714     }
1715     /* same with 64 bit */
1716 #ifdef CONFIG_64BIT
1717     err |= __put_user(regs->hi, &sc->sc_hi[0]);
1718     err |= __put_user(regs->lo, &sc->sc_lo[0]);
1719     if (cpu_has_dsp) {
1720         err |= __put_user(mfhi1(), &sc->sc_hi[1]);
1721         err |= __put_user(mflo1(), &sc->sc_lo[1]);
1722         err |= __put_user(mfhi2(), &sc->sc_hi[2]);
1723         err |= __put_user(mflo2(), &sc->sc_lo[2]);
1724         err |= __put_user(mfhi3(), &sc->sc_hi[3]);
1725         err |= __put_user(mflo3(), &sc->sc_lo[3]);
1726         err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
1727     }
1728 #endif
1729 #endif
1730
1731 #if 0
1732     err |= __put_user(!!used_math(), &sc->sc_used_math);
1733
1734     if (!used_math())
1735         goto out;
1736
1737     /*
1738     * Save FPU state to signal context.  Signal handler will "inherit"
1739     * current FPU state.
1740     */
1741     preempt_disable();
1742
1743     if (!is_fpu_owner()) {
1744         own_fpu();
1745         restore_fp(current);
1746     }
1747     err |= save_fp_context(sc);
1748
1749     preempt_enable();
1750     out:
1751 #endif
1752     return err;
1753 }
1754
1755 static inline int
1756 restore_sigcontext(CPUState *regs, struct target_sigcontext *sc)
1757 {
1758     int err = 0;
1759
1760     err |= __get_user(regs->CP0_EPC, &sc->sc_pc);
1761
1762     err |= __get_user(regs->HI, &sc->sc_mdhi);
1763     err |= __get_user(regs->LO, &sc->sc_mdlo);
1764
1765 #define restore_gp_reg(i) do {                                          \
1766         err |= __get_user(regs->gpr[i], &sc->sc_regs[i]);               \
1767     } while(0)
1768     restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
1769     restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
1770     restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
1771     restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
1772     restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
1773     restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
1774     restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
1775     restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
1776     restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
1777     restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
1778     restore_gp_reg(31);
1779 #undef restore_gp_reg
1780
1781 #if 0
1782     if (cpu_has_dsp) {
1783         err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
1784         err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
1785         err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
1786         err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
1787         err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
1788         err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
1789         err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
1790     }
1791 #ifdef CONFIG_64BIT
1792     err |= __get_user(regs->hi, &sc->sc_hi[0]);
1793     err |= __get_user(regs->lo, &sc->sc_lo[0]);
1794     if (cpu_has_dsp) {
1795         err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg);
1796         err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg);
1797         err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg);
1798         err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg);
1799         err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg);
1800         err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg);
1801         err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
1802     }
1803 #endif
1804
1805     err |= __get_user(used_math, &sc->sc_used_math);
1806     conditional_used_math(used_math);
1807
1808     preempt_disable();
1809
1810     if (used_math()) {
1811         /* restore fpu context if we have used it before */
1812         own_fpu();
1813         err |= restore_fp_context(sc);
1814     } else {
1815         /* signal handler may have used FPU.  Give it up. */
1816         lose_fpu();
1817     }
1818
1819     preempt_enable();
1820 #endif
1821     return err;
1822 }
1823 /*
1824  * Determine which stack to use..
1825  */
1826 static inline void *
1827 get_sigframe(struct emulated_sigaction *ka, CPUState *regs, size_t frame_size)
1828 {
1829     unsigned long sp;
1830
1831     /* Default to using normal stack */
1832     sp = regs->gpr[29];
1833
1834     /*
1835      * FPU emulator may have it's own trampoline active just
1836      * above the user stack, 16-bytes before the next lowest
1837      * 16 byte boundary.  Try to avoid trashing it.
1838      */
1839     sp -= 32;
1840
1841 #if 0
1842     /* This is the X/Open sanctioned signal stack switching.  */
1843     if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
1844         sp = current->sas_ss_sp + current->sas_ss_size;
1845 #endif
1846
1847     return g2h((sp - frame_size) & ~7);
1848 }
1849
1850 static void setup_frame(int sig, struct emulated_sigaction * ka,
1851                 target_sigset_t *set, CPUState *regs)
1852 {
1853     struct sigframe *frame;
1854     int i;
1855
1856     frame = get_sigframe(ka, regs, sizeof(*frame));
1857     if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
1858         goto give_sigsegv;
1859
1860     install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
1861
1862     if(setup_sigcontext(regs, &frame->sf_sc))
1863         goto give_sigsegv;
1864
1865     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1866         if(__put_user(set->sig[i], &frame->sf_mask.sig[i]))
1867             goto give_sigsegv;
1868     }
1869
1870     /*
1871     * Arguments to signal handler:
1872     *
1873     *   a0 = signal number
1874     *   a1 = 0 (should be cause)
1875     *   a2 = pointer to struct sigcontext
1876     *
1877     * $25 and PC point to the signal handler, $29 points to the
1878     * struct sigframe.
1879     */
1880     regs->gpr[ 4] = sig;
1881     regs->gpr[ 5] = 0;
1882     regs->gpr[ 6] = h2g(&frame->sf_sc);
1883     regs->gpr[29] = h2g(frame);
1884     regs->gpr[31] = h2g(frame->sf_code);
1885     /* The original kernel code sets CP0_EPC to the handler
1886     * since it returns to userland using eret
1887     * we cannot do this here, and we must set PC directly */
1888     regs->PC = regs->gpr[25] = ka->sa._sa_handler;
1889     return;
1890
1891 give_sigsegv:
1892     force_sig(TARGET_SIGSEGV/*, current*/);
1893     return;
1894 }
1895
1896 long do_sigreturn(CPUState *regs)
1897 {
1898     struct sigframe *frame;
1899     sigset_t blocked;
1900     target_sigset_t target_set;
1901     int i;
1902
1903 #if defined(DEBUG_SIGNAL)
1904     fprintf(stderr, "do_sigreturn\n");
1905 #endif
1906     frame = (struct sigframe *) regs->gpr[29];
1907     if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
1908         goto badframe;
1909
1910     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1911         if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i]))
1912             goto badframe;
1913     }
1914
1915     target_to_host_sigset_internal(&blocked, &target_set);
1916     sigprocmask(SIG_SETMASK, &blocked, NULL);
1917
1918     if (restore_sigcontext(regs, &frame->sf_sc))
1919         goto badframe;
1920
1921 #if 0
1922     /*
1923      * Don't let your children do this ...
1924      */
1925     __asm__ __volatile__(
1926         "move\t$29, %0\n\t"
1927         "j\tsyscall_exit"
1928         :/* no outputs */
1929         :"r" (&regs));
1930     /* Unreached */
1931 #endif
1932
1933     regs->PC = regs->CP0_EPC;
1934     /* I am not sure this is right, but it seems to work
1935     * maybe a problem with nested signals ? */
1936     regs->CP0_EPC = 0;
1937     return 0;
1938
1939 badframe:
1940     force_sig(TARGET_SIGSEGV/*, current*/);
1941     return 0;
1942 }
1943
1944 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1945                            target_siginfo_t *info,
1946                            target_sigset_t *set, CPUState *env)
1947 {
1948     fprintf(stderr, "setup_rt_frame: not implemented\n");
1949 }
1950
1951 long do_rt_sigreturn(CPUState *env)
1952 {
1953     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1954     return -ENOSYS;
1955 }
1956
1957 #else
1958
1959 static void setup_frame(int sig, struct emulated_sigaction *ka,
1960                         target_sigset_t *set, CPUState *env)
1961 {
1962     fprintf(stderr, "setup_frame: not implemented\n");
1963 }
1964
1965 static void setup_rt_frame(int sig, struct emulated_sigaction *ka,
1966                            target_siginfo_t *info,
1967                            target_sigset_t *set, CPUState *env)
1968 {
1969     fprintf(stderr, "setup_rt_frame: not implemented\n");
1970 }
1971
1972 long do_sigreturn(CPUState *env)
1973 {
1974     fprintf(stderr, "do_sigreturn: not implemented\n");
1975     return -ENOSYS;
1976 }
1977
1978 long do_rt_sigreturn(CPUState *env)
1979 {
1980     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1981     return -ENOSYS;
1982 }
1983
1984 #endif
1985
1986 void process_pending_signals(void *cpu_env)
1987 {
1988     int sig;
1989     target_ulong handler;
1990     sigset_t set, old_set;
1991     target_sigset_t target_old_set;
1992     struct emulated_sigaction *k;
1993     struct sigqueue *q;
1994
1995     if (!signal_pending)
1996         return;
1997
1998     k = sigact_table;
1999     for(sig = 1; sig <= TARGET_NSIG; sig++) {
2000         if (k->pending)
2001             goto handle_signal;
2002         k++;
2003     }
2004     /* if no signal is pending, just return */
2005     signal_pending = 0;
2006     return;
2007
2008  handle_signal:
2009 #ifdef DEBUG_SIGNAL
2010     fprintf(stderr, "qemu: process signal %d\n", sig);
2011 #endif
2012     /* dequeue signal */
2013     q = k->first;
2014     k->first = q->next;
2015     if (!k->first)
2016         k->pending = 0;
2017
2018     sig = gdb_handlesig (cpu_env, sig);
2019     if (!sig) {
2020         fprintf (stderr, "Lost signal\n");
2021         abort();
2022     }
2023
2024     handler = k->sa._sa_handler;
2025     if (handler == TARGET_SIG_DFL) {
2026         /* default handler : ignore some signal. The other are fatal */
2027         if (sig != TARGET_SIGCHLD &&
2028             sig != TARGET_SIGURG &&
2029             sig != TARGET_SIGWINCH) {
2030             force_sig(sig);
2031         }
2032     } else if (handler == TARGET_SIG_IGN) {
2033         /* ignore sig */
2034     } else if (handler == TARGET_SIG_ERR) {
2035         force_sig(sig);
2036     } else {
2037         /* compute the blocked signals during the handler execution */
2038         target_to_host_sigset(&set, &k->sa.sa_mask);
2039         /* SA_NODEFER indicates that the current signal should not be
2040            blocked during the handler */
2041         if (!(k->sa.sa_flags & TARGET_SA_NODEFER))
2042             sigaddset(&set, target_to_host_signal(sig));
2043
2044         /* block signals in the handler using Linux */
2045         sigprocmask(SIG_BLOCK, &set, &old_set);
2046         /* save the previous blocked signal state to restore it at the
2047            end of the signal execution (see do_sigreturn) */
2048         host_to_target_sigset_internal(&target_old_set, &old_set);
2049
2050         /* if the CPU is in VM86 mode, we restore the 32 bit values */
2051 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
2052         {
2053             CPUX86State *env = cpu_env;
2054             if (env->eflags & VM_MASK)
2055                 save_v86_state(env);
2056         }
2057 #endif
2058         /* prepare the stack frame of the virtual CPU */
2059         if (k->sa.sa_flags & TARGET_SA_SIGINFO)
2060             setup_rt_frame(sig, k, &q->info, &target_old_set, cpu_env);
2061         else
2062             setup_frame(sig, k, &target_old_set, cpu_env);
2063         if (k->sa.sa_flags & TARGET_SA_RESETHAND)
2064             k->sa._sa_handler = TARGET_SIG_DFL;
2065     }
2066     if (q != &k->info)
2067         free_sigqueue(q);
2068 }