【Linux系统】进程信号：信号的处理

// 用户程序注册SIGQUIT信号的处理函数
signal(SIGQUIT, sighandler);

#include <signal.h>

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

struct sigaction {
    void     (*sa_handler)(int);         // 简单的信号处理函数
    void     (*sa_sigaction)(int, siginfo_t *, void *); // 高级信号处理函数
    sigset_t   sa_mask;                  // 在执行处理函数期间要阻塞的信号集
    int        sa_flags;                 // 修改信号行为的标志位
    void     (*sa_restorer)(void);       // 已废弃，不应使用
};

void handler(int sig) {
    // 处理信号
}

void handler(int sig, siginfo_t *info, void *ucontext) {
    // 可以访问更多关于信号的信息
}

siginfo_t {
    int      si_signo;     // 信号编号
    int      si_errno;     // 错误号（如果有）
    int      si_code;      // 信号来源代码
    pid_t    si_pid;       // 发送信号的进程ID
    uid_t    si_uid;       // 发送信号的进程的真实用户ID
    void    *si_addr;      // 导致错误的内存地址（对于SIGSEGV等）
    int      si_status;    // 退出值或信号（对于SIGCHLD）
    // ... 其他字段
}

void handler(int signum)
{
    std::cout << "hello signal: " << signum << std::endl;
    while(true)
    {
        //不断获取pending表！
        sigset_t pending;
        sigpending(&pending);
        for(int i = 31; i >= 1; i--)
        {
            if(sigismember(&pending, i))
                std::cout << "1";
            else
                std::cout << "0";
        }
        std::cout << std::endl;
        sleep(1);
    }
    exit(0);
}


int main()
{
    struct sigaction act, oldact;
    act.sa_handler = handler;
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask, 3);
    sigaddset(&act.sa_mask, 4);
    act.sa_flags = 0;// 默认信号处理逻辑

    sigaction(SIGINT, &act, &oldact); // 对2号信号进行捕捉

    while(true)
    {
        std::cout << "I am a process, pid: " << getpid() << std::endl;
        sleep(1);
    }
    return 0;
}

//Linux内核0.11源码
void trap_init(void)
{
    int i;
    set_trap_gate(0,&divide_error);// 设置除操作出错的中断向量值。以下雷同。
    set_trap_gate(1,&debug);
    set_trap_gate(2,&nmi);
    set_system_gate(3,&int3); /* int3-5 can be called from all */
    set_system_gate(4,&overflow);
    set_system_gate(5,&bounds);
    set_trap_gate(6,&invalid_op);
    set_trap_gate(7,&device_not_available);
    set_trap_gate(8,&double_fault);
    set_trap_gate(9,&coprocessor_segment_overrun);
    set_trap_gate(10,&invalid_TSS);
    set_trap_gate(11,&segment_not_present);
    set_trap_gate(12,&stack_segment);
    set_trap_gate(13,&general_protection);
    set_trap_gate(14,&page_fault);
    set_trap_gate(15,&reserved);
    set_trap_gate(16,&coprocessor_error);
    // 下⾯将int17-48 的陷阱⻔先均设置为reserved，以后每个硬件初始化时会重新设置⾃⼰的陷阱⻔。
    for (i=17;i<48;i++)
        set_trap_gate(i,&reserved);
    set_trap_gate(45,&irq13);// 设置协处理器的陷阱⻔。
    outb_p(inb_p(0x21)&0xfb,0x21);// 允许主8259A 芯⽚的IRQ2 中断请求。
    outb(inb_p(0xA1)&0xdf,0xA1);// 允许从8259A 芯⽚的IRQ13 中断请求。
    set_trap_gate(39,&parallel_interrupt);// 设置并⾏⼝的陷阱⻔。
}
void rs_init (void)
{
    set_intr_gate (0x24, rs1_interrupt); // 设置串⾏⼝1 的中断⻔向量(硬件IRQ4信号)。
    set_intr_gate (0x23, rs2_interrupt); // 设置串⾏⼝2 的中断⻔向量(硬件IRQ3信号)。
    init (tty_table[1].read_q.data); // 初始化串⾏⼝1(.data 是端⼝号)。
    init (tty_table[2].read_q.data); // 初始化串⾏⼝2。
    outb (inb_p (0x21) & 0xE7, 0x21); // 允许主8259A 芯⽚的IRQ3，IRQ4 中断信号请求。
}

