Archipelago » qemu

/*

 *  Emulation of Linux signals

 *  Copyright (c) 2003 Fabrice Bellard

 *

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

static struct sigqueue *first_free; /* first free siginfo queue entry */

static int signal_pending; /* non zero if a signal may be pending */

                                void *puc);

static uint8_t host_to_target_signal_table[65] = {

    return target_to_host_signal_table[sig];

}

                                           const sigset_t *s)

{

    int i;

    unsigned long sigmask;

    uint32_t target_sigmask;

    sigmask = ((unsigned long *)s)[0];

    target_sigmask = 0;

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

            target_sigmask |= 1 << (host_to_target_signal(i + 1) - 1);

    }

#if TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 32

    target_sigmask = s->sig[0];

    sigmask = 0;

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

            sigmask |= 1 << (target_to_host_signal(i + 1) - 1);

    }

#if TARGET_LONG_BITS == 32 && HOST_LONG_BITS == 32

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

    target_to_host_sigset_internal(d, &s1);

}

                               const sigset_t *sigset)

{

    target_sigset_t d;

    *old_sigset = d.sig[0];

}

                               const target_ulong *old_sigset)

{

    target_sigset_t d;

/* siginfo conversion */

                                                 const siginfo_t *info)

{

    int sig;

    tinfo->si_signo = sig;

    tinfo->si_errno = 0;

    tinfo->si_code = 0;

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

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

           the target is irrelevant */

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

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

        /* XXX: potential problem if 64 bit */

            (target_ulong)info->si_value.sival_ptr;

    }

}

                          const target_siginfo_t *info)

{

    int sig;

    tinfo->si_signo = tswap32(sig);

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

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

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

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

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

    }

}

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

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

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

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

}

        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. */

    sigfillset(&act.sa_mask);

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

        sigaction(i, &act, NULL);

    }

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

    first_free = &sigqueue_table[0];

        sigqueue_table[i].next = &sigqueue_table[i + 1];

    sigqueue_table[MAX_SIGQUEUE_SIZE - 1].next = NULL;

}

{

    int host_sig;

    host_sig = target_to_host_signal(sig);

            sig, strsignal(host_sig));

#if 1

    _exit(-host_sig);

    target_ulong handler;

#if defined(DEBUG_SIGNAL)

            sig);

#endif

    k = &sigact_table[sig - 1];

    handler = k->sa._sa_handler;

    if (handler == TARGET_SIG_DFL) {

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

            sig != TARGET_SIGWINCH) {

            force_sig(sig);

        } else {

    }

}

                                void *puc)

{

    int sig;

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

       we we forward to it some signals */

#if defined(TARGET_I386) && defined(USE_CODE_COPY)

        || host_signum == SIGFPE

#endif

        return -EINVAL;

    k = &sigact_table[sig - 1];

#if defined(DEBUG_SIGNAL)

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

#endif

    if (oact) {

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

#endif

                                       const target_siginfo_t *info)

{

    tswap_siginfo(tinfo, info);

	}

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

#endif

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

            !(ka->sa.sa_flags & TARGET_SA_RESTORER) &&

	force_sig(TARGET_SIGSEGV /* , current */);

}

                           target_siginfo_t *info,

			   target_sigset_t *set, CPUX86State *env)

{

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

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

	{

		unsigned int tmpflags;

                tmpflags = ldl(&sc->eflags);

    target_to_host_sigset_internal(&set, &target_set);

    sigprocmask(SIG_SETMASK, &set, NULL);

    /* restore registers */

    if (restore_sigcontext(env, &frame->sc, &eax))

        goto badframe;

#endif

        target_to_host_sigset(&set, &frame->uc.tuc_sigmask);

        sigprocmask(SIG_SETMASK, &set, NULL);

	if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))

		goto badframe;

        //	return err;

}

                           target_siginfo_t *info,

			   target_sigset_t *set, CPUState *env)

{

}

                           target_siginfo_t *info,

			   target_sigset_t *set, CPUState *env)

{

    return g2h((sp - frame_size) & ~7);

}

   		target_sigset_t *set, CPUState *regs)

{

    struct sigframe *frame;

give_sigsegv:

    force_sig(TARGET_SIGSEGV/*, current*/);

}

long do_sigreturn(CPUState *regs)

   	:"r" (&regs));

    /* Unreached */

#endif

    regs->PC[regs->current_tc] = regs->CP0_EPC;

    /* I am not sure this is right, but it seems to work

    * maybe a problem with nested signals ? */

    return 0;

}

                           target_siginfo_t *info,

			   target_sigset_t *set, CPUState *env)

{

    fprintf(stderr, "setup_frame: not implemented\n");

}

                           target_siginfo_t *info,

			   target_sigset_t *set, CPUState *env)

{

    target_sigset_t target_old_set;

    struct emulated_sigaction *k;

    struct sigqueue *q;

    if (!signal_pending)

        return;

    k->first = q->next;

    if (!k->first)

        k->pending = 0;

    sig = gdb_handlesig (cpu_env, sig);

    if (!sig) {

        fprintf (stderr, "Lost signal\n");

    handler = k->sa._sa_handler;

    if (handler == TARGET_SIG_DFL) {

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

            sig != TARGET_SIGWINCH) {

            force_sig(sig);

        }

           blocked during the handler */

        if (!(k->sa.sa_flags & TARGET_SA_NODEFER))

            sigaddset(&set, target_to_host_signal(sig));

        /* block signals in the handler using Linux */

        sigprocmask(SIG_BLOCK, &set, &old_set);

        /* save the previous blocked signal state to restore it at the