Archipelago » qemu

/*

 *  Emulation of Linux signals

 *

 *  Copyright (c) 2003 Fabrice Bellard

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <stdarg.h>

#include <unistd.h>

#include <signal.h>

#include <errno.h>

#include <sys/ucontext.h>

#include "qemu.h"

#include "target_signal.h"

//#define DEBUG_SIGNAL

struct target_sigaltstack target_sigaltstack_used = {

    .ss_sp = 0,

    .ss_size = 0,

    .ss_flags = TARGET_SS_DISABLE,

};

static struct target_sigaction sigact_table[TARGET_NSIG];

static void host_signal_handler(int host_signum, siginfo_t *info,

                                void *puc);

static uint8_t host_to_target_signal_table[65] = {

    [SIGHUP] = TARGET_SIGHUP,

    [SIGINT] = TARGET_SIGINT,

    [SIGQUIT] = TARGET_SIGQUIT,

    [SIGILL] = TARGET_SIGILL,

    [SIGTRAP] = TARGET_SIGTRAP,

    [SIGABRT] = TARGET_SIGABRT,

/*    [SIGIOT] = TARGET_SIGIOT,*/

    [SIGBUS] = TARGET_SIGBUS,

    [SIGFPE] = TARGET_SIGFPE,

    [SIGKILL] = TARGET_SIGKILL,

    [SIGUSR1] = TARGET_SIGUSR1,

    [SIGSEGV] = TARGET_SIGSEGV,

    [SIGUSR2] = TARGET_SIGUSR2,

    [SIGPIPE] = TARGET_SIGPIPE,

    [SIGALRM] = TARGET_SIGALRM,

    [SIGTERM] = TARGET_SIGTERM,

#ifdef SIGSTKFLT

    [SIGSTKFLT] = TARGET_SIGSTKFLT,

#endif

    [SIGCHLD] = TARGET_SIGCHLD,

    [SIGCONT] = TARGET_SIGCONT,

    [SIGSTOP] = TARGET_SIGSTOP,

    [SIGTSTP] = TARGET_SIGTSTP,

    [SIGTTIN] = TARGET_SIGTTIN,

    [SIGTTOU] = TARGET_SIGTTOU,

    [SIGURG] = TARGET_SIGURG,

    [SIGXCPU] = TARGET_SIGXCPU,

    [SIGXFSZ] = TARGET_SIGXFSZ,

    [SIGVTALRM] = TARGET_SIGVTALRM,

    [SIGPROF] = TARGET_SIGPROF,

    [SIGWINCH] = TARGET_SIGWINCH,

    [SIGIO] = TARGET_SIGIO,

    [SIGPWR] = TARGET_SIGPWR,

    [SIGSYS] = TARGET_SIGSYS,

    /* next signals stay the same */

    /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with

       host libpthread signals.  This assumes noone actually uses SIGRTMAX :-/

       To fix this properly we need to do manual signal delivery multiplexed

       over a single host signal.  */

    [__SIGRTMIN] = __SIGRTMAX,

    [__SIGRTMAX] = __SIGRTMIN,

};

static uint8_t target_to_host_signal_table[65];

static inline int on_sig_stack(unsigned long sp)

{

    return (sp - target_sigaltstack_used.ss_sp

            < target_sigaltstack_used.ss_size);

}

static inline int sas_ss_flags(unsigned long sp)

{

    return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE

            : on_sig_stack(sp) ? SS_ONSTACK : 0);

}

static inline int host_to_target_signal(int sig)

{

    if (sig > 64)

        return sig;

    return host_to_target_signal_table[sig];

}

int target_to_host_signal(int sig)

{

    if (sig > 64)

        return sig;

    return target_to_host_signal_table[sig];

}

static inline void target_sigemptyset(target_sigset_t *set)

{

    memset(set, 0, sizeof(*set));

}

static inline void target_sigaddset(target_sigset_t *set, int signum)

{

    signum--;

    abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);

    set->sig[signum / TARGET_NSIG_BPW] |= mask;

}

static inline int target_sigismember(const target_sigset_t *set, int signum)

{

    signum--;

    abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);

    return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0);

}

static void host_to_target_sigset_internal(target_sigset_t *d,

                                           const sigset_t *s)

