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, see <http://www.gnu.org/licenses/>.

 */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <stdarg.h>

#include <unistd.h>

#include <errno.h>

#include <assert.h>

#include <sys/ucontext.h>

#include <sys/resource.h>

#include "qemu.h"

#include "qemu-common.h"

#include "target_signal.h"

//#define DEBUG_SIGNAL

static 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[_NSIG] = {

    [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 no one 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[_NSIG];

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);

}

int host_to_target_signal(int sig)

{

    if (sig >= _NSIG)

        return sig;

    return host_to_target_signal_table[sig];

}

int target_to_host_signal(int sig)

{

    if (sig >= _NSIG)

        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] = tswapal(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] = tswapal(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 = host_to_target_signal(info->si_signo);

    tinfo->si_signo = sig;

    tinfo->si_errno = 0;

    tinfo->si_code = info->si_code;

    if (sig == TARGET_SIGILL || sig == TARGET_SIGFPE || sig == TARGET_SIGSEGV

        || sig == TARGET_SIGBUS || sig == TARGET_SIGTRAP) {

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

           the target is irrelevant.  */

        tinfo->_sifields._sigfault._addr = 0;

    } else if (sig == TARGET_SIGIO) {

        tinfo->_sifields._sigpoll._band = info->si_band;

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

    } else if (sig == TARGET_SIGCHLD) {

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

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

        tinfo->_sifields._sigchld._status

            = host_to_target_waitstatus(info->si_status);

        tinfo->_sifields._sigchld._utime = info->si_utime;

        tinfo->_sifields._sigchld._stime = info->si_stime;

    } 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 = info->si_signo;

    tinfo->si_signo = tswap32(sig);

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

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

    if (sig == TARGET_SIGILL || sig == TARGET_SIGFPE || sig == TARGET_SIGSEGV

        || sig == TARGET_SIGBUS || sig == TARGET_SIGTRAP) {

        tinfo->_sifields._sigfault._addr

            = tswapal(info->_sifields._sigfault._addr);

    } else if (sig == TARGET_SIGIO) {

        tinfo->_sifields._sigpoll._band

            = tswap32(info->_sifields._sigpoll._band);

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

    } else if (sig == TARGET_SIGCHLD) {

        tinfo->_sifields._sigchld._pid

            = tswap32(info->_sifields._sigchld._pid);

        tinfo->_sifields._sigchld._uid

            = tswap32(info->_sifields._sigchld._uid);

        tinfo->_sifields._sigchld._status

            = tswap32(info->_sifields._sigchld._status);

        tinfo->_sifields._sigchld._utime

            = tswapal(info->_sifields._sigchld._utime);

        tinfo->_sifields._sigchld._stime

            = tswapal(info->_sifields._sigchld._stime);

    } 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

            = tswapal(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)tswapal(tinfo->_sifields._rt._sigval.sival_ptr);

}

static int fatal_signal (int sig)

{

    switch (sig) {

    case TARGET_SIGCHLD:

    case TARGET_SIGURG:

    case TARGET_SIGWINCH:

        /* Ignored by default.  */

        return 0;

    case TARGET_SIGCONT:

    case TARGET_SIGSTOP:

    case TARGET_SIGTSTP:

    case TARGET_SIGTTIN:

    case TARGET_SIGTTOU:

        /* Job control signals.  */

        return 0;

    default:

        return 1;

    }

}

/* returns 1 if given signal should dump core if not handled */

static int core_dump_signal(int sig)

{

    switch (sig) {

    case TARGET_SIGABRT:

    case TARGET_SIGFPE:

    case TARGET_SIGILL:

    case TARGET_SIGQUIT:

    case TARGET_SIGSEGV:

    case TARGET_SIGTRAP:

    case TARGET_SIGBUS:

        return (1);

    default:

        return (0);

    }

}

void signal_init(void)

{

    struct sigaction act;

    struct sigaction oact;

    int i, j;

    int host_sig;

    /* generate signal conversion tables */

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

        if (host_to_target_signal_table[i] == 0)

            host_to_target_signal_table[i] = i;

    }

    for(i = 1; i < _NSIG; 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.  We need at least

           SIGSEGV and SIGBUS, to detect exceptions.  We can not just

           trap all signals because it affects syscall interrupt

           behavior.  But do trap all default-fatal signals.  */

        if (fatal_signal (i))

            sigaction(host_sig, &act, NULL);

    }

}

