babyos2（18）—— signal，kill，do_signal，sig_return

signal是一种IPC方式，babyos2准备实现一个比较简单的模型，只探究它的基本原理，不深究各个信号具体意义及相互关系等。

基本思路：
1）每个进程有一个信号队列，存放已收到未处理的信号
2）一个进程要发送一个信号到另一个进程，通过系统调用sys_kill进入内核，通过pid找到接受信号的进程，并给它的信号队列新增加一个信号
3）每个进程中断返回之前，检查有没有未处理的信号，若有则去处理

/*
 * 2017-12-28
 * guzhoudiaoke@126.com
 */

#ifndef _SIGNAL_H_
#define _SIGNAL_H_

#include "types.h"
#include "spinlock.h"
#include "atomic.h"

#define NSIG 32

typedef void (*sighandler_t) (int32);
typedef uint64 sigset_t;
typedef struct sigaction_s {
    sighandler_t    m_handler;
    uint64          m_flags;
    sigset_t        m_mask;
} sigaction_t;

typedef struct siginfo_s {
    uint32          m_sig;
    uint32          m_pid;
} siginfo_t;


class signal_t {
public:
    signal_t();
    ~signal_t();
    void init();
    void copy(const signal_t& signal);

    void lock();
    void unlock();
    void set_sigaction(uint32 sig, const sigaction_t& sa);

    static int32 do_sigaction(uint32 sig, sighandler_t sig_handler);
    static int32 do_send_signal(uint32 pid, uint32 sig);
    static int32 do_sigreturn();

public:

private:
    atomic_t    m_count;
    sigaction_t m_action[NSIG];
    spinlock_t  m_lock;
};

#endif

process_t类增加下面的成员

    uint32              m_sig_pending;

    signal_t            m_signals;
    list_t<siginfo_t>   m_sig_queue;
    sigset_t            m_sig_blocked;
    spinlock_t          m_sig_mask_lock;

sys_kill：

int32 syscall_t::sys_kill(trap_frame_t* frame)
{
    uint32 pid = frame->ebx;
    uint32 sig = frame->ecx;
    return signal_t::do_send_signal(pid, sig);
}

int32 signal_t::do_send_signal(uint32 pid, uint32 sig)
{
    siginfo_t si;
    si.m_sig = sig;
    si.m_pid = current->m_pid;

    return os()->get_arch()->get_cpu()->send_signal_to(si, pid);
}

int32 cpu_t::send_signal_to(const siginfo_t& si, uint32 pid)
{
    console()->kprintf(WHITE, "send_signal, ");

    cli();
    process_t* p = find_process(pid);
    if (p != NULL) {
        p->m_sig_queue.push_back(si);
        p->calc_sig_pending();
    }
    sti();

    return 0;
}

do_signal:

reschedule:
    call schedule
    jmp  restore_all

dosignal:
    pushl   %esp
    call do_signal
    addl    $4,             %esp
    jmp  restore_all


common_isr:
    SAVE_ALL
    GET_CURRENT(%ebx)
    movl    $(SEG_KDATA<<3),%edx
    movw    %dx,            %ds
    movw    %dx,            %es
    movw    %dx,            %fs
    movw    %dx,            %gs

    pushl   %esp
    call    do_common_isr
    addl    $4,             %esp
ret_from_isr:
    cli
    cmpl    $0,                need_resched(%ebx)
    jne     reschedule
    cmpl    $0,             sig_pending(%ebx)
    jne     dosignal
restore_all:
    RESTORE_ALL
    addl    $8,             %esp
    iret

中断返回前，检查是否有未处理的信号，若有调用do_signal处理

extern "C"
void do_signal(trap_frame_t* frame)
{
    os()->get_arch()->get_cpu()->do_signal(frame);
}

void cpu_t::do_signal(trap_frame_t* frame)
{
    while (!current->m_sig_queue.empty()) {
        siginfo_t si = *current->m_sig_queue.begin();
        console()->kprintf(PINK, "proc %u get signal SIG_%u from proc %u\n", current->m_pid, si.m_sig, si.m_pid);
        current->m_sig_queue.pop_front();
    }
}

暂时收到信号只打印一条信息。

init每隔2s发送一个signal给shell：

int main()
{
    uint32 cs = 0xffffffff;
    __asm__ volatile("movl %%cs, %%eax" : "=a" (cs));

    // print cs to show work in user mode
    userlib_t::print("This is printed by init, cs = ");
    userlib_t::print_int(cs, 16, 0);
    userlib_t::print("\n");

    // fork
    int32 pid = userlib_t::fork();
    if (pid == 0) {
        // child
        pid = userlib_t::exec(SHELL_LBA, SHELL_SECT_NUM, "shell");
        if (pid != 0) {
            userlib_t::print("BUG exec failed!!!\n");
        }
    }
    else {
        //userlib_t::wait(pid);

        // parent
        while (1) {
            userlib_t::sleep(2);
            userlib_t::print("I,");
            userlib_t::kill(pid, 4);
        }
    }

    return 0;
}