{

    int i;

    target_sigemptyset(d);

    for (i = 1; i <= TARGET_NSIG; i++) {

        if (sigismember(s, i)) {

            target_sigaddset(d, host_to_target_signal(i));

        }

    }

}

void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)

{

    target_sigset_t d1;

    int i;

    host_to_target_sigset_internal(&d1, s);

    for(i = 0;i < TARGET_NSIG_WORDS; i++)

        d->sig[i] = tswapl(d1.sig[i]);

}

static void target_to_host_sigset_internal(sigset_t *d,

                                           const target_sigset_t *s)

{

    int i;

    sigemptyset(d);

    for (i = 1; i <= TARGET_NSIG; i++) {

        if (target_sigismember(s, i)) {

            sigaddset(d, target_to_host_signal(i));

        }

     }

}

void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)

{

    target_sigset_t s1;

    int i;

    for(i = 0;i < TARGET_NSIG_WORDS; i++)

        s1.sig[i] = tswapl(s->sig[i]);

    target_to_host_sigset_internal(d, &s1);

}

void host_to_target_old_sigset(abi_ulong *old_sigset,

                               const sigset_t *sigset)

{

    target_sigset_t d;

    host_to_target_sigset(&d, sigset);

    *old_sigset = d.sig[0];

}

void target_to_host_old_sigset(sigset_t *sigset,

                               const abi_ulong *old_sigset)

{

    target_sigset_t d;

    int i;

    d.sig[0] = *old_sigset;

    for(i = 1;i < TARGET_NSIG_WORDS; i++)

        d.sig[i] = 0;

    target_to_host_sigset(sigset, &d);

}

/* siginfo conversion */

static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,

                                                 const siginfo_t *info)

{

    int sig;

    sig = host_to_target_signal(info->si_signo);

    tinfo->si_signo = sig;

    tinfo->si_errno = 0;

    tinfo->si_code = info->si_code;

    if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||

        sig == SIGBUS || sig == SIGTRAP) {

        /* should never come here, but who knows. The information for

           the target is irrelevant */

        tinfo->_sifields._sigfault._addr = 0;

    } else if (sig == SIGIO) {

        tinfo->_sifields._sigpoll._fd = info->si_fd;

    } else if (sig >= TARGET_SIGRTMIN) {

        tinfo->_sifields._rt._pid = info->si_pid;

        tinfo->_sifields._rt._uid = info->si_uid;

        /* XXX: potential problem if 64 bit */

        tinfo->_sifields._rt._sigval.sival_ptr =

            (abi_ulong)(unsigned long)info->si_value.sival_ptr;

    }

}

static void tswap_siginfo(target_siginfo_t *tinfo,

                          const target_siginfo_t *info)

{

    int sig;

    sig = info->si_signo;

    tinfo->si_signo = tswap32(sig);

    tinfo->si_errno = tswap32(info->si_errno);

    tinfo->si_code = tswap32(info->si_code);

    if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||

        sig == SIGBUS || sig == SIGTRAP) {

        tinfo->_sifields._sigfault._addr =

            tswapl(info->_sifields._sigfault._addr);

    } else if (sig == SIGIO) {

        tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd);

    } else if (sig >= TARGET_SIGRTMIN) {

        tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);

        tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);

        tinfo->_sifields._rt._sigval.sival_ptr =

            tswapl(info->_sifields._rt._sigval.sival_ptr);

    }

}

void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)

{

    host_to_target_siginfo_noswap(tinfo, info);

    tswap_siginfo(tinfo, tinfo);

}

/* XXX: we support only POSIX RT signals are used. */

/* XXX: find a solution for 64 bit (additional malloced data is needed) */

void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)

{

    info->si_signo = tswap32(tinfo->si_signo);

    info->si_errno = tswap32(tinfo->si_errno);

    info->si_code = tswap32(tinfo->si_code);

    info->si_pid = tswap32(tinfo->_sifields._rt._pid);

    info->si_uid = tswap32(tinfo->_sifields._rt._uid);

    info->si_value.sival_ptr =

            (void *)(long)tswapl(tinfo->_sifields._rt._sigval.sival_ptr);

}

void signal_init(void)