set_intr_gate(0x20, &timer_interrupt);  // 0x20向量→timer_interrupt

; x86示例
pushad   ; 保存通用寄存器
push ds
push es  ; 保存段寄存器

outb(0x20, 0x20);  // x86 8259A的EOI

sti();  // 显式开启中断，允许高优先级中断抢占

pop es
pop ds
popad  ; 恢复通用寄存器

// 在sched_init()中设置时钟中断
void sched_init(void) {
    // ...
    set_intr_gate(0x20, &timer_interrupt);  // 设置时钟中断处理程序
    outb(inb_p(0x21) & ~0x01, 0x21);        // 允许时钟中断(IRQ0)
    // ...
}

// 汇编代码：timer_interrupt
_timer_interrupt:
    push %ds
    push %eax
    movl $0x10, %eax
    mov %ax, %ds
    movb $0x20, %al
    outb %al, $0x20      # 向8259A发送EOI(中断结束)信号
    movl $0, %eax
    incl %eax
    movl %eax, jiffies   # 更新系统时钟滴答计数
    pushl $0x10          # 参数：CPL(当前特权级)
    call _do_timer       # 调用C函数处理定时任务
    popl %eax
    popl %eax
    pop %ds
    iret

// kernel/sched.c
void do_timer(long cpl) {
    extern int beepcount;
    extern void sysbeepstop(void);
    
    // 更新系统时间
    if (beepcount)
        if (!--beepcount)
            sysbeepstop();
    
    // 更新当前进程时间片
    if (--current->counter > 0)
        return;
    
    // 时间片用完，需要重新调度
    current->counter = 0;
    schedule();  // 调用调度程序
}

// kernel/sched.c
void schedule(void) {
    int i, next, c;
    struct task_struct **p;
    
    // 寻找就绪状态且counter值最大的进程
    while (1) {
        c = -1;
        next = 0;
        i = NR_TASKS;
        p = &task[NR_TASKS];
        
        while (--i) {
            if (!*--p)
                continue;
            if ((*p)->state == TASK_RUNNING && (*p)->counter > c)
                c = (*p)->counter, next = i;
        }
        
        if (c) break;  // 找到了可运行的进程
        
        // 所有进程的时间片都已用完，重新分配时间片
        for (p = &LAST_TASK; p > &FIRST_TASK; --p)
            if (*p)
                (*p)->counter = ((*p)->counter >> 1) + (*p)->priority;
    }
    
    // 切换到选中的进程
    switch_to(next);
}

// 重新计算时间片的公式
(*p)->counter = ((*p)->counter >> 1) + (*p)->priority;

if (timer++ % 2 == 0) pcb = pcb_A;  // 简单交替执行
else pcb = pcb_B; 

if (--current->time_slice <= 0) 
    move_to_expired_queue(current); 

void main(void) {
    // 初始化阶段：设置整个系统的基础设施
    mem_init();        // 内存管理初始化
    trap_init();       // 中断向量表初始化
    blk_dev_init();    // 块设备初始化
    sched_init();      // 调度器初始化
    // ... 其他初始化工作
    
    // 创建init进程（用户空间的第一个进程）
    if (!fork()) {
        init();
    }
    
    // 主循环：操作系统的"休息"状态
    for (;;) {
        pause();  // 等待中断发生
    }
}

// pause() 的简化实现
int pause(void) {
    // 将当前进程状态设为可中断睡眠
    current->state = TASK_INTERRUPTIBLE;
    
    // 调用调度器，选择其他进程运行
    schedule();
    
    // 当信号到达时，从这里恢复执行
    return -EINTR;
}