/* signal queue handling */

static inline struct sigqueue *alloc_sigqueue(CPUArchState *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(CPUArchState *env, struct sigqueue *q)

{

    TaskState *ts = env->opaque;

    q->next = ts->first_free;

    ts->first_free = q;

}

/* abort execution with signal */

static void QEMU_NORETURN force_sig(int target_sig)

{

    TaskState *ts = (TaskState *)thread_env->opaque;

    int host_sig, core_dumped = 0;

    struct sigaction act;

    host_sig = target_to_host_signal(target_sig);

    gdb_signalled(thread_env, target_sig);

    /* dump core if supported by target binary format */

    if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) {

        stop_all_tasks();

        core_dumped =

            ((*ts->bprm->core_dump)(target_sig, thread_env) == 0);

    }

    if (core_dumped) {

        /* we already dumped the core of target process, we don't want

         * a coredump of qemu itself */

        struct rlimit nodump;

        getrlimit(RLIMIT_CORE, &nodump);

        nodump.rlim_cur=0;

        setrlimit(RLIMIT_CORE, &nodump);

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

            target_sig, strsignal(host_sig), "core dumped" );

    }

    /* The proper exit code for dying from an uncaught signal is

     * -<signal>.  The kernel doesn't allow exit() or _exit() to pass

     * a negative value.  To get the proper exit code we need to

     * actually die from an uncaught signal.  Here the default signal

     * handler is installed, we send ourself a signal and we wait for

     * it to arrive. */

    sigfillset(&act.sa_mask);

    act.sa_handler = SIG_DFL;

    sigaction(host_sig, &act, NULL);

    /* For some reason raise(host_sig) doesn't send the signal when

     * statically linked on x86-64. */

    kill(getpid(), host_sig);

    /* Make sure the signal isn't masked (just reuse the mask inside

    of act) */

    sigdelset(&act.sa_mask, host_sig);

    sigsuspend(&act.sa_mask);

    /* unreachable */

    abort();

}

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

   as possible */

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

{

    TaskState *ts = env->opaque;

    struct emulated_sigtable *k;

    struct sigqueue *q, **pq;

    abi_ulong handler;

    int queue;

#if defined(DEBUG_SIGNAL)

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

            sig);

#endif

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

    queue = gdb_queuesig ();

    handler = sigact_table[sig - 1]._sa_handler;

    if (!queue && handler == TARGET_SIG_DFL) {

        if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {

            kill(getpid(),SIGSTOP);

            return 0;

        } else

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

        if (sig != TARGET_SIGCHLD &&

            sig != TARGET_SIGURG &&

            sig != TARGET_SIGWINCH &&

            sig != TARGET_SIGCONT) {

            force_sig(sig);

        } else {

            return 0; /* indicate ignored */

        }

    } else if (!queue && handler == TARGET_SIG_IGN) {

        /* ignore signal */

        return 0;

    } else if (!queue && 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 forward to it some signals */

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

        && info->si_code > 0) {

        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_exit(thread_env);

    }

}

/* 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 == TARGET_SIGKILL || sig == TARGET_SIGSTOP)

        return -EINVAL;

    k = &sigact_table[sig - 1];

#if defined(DEBUG_SIGNAL)

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

            sig, act, oact);

#endif

    if (oact) {

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

#if defined(TARGET_MIPS) || defined (TARGET_ALPHA)

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

#else

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

#endif

#if !defined(TARGET_MIPS)

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

#endif

        oact->sa_mask = k->sa_mask;

    }

    if (act) {

        /* FIXME: This is not threadsafe.  */

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

#if defined(TARGET_MIPS) || defined (TARGET_ALPHA)

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

#else

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

#endif

#if !defined(TARGET_MIPS)

        k->sa_restorer = tswapal(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) {

                if (fatal_signal (sig))

                    act1.sa_sigaction = host_signal_handler;

                else

                    act1.sa_sigaction = (void *)SIG_DFL;

            } else {

                act1.sa_sigaction = host_signal_handler;

            }

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

        }

    }

    return ret;

}

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,