{

    struct sigaction act;

    struct sigaction oact;

    int i, j;

    int host_sig;

    /* generate signal conversion tables */

    for(i = 1; i <= 64; i++) {

        if (host_to_target_signal_table[i] == 0)

            host_to_target_signal_table[i] = i;

    }

    for(i = 1; i <= 64; i++) {

        j = host_to_target_signal_table[i];

        target_to_host_signal_table[j] = i;

    }

    /* set all host signal handlers. ALL signals are blocked during

       the handlers to serialize them. */

    memset(sigact_table, 0, sizeof(sigact_table));

    sigfillset(&act.sa_mask);

    act.sa_flags = SA_SIGINFO;

    act.sa_sigaction = host_signal_handler;

    for(i = 1; i <= TARGET_NSIG; i++) {

        host_sig = target_to_host_signal(i);

        sigaction(host_sig, NULL, &oact);

        if (oact.sa_sigaction == (void *)SIG_IGN) {

            sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;

        } else if (oact.sa_sigaction == (void *)SIG_DFL) {

            sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;

        }

        /* If there's already a handler installed then something has

           gone horribly wrong, so don't even try to handle that case.  */

        /* Install some handlers for our own use.  */

        if (host_sig == SIGSEGV || host_sig == SIGBUS) {

            sigaction(host_sig, &act, NULL);

        }

    }

}

/* signal queue handling */

static inline struct sigqueue *alloc_sigqueue(CPUState *env)

{

    TaskState *ts = env->opaque;

    struct sigqueue *q = ts->first_free;

    if (!q)

        return NULL;

    ts->first_free = q->next;

    return q;

}

static inline void free_sigqueue(CPUState *env, struct sigqueue *q)

{

    TaskState *ts = env->opaque;

    q->next = ts->first_free;

    ts->first_free = q;

}

/* abort execution with signal */

static void __attribute((noreturn)) force_sig(int sig)

{

    int host_sig;

    host_sig = target_to_host_signal(sig);

    fprintf(stderr, "qemu: uncaught target signal %d (%s) - exiting\n",

            sig, strsignal(host_sig));

#if 1

    _exit(-host_sig);

#else

    {

        struct sigaction act;

        sigemptyset(&act.sa_mask);

        act.sa_flags = SA_SIGINFO;

        act.sa_sigaction = SIG_DFL;

        sigaction(SIGABRT, &act, NULL);

        abort();

    }

#endif

}

/* queue a signal so that it will be send to the virtual CPU as soon

   as possible */

int queue_signal(CPUState *env, int sig, target_siginfo_t *info)

{

    TaskState *ts = env->opaque;

    struct emulated_sigtable *k;

    struct sigqueue *q, **pq;

    abi_ulong handler;

#if defined(DEBUG_SIGNAL)

    fprintf(stderr, "queue_signal: sig=%d\n",

            sig);

#endif

    k = &ts->sigtab[sig - 1];

    handler = sigact_table[sig - 1]._sa_handler;

    if (handler == TARGET_SIG_DFL) {

        /* default handler : ignore some signal. The other are fatal */

        if (sig != TARGET_SIGCHLD &&

            sig != TARGET_SIGURG &&

            sig != TARGET_SIGWINCH) {

            force_sig(sig);

        } else {

            return 0; /* indicate ignored */

        }

    } else if (handler == TARGET_SIG_IGN) {

        /* ignore signal */

        return 0;

    } else if (handler == TARGET_SIG_ERR) {

        force_sig(sig);

    } else {

        pq = &k->first;

        if (sig < TARGET_SIGRTMIN) {

            /* if non real time signal, we queue exactly one signal */

            if (!k->pending)

                q = &k->info;

            else

                return 0;

        } else {

            if (!k->pending) {

                /* first signal */

                q = &k->info;

            } else {

                q = alloc_sigqueue(env);

                if (!q)

                    return -EAGAIN;

                while (*pq != NULL)

                    pq = &(*pq)->next;

            }

        }

        *pq = q;

        q->info = *info;

        q->next = NULL;

        k->pending = 1;

        /* signal that a new signal is pending */

        ts->signal_pending = 1;

        return 1; /* indicates that the signal was queued */

    }

}

static void host_signal_handler(int host_signum, siginfo_t *info,

                                void *puc)