因为是在中断返回前检测信号，所以处于内核态，怎样能回到用户态并执行用户态注册的的信号处理函数，且执行完成后回到中断前的地方继续执行呢？

1）保存中断的context，将中断返回后的eip改为用户态信号处理函数
2）在用户态栈上构造一个frame，模拟函数调用sighandler的场景，并指定一个返回地址
3）返回地址指到栈上一个位置，这个位置放置：
movl $SYS_SIGRET, %eax int$0x80
4）则信号处理完成返回的时候，会执行一个系统调用sys_sigreturn，这个系统调用恢复上次中断的context，则从sys_sigreturn中断返回后回到信号处理前那次中断前的地方继续执行。

注册信号处理函数：

void userlib_t::signal(uint32 sig, sighandler_t handler)
{
    __asm__ volatile("int $0x80" : : "b" (sig), "c"(handler), "a" (SYS_SIGNAL));
}


int32 syscall_t::sys_signal(trap_frame_t* frame)
{
    uint32 sig = frame->ebx;
    sighandler_t sig_handler = (sighandler_t) frame->ecx;
    return signal_t::do_sigaction(sig, sig_handler);
}

void signal_t::lock()
{
    m_lock.lock();
}

void signal_t::unlock()
{
    m_lock.unlock();
}

void signal_t::set_sigaction(uint32 sig, const sigaction_t& sa)
{
    m_action[sig].m_handler = sa.m_handler;
    m_action[sig].m_flags   = sa.m_flags;
    m_action[sig].m_mask    = sa.m_mask;
}

int32 signal_t::do_sigaction(uint32 sig, sighandler_t sig_handler)
{
    if (sig < 1 || sig >= NSIG) {
        return -1;
    }

    sigaction_t sa;
    sa.m_handler = sig_handler;

    current->m_signals.lock();
    current->m_signals.set_sigaction(sig, sa);
    current->m_signals.unlock();

    return 0;
}

处理信号：

void cpu_t::do_signal(trap_frame_t* frame)
{
    if (!current->m_sig_queue.empty()) {
        siginfo_t si = *current->m_sig_queue.begin();
        current->m_sig_queue.pop_front();
        signal_t::handle_signal(frame, si);
    }
}


int32 signal_t::handle_signal(trap_frame_t* frame, const siginfo_t& si)
{
    uint32 sig = si.m_sig;
    sigaction_t* action = &current->m_signals.m_action[sig];
    if (action->m_handler == SIG_DFL) {
        return -1;
    }

    /* get sig frame */
    sigframe_t* sig_frame = (sigframe_t *) ((frame->esp - sizeof(sigframe_t)) & -8UL);
    sig_frame->m_sig = si.m_sig;

    /* save trap frame into sig frame */
    memcpy(&sig_frame->m_trap_frame, frame, sizeof(trap_frame_t));

    /* return addr */
    sig_frame->m_ret_addr = sig_frame->m_ret_code;

    /* return code: this is movl $,%eax ; int $0x80 */
    sig_frame->m_ret_code[0] = 0xb8;
    *(int *) (sig_frame->m_ret_code+1) = SYS_SIGRET;
    *(short *) (sig_frame->m_ret_code+5) = 0x80cd;

    /* set eip to sig handler */
    frame->eip = (uint32) action->m_handler;

    /* set esp as sig frame */
    frame->esp = (uint32) sig_frame;

    return 0;
}

sig return:

int32 syscall_t::sys_sigret(trap_frame_t* frame)
{
    return signal_t::do_sigreturn(frame);
}

int32 signal_t::do_sigreturn(trap_frame_t* frame)
{
    sigframe_t* sig_frame = (sigframe_t *) (frame->esp - 4);
    memcpy(frame, &sig_frame->m_trap_frame, sizeof(trap_frame_t));

    return 0;
}

shell中注册信号处理函数：

/*
 * guzhoudiaoke@126.com
 * 2017-12-10
 */

#include "shell.h"
#include "userlib.h"

void process_signal(int32 sig)
{
    userlib_t::print("SIG_");
    userlib_t::print_int(sig, 10, 1);
    userlib_t::print(",");
}

int main()
{
    sighandler_t handler = &process_signal;
    userlib_t::signal(4, handler);
    userlib_t::print("This is printed by shell.\n");

    while (1) {
        userlib_t::sleep(2);
        userlib_t::print("S,");
    }

    userlib_t::exit(0);
    return 1;
}

信号处理函数打印SIG_no，如图所示，能够成功注册、发送、处理信号。
这样一个最最简单的信号模型就建立好了，暂时只搞明白它的基本原理，像sig mask之类的都暂时不处理，SIG_DFL，默认行为是忽略信号。