// 当时钟中断发生时
void timer_interrupt(void) {
    // 更新系统时间
    jiffies++;
    
    // 减少当前进程时间片
    current->counter--;
    
    // 如果时间片用完或需要调度
    if (current->counter <= 0) {
        schedule();  // 进程调度
    }
}

; 示例：调用write系统调用
mov eax, 4       ; 将write的系统调用号存入EAX
mov ebx, 1       ; 第一个参数：文件描述符(stdout)
mov ecx, buffer  ; 第二个参数：缓冲区地址
mov edx, length  ; 第三个参数：数据长度
int 0x80         ; 触发软中断

// 系统调用处理函数示例
asmlinkage long sys_getpid(void) {
    return current->pid;  // 返回值通过EAX传递给用户程序
}

// 读取文件数据的系统调用
asmlinkage long sys_read(unsigned int fd, char __user *buf, size_t count) {
    // ... 从文件读取数据
    copy_to_user(buf, kernel_buffer, bytes_read);  // 将数据复制到用户空间
    return bytes_read;  // 返回实际读取的字节数
}

// 用户程序中的错误处理
int fd = open("file.txt", O_RDONLY);
if (fd == -1) {
    // open系统调用返回-1，标准库设置errno
    perror("open failed");  // 输出"open failed: No such file or directory"
}

// 系统调用函数指针表
fn_ptr sys_call_table[] = {
    sys_setup, sys_exit, sys_fork, sys_read,
    sys_write, sys_open, sys_close, sys_waitpid,
    // ... 更多系统调用
};

// 通过系统调用号索引函数指针表
call [sys_call_table + eax * 4]

// 用户程序调用write()
write(fd, buffer, count);

// 标准库将其转换为系统调用
mov eax, 4       ; SYS_write = 4
mov ebx, fd      ; 文件描述符
mov ecx, buffer  ; 缓冲区地址
mov edx, count   ; 字节数
int 0x80         ; 触发软中断

; 系统调用入口点（kernel/system_call.s）
_system_call:
    ; 1. 验证系统调用号有效性
    cmp eax, nr_system_calls-1
    ja bad_sys_call
    
    ; 2. 保存用户态寄存器
    push ds
    push es
    push fs
    push edx
    push ecx
    push ebx
    
    ; 3. 设置内核数据段
    mov edx, 0x10
    mov ds, dx
    mov es, dx
    
    ; 4. 调用对应的系统调用处理函数
    call [sys_call_table + eax * 4]
    
    ; 5. 保存返回值
    push eax

// write系统调用的实现（fs/read_write.c）
int sys_write(unsigned int fd, char *buf, int count) {
    // ... 实际的文件写入逻辑
    return bytes_written;  // 返回写入的字节数
}

; 恢复上下文并返回
pop eax      ; 获取系统调用返回值
pop ebx      ; 恢复寄存器
pop ecx
pop edx
pop fs
pop es
pop ds
iret         ; 返回到用户空间