{

    int sig;

    target_siginfo_t tinfo;

    /* the CPU emulator uses some host signals to detect exceptions,

       we we forward to it some signals */

    if (host_signum == SIGSEGV || host_signum == SIGBUS) {

        if (cpu_signal_handler(host_signum, info, puc))

            return;

    }

    /* get target signal number */

    sig = host_to_target_signal(host_signum);

    if (sig < 1 || sig > TARGET_NSIG)

        return;

#if defined(DEBUG_SIGNAL)

    fprintf(stderr, "qemu: got signal %d\n", sig);

#endif

    host_to_target_siginfo_noswap(&tinfo, info);

    if (queue_signal(thread_env, sig, &tinfo) == 1) {

        /* interrupt the virtual CPU as soon as possible */

        cpu_interrupt(thread_env, CPU_INTERRUPT_EXIT);

    }

}

/* do_sigaltstack() returns target values and errnos. */

/* compare linux/kernel/signal.c:do_sigaltstack() */

abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp)

{

    int ret;

    struct target_sigaltstack oss;

    /* XXX: test errors */

    if(uoss_addr)

    {

        __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp);

        __put_user(target_sigaltstack_used.ss_size, &oss.ss_size);

        __put_user(sas_ss_flags(sp), &oss.ss_flags);

    }

    if(uss_addr)

    {

        struct target_sigaltstack *uss;

        struct target_sigaltstack ss;

        ret = -TARGET_EFAULT;

        if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)

            || __get_user(ss.ss_sp, &uss->ss_sp)

            || __get_user(ss.ss_size, &uss->ss_size)

            || __get_user(ss.ss_flags, &uss->ss_flags))

            goto out;

        unlock_user_struct(uss, uss_addr, 0);

        ret = -TARGET_EPERM;

        if (on_sig_stack(sp))

            goto out;

        ret = -TARGET_EINVAL;

        if (ss.ss_flags != TARGET_SS_DISABLE

            && ss.ss_flags != TARGET_SS_ONSTACK

            && ss.ss_flags != 0)

            goto out;

        if (ss.ss_flags == TARGET_SS_DISABLE) {

            ss.ss_size = 0;

            ss.ss_sp = 0;

        } else {

            ret = -TARGET_ENOMEM;

            if (ss.ss_size < MINSIGSTKSZ)

                goto out;

        }

        target_sigaltstack_used.ss_sp = ss.ss_sp;

        target_sigaltstack_used.ss_size = ss.ss_size;

    }

    if (uoss_addr) {

        ret = -TARGET_EFAULT;

        if (copy_to_user(uoss_addr, &oss, sizeof(oss)))

            goto out;

    }

    ret = 0;

out:

    return ret;

}

/* do_sigaction() return host values and errnos */

int do_sigaction(int sig, const struct target_sigaction *act,

                 struct target_sigaction *oact)

{

    struct target_sigaction *k;

    struct sigaction act1;

    int host_sig;

    int ret = 0;

    if (sig < 1 || sig > TARGET_NSIG || sig == SIGKILL || sig == SIGSTOP)

        return -EINVAL;

    k = &sigact_table[sig - 1];

#if defined(DEBUG_SIGNAL)

    fprintf(stderr, "sigaction sig=%d act=0x%08x, oact=0x%08x\n",

            sig, (int)act, (int)oact);

#endif

    if (oact) {

        oact->_sa_handler = tswapl(k->_sa_handler);

        oact->sa_flags = tswapl(k->sa_flags);

#if !defined(TARGET_MIPS)

        oact->sa_restorer = tswapl(k->sa_restorer);

#endif

        oact->sa_mask = k->sa_mask;

    }

    if (act) {

        /* FIXME: This is not threadsafe.  */

        k->_sa_handler = tswapl(act->_sa_handler);

        k->sa_flags = tswapl(act->sa_flags);

#if !defined(TARGET_MIPS)

        k->sa_restorer = tswapl(act->sa_restorer);

#endif

        k->sa_mask = act->sa_mask;

        /* we update the host linux signal state */

        host_sig = target_to_host_signal(sig);

        if (host_sig != SIGSEGV && host_sig != SIGBUS) {

            sigfillset(&act1.sa_mask);

            act1.sa_flags = SA_SIGINFO;

            if (k->sa_flags & TARGET_SA_RESTART)

                act1.sa_flags |= SA_RESTART;

            /* NOTE: it is important to update the host kernel signal

               ignore state to avoid getting unexpected interrupted

               syscalls */

            if (k->_sa_handler == TARGET_SIG_IGN) {

                act1.sa_sigaction = (void *)SIG_IGN;

            } else if (k->_sa_handler == TARGET_SIG_DFL) {

                act1.sa_sigaction = (void *)SIG_DFL;

            } else {

                act1.sa_sigaction = host_signal_handler;

            }

            ret = sigaction(host_sig, &act1, NULL);

        }

    }

