qemu/linux-user/signal.c

/*
 *  Emulation of Linux signal handling
 * 
 *  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 <stdarg.h>
#include <signal.h>
#include <sys/ucontext.h>

/* Algorithm strongly inspired from em86 : we queue the signals so
   that we can handle them at precise points in the emulated code. */

struct emulated_sigaction {
    struct target_sigaction sa;
    int nb_pending;
    struct target_siginfo info;
};

struct emulated_sigaction sigact_table[NSIG];
int signal_pending;

static inline int host_to_target_signal(int sig)
{
    return sig;
}

static inline int target_to_host_signal(int sig)
{
    return sig;
}

void signal_init(void)
{
    struct sigaction act;
    int i;

    /* set all host signal handlers */
    sigemptyset(&act.sa_mask);
    act.sa_flags = SA_SIGINFO;
    act.sa_sigaction = host_signal_handler;
    for(i = 1; i < NSIG; i++) {
	sigaction(i, &sa, NULL);
    }
    
    memset(sigact_table, 0, sizeof(sigact_table));
}

static void host_signal_handler(int host_signum, siginfo_t *info, 
                                void *puc)
{
    struct ucontext *uc = puc;
    int signum;
    /* get target signal number */
    signum = host_to_target(host_signum);
    if (signum >= TARGET_NSIG)
        return;
    /* we save the old mask */
    
    
}


void process_pending_signals(void)
{
    int signum;
    target_ulong _sa_handler;

    struct emulated_sigaction *esig;

    if (!signal_pending)
        return;

    esig = sigact_table;
    for(signum = 1; signum < TARGET_NSIG; signum++) {
        if (esig->nb_pending != 0)
            goto handle_signal;
        esig++;
    }
    /* if no signal is pending, just return */
    signal_pending = 0;
    return;
 handle_signal:
    _sa_handler = esig->sa._sa_handler;
    if (_sa_handler == TARGET_SIG_DFL) {
        /* default handling
    }


}