// sys.h
// 系统调⽤函数指针表。⽤于系统调⽤中断处理程序(int 0x80)，作为跳转表。
extern int sys_setup (); // 系统启动初始化设置函数。 (kernel/blk_drv/hd.c,71)
extern int sys_exit (); // 程序退出。 (kernel/exit.c, 137)
extern int sys_fork (); // 创建进程。 (kernel/system_call.s, 208)
extern int sys_read (); // 读⽂件。 (fs/read_write.c, 55)
extern int sys_write (); // 写⽂件。 (fs/read_write.c, 83)
extern int sys_open (); // 打开⽂件。 (fs/open.c, 138)
extern int sys_close (); // 关闭⽂件。 (fs/open.c, 192)
extern int sys_waitpid (); // 等待进程终⽌。 (kernel/exit.c, 142)
extern int sys_creat (); // 创建⽂件。 (fs/open.c, 187)
extern int sys_link (); // 创建⼀个⽂件的硬连接。 (fs/namei.c, 721)
extern int sys_unlink (); // 删除⼀个⽂件名(或删除⽂件)。 (fs/namei.c, 663)
extern int sys_execve (); // 执⾏程序。 (kernel/system_call.s, 200)
extern int sys_chdir (); // 更改当前⽬录。 (fs/open.c, 75)
extern int sys_time (); // 取当前时间。 (kernel/sys.c, 102)
extern int sys_mknod (); // 建⽴块/字符特殊⽂件。 (fs/namei.c, 412)
extern int sys_chmod (); // 修改⽂件属性。 (fs/open.c, 105)
extern int sys_chown (); // 修改⽂件宿主和所属组。 (fs/open.c, 121)
extern int sys_break (); // (-kernel/sys.c, 21)
extern int sys_stat (); // 使⽤路径名取⽂件的状态信息。 (fs/stat.c, 36)
extern int sys_lseek (); // 重新定位读/写⽂件偏移。 (fs/read_write.c, 25)
extern int sys_getpid (); // 取进程id。 (kernel/sched.c, 348)
extern int sys_mount (); // 安装⽂件系统。 (fs/super.c, 200)
extern int sys_umount (); // 卸载⽂件系统。 (fs/super.c, 167)
extern int sys_setuid (); // 设置进程⽤⼾id。 (kernel/sys.c, 143)
extern int sys_getuid (); // 取进程⽤⼾id。 (kernel/sched.c, 358)
extern int sys_stime (); // 设置系统时间⽇期。 (-kernel/sys.c, 148)
extern int sys_ptrace (); // 程序调试。 (-kernel/sys.c, 26)
extern int sys_alarm (); // 设置报警。 (kernel/sched.c, 338)
extern int sys_fstat (); // 使⽤⽂件句柄取⽂件的状态信息。(fs/stat.c, 47)
extern int sys_pause (); // 暂停进程运⾏。 (kernel/sched.c, 144)
extern int sys_utime (); // 改变⽂件的访问和修改时间。 (fs/open.c, 24)
extern int sys_stty (); // 修改终端⾏设置。 (-kernel/sys.c, 31)
extern int sys_gtty (); // 取终端⾏设置信息。 (-kernel/sys.c, 36)
extern int sys_access (); // 检查⽤⼾对⼀个⽂件的访问权限。(fs/open.c, 47)
extern int sys_nice (); // 设置进程执⾏优先权。 (kernel/sched.c, 378)
extern int sys_ftime (); // 取⽇期和时间。 (-kernel/sys.c,16)
extern int sys_sync (); // 同步⾼速缓冲与设备中数据。 (fs/buffer.c, 44)
extern int sys_kill (); // 终⽌⼀个进程。 (kernel/exit.c, 60)
extern int sys_rename (); // 更改⽂件名。 (-kernel/sys.c, 41)
extern int sys_mkdir (); // 创建⽬录。 (fs/namei.c, 463)
extern int sys_rmdir (); // 删除⽬录。 (fs/namei.c, 587)
extern int sys_dup (); // 复制⽂件句柄。 (fs/fcntl.c, 42)
extern int sys_pipe (); // 创建管道。 (fs/pipe.c, 71)
extern int sys_times (); // 取运⾏时间。 (kernel/sys.c, 156)
extern int sys_prof (); // 程序执⾏时间区域。 (-kernel/sys.c, 46)
extern int sys_brk (); // 修改数据段⻓度。 (kernel/sys.c, 168)
extern int sys_setgid (); // 设置进程组id。 (kernel/sys.c, 72)
extern int sys_getgid (); // 取进程组id。 (kernel/sched.c, 368)
extern int sys_signal (); // 信号处理。 (kernel/signal.c, 48)
extern int sys_geteuid (); // 取进程有效⽤⼾id。 (kenrl/sched.c, 363)
extern int sys_getegid (); // 取进程有效组id。 (kenrl/sched.c, 373)
extern int sys_acct (); // 进程记帐。 (-kernel/sys.c, 77)
extern int sys_phys (); // (-kernel/sys.c, 82)
extern int sys_lock (); // (-kernel/sys.c, 87)
extern int sys_ioctl (); // 设备控制。 (fs/ioctl.c, 30)
extern int sys_fcntl (); // ⽂件句柄操作。 (fs/fcntl.c, 47)
extern int sys_mpx (); // (-kernel/sys.c, 92)
extern int sys_setpgid (); // 设置进程组id。 (kernel/sys.c, 181)
extern int sys_ulimit (); // (-kernel/sys.c, 97)
extern int sys_uname (); // 显⽰系统信息。 (kernel/sys.c, 216)
extern int sys_umask (); // 取默认⽂件创建属性码。 (kernel/sys.c, 230)
extern int sys_chroot (); // 改变根系统。 (fs/open.c, 90)
extern int sys_ustat (); // 取⽂件系统信息。 (fs/open.c, 19)
extern int sys_dup2 (); // 复制⽂件句柄。 (fs/fcntl.c, 36)
extern int sys_getppid (); // 取⽗进程id。 (kernel/sched.c, 353)
extern int sys_getpgrp (); // 取进程组id，等于getpgid(0)。(kernel/sys.c, 201)
extern int sys_setsid (); // 在新会话中运⾏程序。 (kernel/sys.c, 206)
extern int sys_sigaction (); // 改变信号处理过程。 (kernel/signal.c, 63)
extern int sys_sgetmask (); // 取信号屏蔽码。 (kernel/signal.c, 15)
extern int sys_ssetmask (); // 设置信号屏蔽码。 (kernel/signal.c, 20)
extern int sys_setreuid (); // 设置真实与/或有效⽤⼾id。 (kernel/sys.c,118)
extern int sys_setregid (); // 设置真实与/或有效组id。 (kernel/sys.c, 51)


