signal.c

一个用于学习的操作系统

#include <fairysky/signal.h>
#include <fairysky/scheduler.h>
#include <asm/segment.h>

s32 sys_signal(s32 signal_num, s32 handle, s32 restorer)
{
    if (signal_num < 1 || signal_num > 32) {
        return -1;
    }

    if (signal_num == SIGKILL) {
        return -1;
    }

    handle = (long) current->sigaction[signal_num - 1].sa_handler;

    current->sigaction[signal_num - 1].sa_handler = (void (*)(int))handle;
    current->sigaction[signal_num - 1].sa_restorer = (void (*)(void))restorer;
    current->sigaction[signal_num - 1].sa_mask = 0;
    current->sigaction[signal_num - 1].sa_flags = SA_ONESHOT | SA_NOMASK;

    return handle;
}

#ifdef WINDOWS_CYGWIN
    #define DO_SIGNAL do_signal
#else
    #define DO_SIGNAL _do_signal
#endif
s32 DO_SIGNAL(
    s32 EAX,
    s32 EBX,
    s32 ECX,
    s32 EDX,
    s32 ESI,
    s32 EDI,
    s32 EBP,
    s32 FS,
    s32 GS,
    s32 ES,
    s32 DS,
    s32 EIP,
    s32 CS,
    s32 EFLAG,
    s32 ESP3,
    s32 SS3)
{
    s32 signal_num;
    s32 signal;
    s32 ret;

    struct sigaction *sa;
    u32 sa_handle;
    s32 old_eip = EIP;
    s32 longs;
    u32 *tmp_esp;

    if (current == pinit_task) {        //如果为进程0,则不处理
        return 0;
    }

    signal = current->signal & (~ current->signal_blocked);     //根据屏蔽位获取有效的信号
    //从低位(位0)开始扫描位图，看是否有1的位，如果有，则ecx保留该位的偏移值(即第几位0-31)
    //如果没有信号，则设置%%eax为0
    //printk("DO_SIGNAL ecx:%x\n", signal);
    __asm__ __volatile__ (
        "movl $0, %%eax\t\n"        /*设置标志eax,也就是ret为0*/
        "bsfl %%ecx, %%ecx\t\n"
        "je 1f\t\n"                 /*没有信号,则直接退出,ret为0*/
        "movl $1, %%eax\t\n"        /*有信号,设置标志eax,也就是ret为1*/
        "btrl %%ecx, %%ebx\t\n"     /*复位该信号*/
        "1:"
        :"=a"(ret), "=b"(current->signal), "=c"(signal_num)
        :"b"(current->signal), "c"(signal)
        );
    if (! ret) {     //如果Result为0,则说明没有信号
        return 0;
    }

    //开始处理信号
    //printk("DO_SIGNAL \n");

    sa = &current->sigaction[signal_num];
    ++signal_num;   //取得信号的值

    sa_handle = (u32)sa->sa_handler;
    if ((void *)sa_handle == SIG_IGN) { //如果是忽略处理，则直接退出
        return 0;
    } else if ((void *)sa_handle == SIG_DFL) {  //如果是默认处理
        if (signal_num == SIGCHLD) {
            return 0;
        } else {
            ;//do_exit(1 << signal_num);
            return 0;
        }
    } else {
        EIP = sa_handle;
        longs = 8 ;
        /*
        ESP3 -= longs * sizeof(s32);
        tmp_esp = ESP3;

        put_fs_long((long)sa->sa_restorer, tmp_esp++);
        put_fs_long(signal_num, tmp_esp++);
        put_fs_long(current->signal_blocked, tmp_esp++);
        put_fs_long(EAX, tmp_esp++);
        put_fs_long(ECX, tmp_esp++);
        put_fs_long(EDX, tmp_esp++);
        put_fs_long(EFLAG, tmp_esp++);
        put_fs_long(old_eip, tmp_esp++);
        */
        tmp_esp = ESP3;
        ESP3 -= longs * sizeof(s32);

        put_fs_long((u32)old_eip, --tmp_esp);

        //sa_restorer的原型应该这样sa_restorer(signal_num, current->signal_blocked, EAX, ECX, EDX, EFLAG)
        put_fs_long((u32)EFLAG, --tmp_esp);  //EFLAG作为sa_restorer参数压栈
        put_fs_long((u32)EDX, --tmp_esp);    //EDX作为sa_restorer参数压栈
        put_fs_long((u32)ECX, --tmp_esp);    //ECX作为sa_restorer参数压栈
        put_fs_long((u32)EAX, --tmp_esp);    //EAX作为sa_restorer参数压栈
        put_fs_long((u32)current->signal_blocked, --tmp_esp);    //signal_blocked作为sa_restorer参数压栈
        put_fs_long((u32)signal_num, --tmp_esp);                 //signal_num作为sa_restorer参数压栈
        put_fs_long((u32)sa->sa_restorer, --tmp_esp);

        current->signal_blocked |= sa->sa_mask;
    }

    return 0;
}