    return ret;

}

#ifndef offsetof

#define offsetof(type, field) ((size_t) &((type *)0)->field)

#endif

static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,

                                       const target_siginfo_t *info)

{

    tswap_siginfo(tinfo, info);

    return 0;

}

static inline int current_exec_domain_sig(int sig)

{

    return /* current->exec_domain && current->exec_domain->signal_invmap

              && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig;

}

#if defined(TARGET_I386) && TARGET_ABI_BITS == 32

/* from the Linux kernel */

struct target_fpreg {

        uint16_t significand[4];

        uint16_t exponent;

};

struct target_fpxreg {

        uint16_t significand[4];

        uint16_t exponent;

        uint16_t padding[3];

};

struct target_xmmreg {

        abi_ulong element[4];

};

struct target_fpstate {

        /* Regular FPU environment */

        abi_ulong       cw;

        abi_ulong       sw;

        abi_ulong       tag;

        abi_ulong       ipoff;

        abi_ulong       cssel;

        abi_ulong       dataoff;

        abi_ulong       datasel;

        struct target_fpreg        _st[8];

        uint16_t        status;

        uint16_t        magic;                /* 0xffff = regular FPU data only */

        /* FXSR FPU environment */

        abi_ulong       _fxsr_env[6];   /* FXSR FPU env is ignored */

        abi_ulong       mxcsr;

        abi_ulong       reserved;

        struct target_fpxreg        _fxsr_st[8];        /* FXSR FPU reg data is ignored */

        struct target_xmmreg        _xmm[8];

        abi_ulong       padding[56];

};

#define X86_FXSR_MAGIC                0x0000

struct target_sigcontext {

        uint16_t gs, __gsh;

        uint16_t fs, __fsh;

        uint16_t es, __esh;

        uint16_t ds, __dsh;

        abi_ulong edi;

        abi_ulong esi;

        abi_ulong ebp;

        abi_ulong esp;

        abi_ulong ebx;

        abi_ulong edx;

        abi_ulong ecx;

        abi_ulong eax;

        abi_ulong trapno;

        abi_ulong err;

        abi_ulong eip;

        uint16_t cs, __csh;

        abi_ulong eflags;

        abi_ulong esp_at_signal;

        uint16_t ss, __ssh;

        abi_ulong fpstate; /* pointer */

        abi_ulong oldmask;

        abi_ulong cr2;

};

struct target_ucontext {

        abi_ulong         tuc_flags;

        abi_ulong         tuc_link;

        target_stack_t          tuc_stack;

        struct target_sigcontext tuc_mcontext;

        target_sigset_t          tuc_sigmask;        /* mask last for extensibility */

};

struct sigframe

{

    abi_ulong pretcode;

    int sig;

    struct target_sigcontext sc;

    struct target_fpstate fpstate;

    abi_ulong extramask[TARGET_NSIG_WORDS-1];

    char retcode[8];

};

struct rt_sigframe

{

    abi_ulong pretcode;

    int sig;

    abi_ulong pinfo;

    abi_ulong puc;

    struct target_siginfo info;

    struct target_ucontext uc;

    struct target_fpstate fpstate;

    char retcode[8];

};

/*

 * Set up a signal frame.

 */

/* XXX: save x87 state */

static int

setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,

                 CPUX86State *env, abi_ulong mask, abi_ulong fpstate_addr)