// 系统调⽤函数指针表。⽤于系统调⽤中断处理程序(int 0x80)，作为跳转表。
fn_ptr sys_call_table[] = { sys_setup, sys_exit, sys_fork, sys_read,
    sys_write, sys_open, sys_close, sys_waitpid, sys_creat, sys_link,
    sys_unlink, sys_execve, sys_chdir, sys_time, sys_mknod, sys_chmod,
    sys_chown, sys_break, sys_stat, sys_lseek, sys_getpid, sys_mount,
    sys_umount, sys_setuid, sys_getuid, sys_stime, sys_ptrace, sys_alarm,
    sys_fstat, sys_pause, sys_utime, sys_stty, sys_gtty, sys_access,
    sys_nice, sys_ftime, sys_sync, sys_kill, sys_rename, sys_mkdir,
    sys_rmdir, sys_dup, sys_pipe, sys_times, sys_prof, sys_brk, sys_setgid,
    sys_getgid, sys_signal, sys_geteuid, sys_getegid, sys_acct, sys_phys,
    sys_lock, sys_ioctl, sys_fcntl, sys_mpx, sys_setpgid, sys_ulimit,
    sys_uname, sys_umask, sys_chroot, sys_ustat, sys_dup2, sys_getppid,
    sys_getpgrp, sys_setsid, sys_sigaction, sys_sgetmask, sys_ssetmask,
    sys_setreuid, sys_setregid
};

// 调度程序的初始化⼦程序。
void sched_init(void)
{
    ...
    // 设置系统调⽤中断⻔。
    set_system_gate(0x80, &system_call);
}

_system_call:
    cmp eax,nr_system_calls-1 ;// 调⽤号如果超出范围的话就在eax 中置-1 并退出。
    ja bad_sys_call
    push ds ;// 保存原段寄存器值。
    push es
    push fs
    push edx ;// ebx,ecx,edx 中放着系统调⽤相应的C 语⾔函数的调⽤参数。
    push ecx ;// push %ebx,%ecx,%edx as parameters
    push ebx ;// to the system call
    mov edx,10h ;// set up ds,es to kernel space
    mov ds,dx ;// ds,es 指向内核数据段(全局描述符表中数据段描述符)。
    mov es,dx
    mov edx,17h ;// fs points to local data space
    mov fs,dx ;// fs 指向局部数据段(局部描述符表中数据段描述符)。
;// 下⾯这句操作数的含义是：调⽤地址 = _sys_call_table + %eax * 4。参⻅列表后的说明。
;// 对应的C 程序中的sys_call_table 在include/linux/sys.h 中，其中定义了⼀个包括72个
;// 系统调⽤C 处理函数的地址数组表。
    call [_sys_call_table+eax*4]
    push eax ;// 把系统调⽤号⼊栈。
    mov eax,_current ;// 取当前任务（进程）数据结构地址??eax。
;// 下⾯97-100 ⾏查看当前任务的运⾏状态。如果不在就绪状态(state 不等于0)就去执⾏调度程序。
;// 如果该任务在就绪状态但counter[??]值等于0，则也去执⾏调度程序。
    cmp dword ptr [state+eax],0 ;// state
    jne reschedule
    cmp dword ptr [counter+eax],0 ;// counter
    je reschedule
;// 以下这段代码执⾏从系统调⽤C 函数返回后，对信号量进⾏识别处理。
ret_from_sys_call:

// 伪代码：glibc 对 write() 的封装
ssize_t write(int fd, const void *buf, size_t count) {
    if (buf == NULL) return -EFAULT;  // 指针有效性校验
    if (count > MAX_IO_SIZE) return -EINVAL; // 参数范围校验
    return syscall(SYS_write, fd, buf, count); // 安全转入内核
}

// 应用程序员看到的接口
int fd = open("file.txt", O_RDONLY);

// glibc内部的实现大致如下：
int open(const char *pathname, int flags, mode_t mode) {
    #ifdef __i386__
        return syscall(SYS_open, pathname, flags, mode);
    #elif __x86_64__
        return syscall(SYS_open, pathname, flags, mode);
    #elif __arm__
        return syscall(SYS_open, pathname, flags, mode);
    // ... 其他架构
    #endif
}

// 内核头文件中的系统调用号定义（如asm/unistd_32.h）
#define __NR_restart_syscall 0
#define __NR_exit 1
#define __NR_fork 2
#define __NR_read 3
#define __NR_write 4
#define __NR_open 5
// ...

// glibc中的封装宏
#define SYS_ify(syscall_name) __NR_##syscall_name

// 使用示例
int syscall_num = SYS_ify(open); // 展开为 __NR_open

// i386架构的实现（使用int 0x80）
#define INTERNAL_SYSCALL(name, err, nr, args...) \
    internal_syscall##nr (__NR_##name, err, args)

// x86_64架构的实现（使用syscall）
#define INTERNAL_SYSCALL(name, err, nr, args...) \
    internal_syscall##nr (__NR_##name, err, args)

#define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
({ \
    unsigned long int resultvar; \
    LOAD_ARGS_##nr (args) \          // 加载参数到寄存器
    LOAD_REGS_##nr \                 // 设置寄存器
    asm volatile ( \
        "syscall\n\t" \              // 执行syscall指令
        : "=a" (resultvar) \         // 输出：结果放在resultvar
        : "0" (name) ASM_ARGS_##nr \ // 输入：系统调用号和参数
        : "memory", "cc", "r11", "cx" \ // 破坏的寄存器
    ); \
    (long int) resultvar; \          // 返回结果
})

// 加载3个参数的宏
#define LOAD_ARGS_3(a1, a2, a3) \
    register unsigned long int _a1 __asm__ ("rdi") = (unsigned long int) (a1); \
    register unsigned long int _a2 __asm__ ("rsi") = (unsigned long int) (a2); \
    register unsigned long int _a3 __asm__ ("rdx") = (unsigned long int) (a3);

#define ASM_ARGS_3 , "r" (_a1), "r" (_a2), "r" (_a3)