{

        int err = 0;

        uint16_t magic;

        /* already locked in setup_frame() */

        err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);

        err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);

        err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);

        err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);

        err |= __put_user(env->regs[R_EDI], &sc->edi);

        err |= __put_user(env->regs[R_ESI], &sc->esi);

        err |= __put_user(env->regs[R_EBP], &sc->ebp);

        err |= __put_user(env->regs[R_ESP], &sc->esp);

        err |= __put_user(env->regs[R_EBX], &sc->ebx);

        err |= __put_user(env->regs[R_EDX], &sc->edx);

        err |= __put_user(env->regs[R_ECX], &sc->ecx);

        err |= __put_user(env->regs[R_EAX], &sc->eax);

        err |= __put_user(env->exception_index, &sc->trapno);

        err |= __put_user(env->error_code, &sc->err);

        err |= __put_user(env->eip, &sc->eip);

        err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);

        err |= __put_user(env->eflags, &sc->eflags);

        err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);

        err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);

        cpu_x86_fsave(env, fpstate_addr, 1);

        fpstate->status = fpstate->sw;

        magic = 0xffff;

        err |= __put_user(magic, &fpstate->magic);

        err |= __put_user(fpstate_addr, &sc->fpstate);

        /* non-iBCS2 extensions.. */

        err |= __put_user(mask, &sc->oldmask);

        err |= __put_user(env->cr[2], &sc->cr2);

        return err;

}

/*

 * Determine which stack to use..

 */

static inline abi_ulong

get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size)

{

        unsigned long esp;

        /* Default to using normal stack */

        esp = env->regs[R_ESP];

        /* This is the X/Open sanctioned signal stack switching.  */

        if (ka->sa_flags & TARGET_SA_ONSTACK) {

            if (sas_ss_flags(esp) == 0)

                esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;

        }

        /* This is the legacy signal stack switching. */

        else

        if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&

            !(ka->sa_flags & TARGET_SA_RESTORER) &&

            ka->sa_restorer) {

            esp = (unsigned long) ka->sa_restorer;

        }

        return (esp - frame_size) & -8ul;

}

/* compare linux/arch/i386/kernel/signal.c:setup_frame() */

static void setup_frame(int sig, struct target_sigaction *ka,

                        target_sigset_t *set, CPUX86State *env)

{

        abi_ulong frame_addr;

        struct sigframe *frame;

        int i, err = 0;

        frame_addr = get_sigframe(ka, env, sizeof(*frame));

        if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))

                goto give_sigsegv;

        err |= __put_user(current_exec_domain_sig(sig),

                          &frame->sig);

        if (err)

                goto give_sigsegv;

        setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0],

                         frame_addr + offsetof(struct sigframe, fpstate));

        if (err)

                goto give_sigsegv;

        for(i = 1; i < TARGET_NSIG_WORDS; i++) {

            if (__put_user(set->sig[i], &frame->extramask[i - 1]))

                goto give_sigsegv;

        }

        /* Set up to return from userspace.  If provided, use a stub

           already in userspace.  */

        if (ka->sa_flags & TARGET_SA_RESTORER) {

                err |= __put_user(ka->sa_restorer, &frame->pretcode);

        } else {

                uint16_t val16;

                abi_ulong retcode_addr;

                retcode_addr = frame_addr + offsetof(struct sigframe, retcode);

                err |= __put_user(retcode_addr, &frame->pretcode);

                /* This is popl %eax ; movl $,%eax ; int $0x80 */

                val16 = 0xb858;

                err |= __put_user(val16, (uint16_t *)(frame->retcode+0));

                err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));

                val16 = 0x80cd;

                err |= __put_user(val16, (uint16_t *)(frame->retcode+6));

        }

        if (err)

                goto give_sigsegv;

        /* Set up registers for signal handler */

        env->regs[R_ESP] = frame_addr;

        env->eip = ka->_sa_handler;

        cpu_x86_load_seg(env, R_DS, __USER_DS);

        cpu_x86_load_seg(env, R_ES, __USER_DS);

        cpu_x86_load_seg(env, R_SS, __USER_DS);

        cpu_x86_load_seg(env, R_CS, __USER_CS);

        env->eflags &= ~TF_MASK;

        unlock_user_struct(frame, frame_addr, 1);

        return;

give_sigsegv:

        unlock_user_struct(frame, frame_addr, 1);

        if (sig == TARGET_SIGSEGV)

                ka->_sa_handler = TARGET_SIG_DFL;

        force_sig(TARGET_SIGSEGV /* , current */);

}

/* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */

static void setup_rt_frame(int sig, struct target_sigaction *ka,

                           target_siginfo_t *info,

                           target_sigset_t *set, CPUX86State *env)

{

        abi_ulong frame_addr, addr;

        struct rt_sigframe *frame;

        int i, err = 0;

        frame_addr = get_sigframe(ka, env, sizeof(*frame));

        if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))

                goto give_sigsegv;

        err |= __put_user(current_exec_domain_sig(sig),

                          &frame->sig);

        addr = frame_addr + offsetof(struct rt_sigframe, info);

        err |= __put_user(addr, &frame->pinfo);

        addr = frame_addr + offsetof(struct rt_sigframe, uc);

        err |= __put_user(addr, &frame->puc);

        err |= copy_siginfo_to_user(&frame->info, info);

        if (err)

                goto give_sigsegv;

        /* Create the ucontext.  */

        err |= __put_user(0, &frame->uc.tuc_flags);

        err |= __put_user(0, &frame->uc.tuc_link);

        err |= __put_user(target_sigaltstack_used.ss_sp,

                          &frame->uc.tuc_stack.ss_sp);

        err |= __put_user(sas_ss_flags(get_sp_from_cpustate(env)),

                          &frame->uc.tuc_stack.ss_flags);

        err |= __put_user(target_sigaltstack_used.ss_size,

                          &frame->uc.tuc_stack.ss_size);

        err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate,

                                env, set->sig[0], 

                                frame_addr + offsetof(struct rt_sigframe, fpstate));

        for(i = 0; i < TARGET_NSIG_WORDS; i++) {

            if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))

                goto give_sigsegv;

        }

        /* Set up to return from userspace.  If provided, use a stub

           already in userspace.  */

        if (ka->sa_flags & TARGET_SA_RESTORER) {

                err |= __put_user(ka->sa_restorer, &frame->pretcode);

        } else {

                uint16_t val16;

                addr = frame_addr + offsetof(struct rt_sigframe, retcode);

                err |= __put_user(addr, &frame->pretcode);

                /* This is movl $,%eax ; int $0x80 */

                err |= __put_user(0xb8, (char *)(frame->retcode+0));

                err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));

                val16 = 0x80cd;

                err |= __put_user(val16, (uint16_t *)(frame->retcode+5));

        }

        if (err)

                goto give_sigsegv;

        /* Set up registers for signal handler */

        env->regs[R_ESP] = frame_addr;

        env->eip = ka->_sa_handler;

        cpu_x86_load_seg(env, R_DS, __USER_DS);

        cpu_x86_load_seg(env, R_ES, __USER_DS);

        cpu_x86_load_seg(env, R_SS, __USER_DS);

        cpu_x86_load_seg(env, R_CS, __USER_CS);

        env->eflags &= ~TF_MASK;

        unlock_user_struct(frame, frame_addr, 1);

        return;

give_sigsegv:

        unlock_user_struct(frame, frame_addr, 1);

        if (sig == TARGET_SIGSEGV)

                ka->_sa_handler = TARGET_SIG_DFL;

        force_sig(TARGET_SIGSEGV /* , current */);

}

static int

restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)

{

        unsigned int err = 0;

        abi_ulong fpstate_addr;

        unsigned int tmpflags;

        cpu_x86_load_seg(env, R_GS, tswap16(sc->gs));

        cpu_x86_load_seg(env, R_FS, tswap16(sc->fs));

        cpu_x86_load_seg(env, R_ES, tswap16(sc->es));

        cpu_x86_load_seg(env, R_DS, tswap16(sc->ds));

        env->regs[R_EDI] = tswapl(sc->edi);

        env->regs[R_ESI] = tswapl(sc->esi);

        env->regs[R_EBP] = tswapl(sc->ebp);

        env->regs[R_ESP] = tswapl(sc->esp);

        env->regs[R_EBX] = tswapl(sc->ebx);

        env->regs[R_EDX] = tswapl(sc->edx);

        env->regs[R_ECX] = tswapl(sc->ecx);

        env->eip = tswapl(sc->eip);

        cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3);

        cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3);

        tmpflags = tswapl(sc->eflags);

        env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);

        //                regs->orig_eax = -1;                /* disable syscall checks */