// 传统int 0x80方式（i386）
#define INTERNAL_SYSCALL_INT80(name, err, nr, args...) \
({ \
    unsigned long int resultvar; \
    asm volatile ( \
        "int $0x80\n\t" \
        : "=a" (resultvar) \
        : "a" (__NR_##name) ASM_ARGS_##nr \
        : "memory", "cc" \
    ); \
    (long int) resultvar; \
})

// 现代syscall方式（x86_64）
#define INTERNAL_SYSCALL_SYSCALL(name, err, nr, args...) \
({ \
    unsigned long int resultvar; \
    asm volatile ( \
        "syscall\n\t" \
        : "=a" (resultvar) \
        : "0" (__NR_##name) ASM_ARGS_##nr \
        : "memory", "cc", "r11", "cx" \
    ); \
    (long int) resultvar; \
})

void* vsyscall_page = map_vsyscall(); // 映射内核提供的陷入指令页

if (cpu_supports_syscall()) {
    vsyscall_page->entry = syscall_instruction; // 64位优先使用 syscall
} else if (cpu_supports_sysenter()) {
    vsyscall_page->entry = sysenter_instruction; // 32位新机器用 sysenter
} else {
    vsyscall_page->entry = int80_instruction; // 旧机器回退到 int 0x80
}

// Linux 0.11处理逻辑
void do_page_fault(struct pt_regs *regs) {
    unsigned long address = read_cr2();  // 读取触发地址
    if (handle_vmalloc_fault(address))   // 处理vmalloc区域
        return;
    if (handle_copy_on_write(address))  // 写时复制处理
        return;
    __do_page_fault(address);           // 核心页表处理
}

// Linux 0.11异常处理链
void divide_error(void) {
    send_signal(current, SIGFPE);  // 发送浮点异常信号
}

void general_protection(void) {
    if (is_user_ptr_fault())       // 检查是否用户态野指针
        send_signal(current, SIGSEGV); // 发送段错误信号
    else
        kernel_panic();            // 内核态错误直接崩溃
}

void trap_init(void)
{
    int i;

    set_trap_gate(0,&divide_error);// 设置除操作出错的中断向量值。以下雷同。
    set_trap_gate(1,&debug);
    set_trap_gate(2,&nmi);
    set_system_gate(3,&int3); /* int3-5 can be called from all */
    set_system_gate(4,&overflow);
    set_system_gate(5,&bounds);
    set_trap_gate(6,&invalid_op);
    set_trap_gate(7,&device_not_available);
    set_trap_gate(8,&double_fault);
    set_trap_gate(9,&coprocessor_segment_overrun);
    set_trap_gate(10,&invalid_TSS);
    set_trap_gate(11,&segment_not_present);
    set_trap_gate(12,&stack_segment);
    set_trap_gate(13,&general_protection);
    set_trap_gate(14,&page_fault);
    set_trap_gate(15,&reserved);
    set_trap_gate(16,&coprocessor_error);
    // 下⾯将int17-48 的陷阱⻔先均设置为reserved，以后每个硬件初始化时会重新设置⾃⼰的陷阱⻔。
    for (i=17;i<48;i++)
        set_trap_gate(i,&reserved);
    set_trap_gate(45,&irq13);// 设置协处理器的陷阱⻔。
    outb_p(inb_p(0x21)&0xfb,0x21);// 允许主8259A 芯⽚的IRQ2 中断请求。
    outb(inb_p(0xA1)&0xdf,0xA1);// 允许从8259A 芯⽚的IRQ13 中断请求。
    set_trap_gate(39,&parallel_interrupt);// 设置并⾏⼝的陷阱⻔。
}

mov eax, 4    ; sys_write调用号
int 0x80      ; 主动触发陷阱
; 返回后继续执行此处

// CPU通过当前特权级别(CPL)控制访问权限
#define USER_CPL   3  // 用户态特权级
#define KERNEL_CPL 0  // 内核态特权级

; 系统调用入口的硬件检查流程
system_call_entry:
    ; 1. 检查目标代码段的DPL(描述符特权级)是否允许当前CPL调用
    ; 如果CPL > DPL，触发通用保护异常(#GP)
    
    ; 2. 检查中断描述符表(IDT)的门描述符类型
    ; 确保只能通过正确的门类型进入内核
    
    ; 3. 自动切换栈指针到内核栈
    ; 防止用户栈污染内核
    
    ; 4. 保存用户态寄存器状态
    ; 保证能够正确返回

// 页表项中的保护位
#define _PAGE_PRESENT   0x001  // 页存在
#define _PAGE_RW        0x002  // 可写
#define _PAGE_USER      0x004  // 用户可访问
#define _PAGE_SUPERVISOR 0x000 // 只能内核访问

// 内核页表设置：用户空间可访问，内核空间仅内核可访问
void setup_page_tables(void) {
    // 用户空间页表：设置_USER标志
    set_page_flags(user_vaddr, _PAGE_PRESENT | _PAGE_RW | _PAGE_USER);
    
    // 内核空间页表：不设置_USER标志
    set_page_flags(kernel_vaddr, _PAGE_PRESENT | _PAGE_RW);
}

// 系统调用参数安全检查
asmlinkage long sys_write(unsigned int fd, const char __user *buf, size_t count) {
    // 1. 检查文件描述符有效性
    if (fd >= NR_OPEN) return -EBADF;
    
    // 2. 检查用户指针有效性（重要！）
    if (!access_ok(VERIFY_READ, buf, count))
        return -EFAULT;
    
    // 3. 检查计数合理性
    if (count > MAX_WRITE_SIZE) return -EINVAL;
    
    // 只有通过所有检查才会真正执行操作
    return do_write(fd, buf, count);
}

用户程序调用系统调用 → 执行int 0x80/syscall
    ↓
CPU自动进行特权级检查（CPL vs DPL）
    ↓
如果检查失败 → 触发#GP异常 → 杀死进程
    ↓
如果检查通过 → 切换栈指针到内核栈
    ↓
保存用户态寄存器状态
    ↓
根据系统调用号查找系统调用表
    ↓
执行对应的内核函数（进行参数验证）
    ↓
完成操作后返回用户态

void insert(Node* node) {
    node->next = head;  // 步骤1
    head = node;        // 步骤2
}

// 可重入的函数示例
int add(int a, int b) {
    int result;          // 局部变量，在栈上分配
    result = a + b;      // 只操作局部变量和参数
    return result;
}

进程地址空间:
┌────────────────┐
│    栈区         │ ← 每个函数调用有自己的栈帧
│   (Stack)      │   局部变量在这里分配
├────────────────┤
│    堆区         │
│    (Heap)      │ ← 全局变量和malloc内存在这里
├────────────────┤
│   数据区        │ ← 全局变量在这里
│   (Data)       │
├────────────────┤
│   代码区        │
│   (Text)       │
└────────────────┘

// malloc内部伪代码
void* malloc(size_t size) {
    static HeapSegment* free_list; // 全局空闲链表
    
    lock_mutex();       // 线程安全但不可重入！
    HeapSegment* block = find_free_block(free_list);
    unlock_mutex();
    return block;
}

void log_message(const char* msg) {
    static FILE* logfile; // 静态变量！
    if (!logfile) logfile = fopen("app.log", "a");
    fprintf(logfile, "%s\n", msg); // 使用全局I/O缓冲区
}

// 安全版本链表插入
void reentrant_insert(Node** head_ptr, Node* node) {
    node->next = *head_ptr;  // 通过指针参数访问
    *head_ptr = node;        // 修改调用者提供的指针
}

Node* private_list = NULL; // 每个控制流独立维护

// main函数
reentrant_insert(&private_list, node1);

// 信号处理函数
reentrant_insert(&sig_list, node2); // 使用独立链表

__thread Node* thread_local_head; // GCC扩展

void thread_safe_insert(Node* node) {
    node->next = thread_local_head;
    thread_local_head = node;
}

// 典型信号安全函数
_Exit()     abort()     accept()     access()
alarm()     bind()      cfgetispeed() cfgetospeed()
...
write()     // 部分实现安全

void signal_handler(int sig) {
    // 1. 仅设置原子标志
    volatile sig_atomic_t flag = 1;
    
    // 2. 通过管道通知主循环
    char byte = 1;
    write(self_pipe[1], &byte, 1); // write是信号安全的
}

while (read(self_pipe[0], &byte, 1) > 0) {
    // 在安全环境执行实际逻辑
    process_signal_events();
}