（三）内核那些事儿：CPU中断和信号

// 低效的轮询方式
void inefficient_polling() {
    while (1) {
        if (keyboard_has_data()) {
            process_keyboard_input();
        }
        if (network_has_packet()) {
            process_network_packet();
        }
        if (timer_expired()) {
            handle_timer_event();
        }
        // CPU 大量时间浪费在轮询上
    }
}

// 中断分类的系统性定义
enum interrupt_source {
    // 外部硬件中断
    EXTERNAL_HARDWARE,    // 键盘、鼠标、网卡等外设

    // 内部硬件中断
    INTERNAL_HARDWARE,    // CPU内部定时器、性能计数器

    // 软件中断
    SOFTWARE_INTERRUPT,   // 系统调用、软件模拟的中断

    // CPU异常
    CPU_EXCEPTION        // 除零、缺页、保护违例等
};

// 中断描述符的完整结构
struct interrupt_descriptor {
    uint32_t interrupt_number;     // 中断号
    enum interrupt_source source;  // 中断源类型
    uint8_t priority_level;        // 优先级
    uint32_t flags;               // 中断属性标志

    // 处理函数指针
    void (*handler)(struct interrupt_context *ctx);

    // 统计信息
    uint64_t trigger_count;       // 触发次数
    uint64_t total_time;          // 总处理时间
    uint64_t max_time;            // 最大处理时间
};

// 中断优先级系统
enum interrupt_priority {
    IRQ_PRIORITY_NMI = 0,         // 不可屏蔽中断(最高)
    IRQ_PRIORITY_MACHINE_CHECK,   // 机器检查异常
    IRQ_PRIORITY_TIMER,           // 系统定时器
    IRQ_PRIORITY_KEYBOARD,        // 键盘输入
    IRQ_PRIORITY_NETWORK,         // 网络中断
    IRQ_PRIORITY_DISK,           // 磁盘I/O
    IRQ_PRIORITY_USER_SIGNAL,    // 用户信号(最低)
    IRQ_PRIORITY_MAX
};

// 优先级管理结构
struct priority_manager {
    // 当前中断优先级
    enum interrupt_priority current_level;

    // 各优先级的中断计数
    atomic_t pending_count[IRQ_PRIORITY_MAX];

    // 优先级掩码
    uint32_t priority_mask;

    // 嵌套深度控制
    int nested_depth;
    int max_nested_depth;
};

// 硬件中断的发生过程
struct hardware_interrupt_process {
    // 1. 外设事件发生
    void device_event_occurs() {
        // 设备完成某项操作（如数据接收完成）
        device_status_register |= DEVICE_DATA_READY;

        // 如果中断使能，向中断控制器发送中断请求
        if (device_interrupt_enabled()) {
            interrupt_controller_send_irq(device_irq_number);
        }
    }

    // 2. 中断控制器处理
    void interrupt_controller_process() {
        // 中断控制器接收多个设备的中断请求
        // 按优先级排序并向CPU发送中断信号
        int highest_priority_irq = get_highest_priority_pending_irq();

        if (cpu_interrupt_enabled() &&
            irq_priority[highest_priority_irq] > current_cpu_priority) {
            // 向CPU发送中断信号
            cpu_interrupt_line_assert(highest_priority_irq);
        }
    }

    // 3. CPU响应中断
    void cpu_interrupt_response() {
        // CPU在指令边界检查中断信号
        if (interrupt_signal_pending() && interrupts_enabled()) {
            // 开始中断处理流程
            handle_interrupt();
        }
    }
};

// 通用中断处理框架
void generic_interrupt_handler(struct interrupt_context *ctx) {
    int irq_number = ctx->interrupt_number;
    struct interrupt_descriptor *desc = &interrupt_table[irq_number];

    // 1. 中断统计与监控
    desc->trigger_count++;
    uint64_t start_time = get_cycle_count();

    // 2. 关键中断的快速路径
    if (desc->flags & IRQ_FLAG_FAST_PATH) {
        handle_fast_interrupt(irq_number, ctx);
        goto interrupt_done;
    }

    // 3. 常规中断处理
    // 3.1 确认中断（向中断控制器发送EOI）
    interrupt_controller_ack(irq_number);

    // 3.2 启用中断嵌套（如果允许）
    if (desc->flags & IRQ_FLAG_NESTABLE) {
        enable_interrupts();
    }

    // 3.3 调用具体的中断处理函数
    if (desc->handler) {
        desc->handler(ctx);
    }

    // 3.4 处理底半部（延迟工作）
    if (desc->flags & IRQ_FLAG_HAS_BOTTOM_HALF) {
        schedule_bottom_half(irq_number);
    }

interrupt_done:
    // 4. 更新统计信息
    uint64_t end_time = get_cycle_count();
    uint64_t elapsed = end_time - start_time;
    desc->total_time += elapsed;
    if (elapsed > desc->max_time) {
        desc->max_time = elapsed;
    }

    // 5. 检查是否需要进程调度
    if (ctx->flags & CTX_FLAG_PREEMPT_NEEDED) {
        schedule();
    }
}

// 现代x86-64的系统调用机制（SYSCALL/SYSRET）
struct syscall_context {
    // 保存的用户态寄存器
    uint64_t user_rax, user_rbx, user_rcx, user_rdx;
    uint64_t user_rsi, user_rdi, user_rbp, user_rsp;
    uint64_t user_r8, user_r9, user_r10, user_r11;
    uint64_t user_r12, user_r13, user_r14, user_r15;

    // 用户态执行状态
    uint64_t user_rip;          // 用户态返回地址
    uint64_t user_rflags;       // 用户态标志寄存器
    uint16_t user_cs, user_ss;   // 用户态段寄存器

    // 系统调用信息
    uint64_t syscall_number;    // 系统调用号
    uint64_t parameters[6];     // 系统调用参数
    uint64_t return_value;      // 返回值
    int error_code;            // 错误码
};

// 系统调用入口点
asmlinkage long system_call_handler(struct syscall_context *ctx) {
    long ret;

    // 1. 安全检查
    if (ctx->syscall_number >= NR_SYSCALLS) {
        return -ENOSYS;
    }

    // 2. 权限检查
    if (!syscall_permission_check(ctx->syscall_number)) {
        return -EPERM;
    }

    // 3. 参数验证和复制
    if (validate_syscall_parameters(ctx) < 0) {
        return -EINVAL;
    }

    // 4. 调用具体的系统调用实现
    ret = (*sys_call_table[ctx->syscall_number])(
        ctx->parameters[0], ctx->parameters[1], ctx->parameters[2],
        ctx->parameters[3], ctx->parameters[4], ctx->parameters[5]
    );

    // 5. 结果处理
    ctx->return_value = ret;

    return ret;
}

// 信号机制要解决的核心问题
struct signal_design_goals {
    // 1. 异步通知能力
    bool asynchronous_notification;

    // 2. 进程间通信
    bool inter_process_communication;

    // 3. 系统事件传递
    bool system_event_delivery;

    // 4. 用户控制接口
    bool user_control_interface;

    // 5. 简单编程模型
    bool simple_programming_model;
};

// 信号系统的历史演进
enum signal_evolution {
    // 第一代：简单信号（Unix V6/V7）
    SIMPLE_SIGNALS,           // 基本的进程终止和停止

    // 第二代：可靠信号（4.2BSD）
    RELIABLE_SIGNALS,         // 引入信号屏蔽和排队

    // 第三代：实时信号（POSIX.1b）
    REALTIME_SIGNALS,         // 支持优先级和附加数据

    // 第四代：现代扩展（Linux/现代Unix）
    MODERN_EXTENSIONS         // signalfd, eventfd等新机制
};

// 现代信号系统的特性
struct modern_signal_features {
    // 标准信号（1-31）
    int standard_signals[31];

    // 实时信号（32-64）
    int realtime_signals[33];

    // 信号排队支持
    bool signal_queuing;

    // 信号信息传递
    bool signal_information;

    // 异步安全保证
    bool async_signal_safety;

    // 现代同步接口
    bool synchronous_interfaces;
};

// 信号产生的完整分类
enum signal_generation {
    // 1. 硬件异常转换
    HARDWARE_EXCEPTION_SIGNAL,   // 除零、段错误等

    // 2. 内核事件通知
    KERNEL_EVENT_SIGNAL,         // 子进程退出、定时器到期

    // 3. 用户显式发送
    USER_EXPLICIT_SIGNAL,        // kill()、raise()等

    // 4. 终端操作触发
    TERMINAL_SIGNAL,             // Ctrl+C、Ctrl+Z等

    // 5. 资源限制违反
    RESOURCE_LIMIT_SIGNAL        // CPU时间、文件大小超限
};

// 信号生成的内核实现
struct signal_generation_context {
    struct task_struct *sender;     // 发送者进程
    struct task_struct *target;     // 目标进程
    int signal_number;              // 信号编号
    siginfo_t signal_info;          // 信号附加信息
    enum signal_generation source;   // 信号来源

    // 权限验证
    bool permission_granted;

    // 发送时间戳
    struct timespec send_time;
};

// 信号发送的内核核心函数
int send_signal_internal(int sig, siginfo_t *info,
                         struct task_struct *target, int group) {
    struct sigpending *pending;
    struct sigqueue *q;
    unsigned long flags;

    // 1. 权限检查
    if (!signal_permission_check(current, target, sig)) {
        return -EPERM;
    }

    // 2. 目标进程状态检查
    if (target->state == TASK_DEAD) {
        return -ESRCH;
    }

    // 3. 信号屏蔽检查
    if (sigismember(&target->blocked, sig)) {
        // 如果信号被屏蔽，仍然需要排队（除非是SIGKILL/SIGSTOP）
        if (sig != SIGKILL && sig != SIGSTOP) {
            goto queue_signal;
        }
    }

    // 4. 特殊信号处理
    if (sig == SIGKILL || sig == SIGSTOP) {
        // 这些信号不能被忽略或捕获
        return force_signal_delivery(sig, target);
    }

queue_signal:
    // 5. 确定信号队列
    if (group) {
        pending = &target->signal->shared_pending;
    } else {
        pending = &target->pending;
    }

    spin_lock_irqsave(&target->sighand->siglock, flags);

    // 6. 实时信号特殊处理
    if (sig >= SIGRTMIN && sig <= SIGRTMAX) {
        // 实时信号需要排队
        q = allocate_sigqueue(sig, target);
        if (q) {
            list_add_tail(&q->list, &pending->list);
            copy_siginfo(&q->info, info);
        }
    } else {
        // 标准信号只设置位标志
        sigaddset(&pending->signal, sig);
    }

    // 7. 唤醒目标进程
    signal_wake_up_state(target, sig == SIGKILL ? TASK_WAKEKILL : 0);

    spin_unlock_irqrestore(&target->sighand->siglock, flags);

    return 0;
}

// 信号队列管理
struct signal_queue_manager {
    // 标准信号队列（位图方式）
    sigset_t standard_pending;

    // 实时信号队列（链表方式）
    struct list_head realtime_queue;

    // 队列统计
    atomic_t queue_depth;
    atomic_t max_queue_depth;

    // 内存管理
    struct kmem_cache *sigqueue_cache;
    atomic_t allocated_sigqueues;
};

// 信号优先级处理
int dequeue_signal(sigset_t *mask, siginfo_t *info) {
    struct sigpending *pending = &current->pending;
    struct sigqueue *q;
    unsigned long flags;
    int sig = 0;

    spin_lock_irqsave(&current->sighand->siglock, flags);

    // 1. 首先检查标准信号（按编号顺序）
    sig = next_signal(pending, mask);
    if (sig) {
        if (sig < SIGRTMIN) {
            // 标准信号：清除位标志
            sigdelset(&pending->signal, sig);

            // 填充基本信号信息
            info->si_signo = sig;
            info->si_errno = 0;
            info->si_code = SI_USER;
        } else {
            // 实时信号：从队列中取出
            q = list_first_entry(&pending->list, struct sigqueue, list);
            list_del_init(&q->list);
            copy_siginfo(info, &q->info);
            __sigqueue_free(q);
        }
    }

    // 2. 检查进程组信号
    if (!sig) {
        sig = dequeue_group_signal(mask, info);
    }

    spin_unlock_irqrestore(&current->sighand->siglock, flags);

    return sig;
}

// 信号默认动作定义
enum signal_default_action {
    SIGACT_IGNORE,     // 忽略信号
    SIGACT_TERMINATE,  // 终止进程
    SIGACT_COREDUMP,   // 终止进程并生成核心转储
    SIGACT_STOP,       // 停止进程
    SIGACT_CONTINUE    // 继续进程
};

// 各信号的默认动作表
static const enum signal_default_action signal_defaults[_NSIG] = {
    [SIGHUP]  = SIGACT_TERMINATE,
    [SIGINT]  = SIGACT_TERMINATE,
    [SIGQUIT] = SIGACT_COREDUMP,
    [SIGILL]  = SIGACT_COREDUMP,
    [SIGTRAP] = SIGACT_COREDUMP,
    [SIGABRT] = SIGACT_COREDUMP,
    [SIGFPE]  = SIGACT_COREDUMP,
    [SIGKILL] = SIGACT_TERMINATE,  // 不可改变
    [SIGSEGV] = SIGACT_COREDUMP,
    [SIGPIPE] = SIGACT_TERMINATE,
    [SIGALRM] = SIGACT_TERMINATE,
    [SIGTERM] = SIGACT_TERMINATE,
    [SIGCHLD] = SIGACT_IGNORE,
    [SIGCONT] = SIGACT_CONTINUE,
    [SIGSTOP] = SIGACT_STOP,       // 不可改变
    [SIGTSTP] = SIGACT_STOP,
    // ... 更多信号
};

// 执行默认动作
void do_signal_default_action(int sig) {
    enum signal_default_action action = signal_defaults[sig];

    switch (action) {
    case SIGACT_IGNORE:
        // 什么都不做
        break;

    case SIGACT_TERMINATE:
        do_exit_group(sig);
        break;

    case SIGACT_COREDUMP:
        do_coredump(sig);
        do_exit_group(sig);
        break;

    case SIGACT_STOP:
        do_signal_stop(sig);
        break;

    case SIGACT_CONTINUE:
        do_signal_continue();
        break;
    }
}

// 信号忽略的实现
void signal_ignore_setup() {
    struct sigaction ignore_action;

    // 设置忽略动作
    ignore_action.sa_handler = SIG_IGN;
    sigemptyset(&ignore_action.sa_mask);
    ignore_action.sa_flags = 0;

    // 应用到特定信号
    sigaction(SIGPIPE, &ignore_action, NULL);
}

// 内核中的忽略处理
static inline bool signal_ignored(struct task_struct *t, int sig) {
    struct k_sigaction *ka = &t->sighand->action[sig - 1];

    // 检查是否设置为忽略
    if (ka->sa.sa_handler == SIG_IGN) {
        return true;
    }

    // 默认忽略的信号
    if (ka->sa.sa_handler == SIG_DFL && signal_defaults[sig] == SIGACT_IGNORE) {
        return true;
    }

    return false;
}

// 高级信号处理的完整示例
struct advanced_signal_handler {
    // 信号处理函数
    void (*handler)(int, siginfo_t *, void *);

    // 信号掩码
    sigset_t blocked_signals;

    // 处理标志
    int flags;

    // 替代栈
    stack_t signal_stack;

    // 统计信息
    unsigned long handle_count;
    struct timespec last_handled;
};

// 现代信号处理注册
int setup_advanced_signal_handler(int sig) {
    struct sigaction sa;
    stack_t ss;

    // 1. 设置替代信号栈
    ss.ss_sp = malloc(SIGSTKSZ);
    ss.ss_size = SIGSTKSZ;
    ss.ss_flags = 0;

    if (sigaltstack(&ss, NULL) == -1) {
        perror("sigaltstack");
        return -1;
    }

    // 2. 配置信号处理
    sa.sa_sigaction = advanced_signal_handler;
    sigemptyset(&sa.sa_mask);

    // 屏蔽其他信号在处理期间
    sigaddset(&sa.sa_mask, SIGINT);
    sigaddset(&sa.sa_mask, SIGTERM);

    // 设置标志
    sa.sa_flags = SA_SIGINFO |     // 使用扩展信息
                  SA_ONSTACK |     // 使用替代栈
                  SA_RESTART;      // 自动重启被中断的系统调用

    // 3. 注册处理函数
    if (sigaction(sig, &sa, NULL) == -1) {
        perror("sigaction");
        return -1;
    }

    return 0;
}

// 高级信号处理函数
void advanced_signal_handler(int sig, siginfo_t *info, void *ucontext) {
    ucontext_t *uc = (ucontext_t *)ucontext;

    // 1. 记录信号信息
    printf("信号 %d 来自进程 %d\n", sig, info->si_pid);
    printf("信号原因: %d, 错误码: %d\n", info->si_code, info->si_errno);

    // 2. 根据信号类型处理
    switch (sig) {
    case SIGSEGV:
        printf("段错误发生在地址: %p\n", info->si_addr);
        print_stack_trace(uc);
        break;

    case SIGFPE:
        printf("浮点异常，错误地址: %p\n", info->si_addr);
        break;

    case SIGCHLD:
        handle_child_signal(info);
        break;

    default:
        printf("处理通用信号: %d\n", sig);
    }

    // 3. 可选：修改上下文后继续执行
    if (sig == SIGSEGV && can_recover_from_segv(info)) {
        // 修复错误并继续
        fix_segmentation_fault(uc, info);
    }
}

// 使用signalfd进行同步信号处理
#include <sys/signalfd.h>

struct modern_signal_processor {
    int signal_fd;                  // signalfd文件描述符
    sigset_t monitored_signals;     // 监控的信号集
    struct epoll_event events[16];  // epoll事件数组
    int epoll_fd;                   // epoll文件描述符
};

// 初始化现代信号处理
int init_modern_signal_handling() {
    struct modern_signal_processor *processor = &global_processor;

    // 1. 设置要监控的信号
    sigemptyset(&processor->monitored_signals);
    sigaddset(&processor->monitored_signals, SIGINT);
    sigaddset(&processor->monitored_signals, SIGTERM);
    sigaddset(&processor->monitored_signals, SIGCHLD);
    sigaddset(&processor->monitored_signals, SIGUSR1);

    // 2. 阻塞这些信号的传统处理
    if (sigprocmask(SIG_BLOCK, &processor->monitored_signals, NULL) == -1) {
        perror("sigprocmask");
        return -1;
    }

    // 3. 创建signalfd
    processor->signal_fd = signalfd(-1, &processor->monitored_signals,
                                   SFD_CLOEXEC | SFD_NONBLOCK);
    if (processor->signal_fd == -1) {
        perror("signalfd");
        return -1;
    }

    // 4. 创建epoll实例
    processor->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
    if (processor->epoll_fd == -1) {
        perror("epoll_create1");
        return -1;
    }

    // 5. 将signalfd添加到epoll中
    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = processor->signal_fd;

    if (epoll_ctl(processor->epoll_fd, EPOLL_CTL_ADD,
                  processor->signal_fd, &ev) == -1) {
        perror("epoll_ctl");
        return -1;
    }

    return 0;
}

// 同步处理信号
void process_signals_synchronously() {
    struct modern_signal_processor *processor = &global_processor;

    while (1) {
        // 1. 等待信号或其他事件
        int nfds = epoll_wait(processor->epoll_fd, processor->events,
                             16, -1);

        if (nfds == -1) {
            if (errno == EINTR) continue;
            perror("epoll_wait");
            break;
        }

        // 2. 处理事件
        for (int i = 0; i < nfds; i++) {
            if (processor->events[i].data.fd == processor->signal_fd) {
                handle_signalfd_events();
            }
        }
    }
}

// 处理signalfd事件
void handle_signalfd_events() {
    struct signalfd_siginfo si;
    ssize_t s;

    while ((s = read(global_processor.signal_fd, &si, sizeof(si))) == sizeof(si)) {
        printf("接收到信号: %d\n", si.ssi_signo);
        printf("发送者PID: %d\n", si.ssi_pid);
        printf("发送者UID: %d\n", si.ssi_uid);

        switch (si.ssi_signo) {
        case SIGINT:
        case SIGTERM:
            printf("收到终止信号，开始清理...\n");
            cleanup_and_exit();
            break;

        case SIGCHLD:
            printf("子进程 %d 退出，状态: %d\n",
                   si.ssi_pid, si.ssi_status);
            reap_child_processes();
            break;

        case SIGUSR1:
            printf("收到用户定义信号1\n");
            handle_user_request();
            break;
        }
    }
}

// 从硬件事件到应用响应的完整流程
struct event_processing_pipeline {
    // 阶段1：硬件事件检测
    struct hardware_stage {
        void (*detect_event)(void);        // 事件检测
        void (*generate_interrupt)(int);   // 产生中断
        void (*notify_controller)(int);    // 通知中断控制器
    } hardware;

    // 阶段2：中断处理
    struct interrupt_stage {
        void (*save_context)(void);        // 保存上下文
        void (*handle_interrupt)(int);     // 处理中断
        void (*decide_signal)(int);        // 决定是否产生信号
    } interrupt;

    // 阶段3：信号生成
    struct signal_stage {
        void (*generate_signal)(int, int); // 生成信号
        void (*queue_signal)(int, int);    // 信号排队
        void (*wake_process)(int);         // 唤醒进程
    } signal;

    // 阶段4：用户处理
    struct user_stage {
        void (*check_signals)(void);       // 检查信号
        void (*handle_signal)(int);        // 处理信号
        void (*resume_execution)(void);    // 恢复执行
    } user;
};

// 事件处理流程的具体实现
void complete_event_processing_example() {
    // 场景：键盘按键导致进程接收SIGINT信号

    // 1. 硬件阶段：键盘控制器检测到按键
    keyboard_hardware_detect_keypress();

    // 2. 硬件阶段：产生键盘中断
    keyboard_generate_interrupt(IRQ_KEYBOARD);

    // 3. 中断阶段：CPU响应中断
    cpu_interrupt_handler(IRQ_KEYBOARD);

    // 4. 中断阶段：键盘中断处理程序
    keyboard_interrupt_handler();

    // 5. 信号阶段：检测到Ctrl+C组合键
    if (detect_ctrl_c_combination()) {
        // 6. 信号阶段：向前台进程发送SIGINT
        send_signal_to_foreground_process(SIGINT);
    }

    // 7. 用户阶段：进程在下次调度时检查信号
    process_check_pending_signals();

    // 8. 用户阶段：执行信号处理函数
    execute_sigint_handler();
}

// 事件处理性能监控
struct event_performance_monitor {
    // 各阶段耗时统计
    struct stage_timing {
        uint64_t hardware_detection_time;   // 硬件检测时间
        uint64_t interrupt_latency;         // 中断延迟
        uint64_t interrupt_handling_time;   // 中断处理时间
        uint64_t signal_generation_time;    // 信号生成时间
        uint64_t signal_delivery_time;      // 信号传递时间
        uint64_t user_handling_time;        // 用户处理时间
        uint64_t total_response_time;       // 总响应时间
    } timing;

    // 性能计数器
    atomic64_t total_events;
    atomic64_t fast_path_events;
    atomic64_t slow_path_events;
    atomic64_t dropped_events;

    // 响应时间分布
    uint64_t response_histogram[10];  // 0-9个时间段
};

// 性能优化策略
struct optimization_strategies {
    // 中断优化
    bool interrupt_coalescing;      // 中断合并
    bool interrupt_threading;       // 中断线程化
    bool fast_interrupt_path;       // 快速中断路径

    // 信号优化
    bool signal_batching;          // 信号批处理
    bool realtime_signal_priority; // 实时信号优先级
    bool signal_compression;       // 信号压缩

    // 缓存优化
    bool hot_path_optimization;    // 热路径优化
    bool cache_line_alignment;     // 缓存行对齐
    bool prefetch_optimization;    // 预取优化
};

// 异常情况的处理策略
struct error_handling_framework {
    // 中断错误处理
    struct interrupt_error_handling {
        void (*spurious_interrupt)(int);    // 虚假中断
        void (*interrupt_storm)(int);       // 中断风暴
        void (*handler_timeout)(int);       // 处理超时
        void (*nested_overflow)(void);      // 嵌套溢出
    } interrupt_errors;

    // 信号错误处理
    struct signal_error_handling {
        void (*queue_overflow)(int);        // 队列溢出
        void (*delivery_failure)(int, int); // 传递失败
        void (*handler_crash)(int);         // 处理程序崩溃
        void (*infinite_loop)(int);         // 无限循环
    } signal_errors;

    // 恢复机制
    struct recovery_mechanisms {
        bool automatic_retry;               // 自动重试
        bool graceful_degradation;          // 优雅降级
        bool emergency_shutdown;            // 紧急关闭
        bool checkpoint_recovery;           // 检查点恢复
    } recovery;
};

// 错误恢复的实现示例
void implement_error_recovery() {
    // 1. 中断风暴检测与处理
    if (detect_interrupt_storm(IRQ_NETWORK)) {
        // 临时禁用中断
        disable_irq(IRQ_NETWORK);

        // 启动恢复定时器
        setup_recovery_timer(IRQ_NETWORK, 1000); // 1秒后重新启用
    }

    // 2. 信号队列溢出处理
    if (signal_queue_overflow_detected()) {
        // 清理低优先级信号
        cleanup_low_priority_signals();

        // 通知应用程序
        send_signal(current, SIGUSR2); // 自定义溢出信号
    }

    // 3. 信号处理程序崩溃恢复
    if (signal_handler_crashed(SIGINT)) {
        // 重置为默认处理
        signal(SIGINT, SIG_DFL);

        // 记录错误
        log_signal_handler_crash(SIGINT, current->pid);
    }
}

// 高性能Web服务器的事件处理架构
struct high_performance_server {
    // 网络中断优化
    struct network_optimization {
        bool napi_polling;          // NAPI轮询模式
        bool interrupt_coalescing;  // 中断合并
        bool rss_support;          // RSS多队列支持
        int irq_affinity[32];      // 中断亲和性设置
    } network;

    // 信号处理优化
    struct signal_optimization {
        int signalfd;              // 使用signalfd
        bool self_pipe_trick;      // 自管道技巧
        bool signal_masking;       // 信号屏蔽
        sigset_t worker_mask;      // 工作线程信号掩码
    } signals;

    // 事件循环优化
    struct event_loop_optimization {
        int epoll_fd;              // epoll文件描述符
        bool edge_triggered;       // 边缘触发模式
        int max_events;           // 最大事件数
        struct epoll_event *events; // 事件数组
    } event_loop;
};

// 服务器事件处理主循环
void server_event_loop() {
    struct high_performance_server *server = &global_server;

    while (!shutdown_requested) {
        // 1. 等待事件（网络I/O、信号等）
        int nfds = epoll_wait(server->event_loop.epoll_fd,
                             server->event_loop.events,
                             server->event_loop.max_events,
                             -1);

        if (nfds == -1) {
            if (errno == EINTR) {
                // 被信号中断，继续
                continue;
            }
            handle_epoll_error();
            break;
        }

        // 2. 处理所有就绪事件
        for (int i = 0; i < nfds; i++) {
            struct epoll_event *ev = &server->event_loop.events[i];

            if (ev->data.fd == server->signals.signalfd) {
                // 处理信号事件
                handle_signal_events();
            } else if (ev->events & EPOLLIN) {
                // 处理网络读事件
                handle_network_read(ev->data.fd);
            } else if (ev->events & EPOLLOUT) {
                // 处理网络写事件
                handle_network_write(ev->data.fd);
            } else if (ev->events & (EPOLLERR | EPOLLHUP)) {
                // 处理错误事件
                handle_connection_error(ev->data.fd);
            }
        }

        // 3. 处理延迟任务
        process_deferred_tasks();
    }
}

// 实时系统的优先级管理
struct realtime_priority_manager {
    // 中断优先级配置
    struct interrupt_priority_config {
        int critical_irqs[8];       // 关键中断列表
        int rt_irqs[16];           // 实时中断列表
        int normal_irqs[32];       // 普通中断列表

        uint64_t max_interrupt_latency; // 最大中断延迟
        uint64_t max_handling_time;     // 最大处理时间
    } interrupt_config;

    // 信号优先级配置
    struct signal_priority_config {
        sigset_t rt_signals;        // 实时信号集
        sigset_t critical_signals;  // 关键信号集

        int rt_signal_priority[33]; // 实时信号优先级
        uint64_t max_signal_latency; // 最大信号延迟
    } signal_config;

    // 调度策略
    struct scheduling_policy {
        bool preempt_disable;       // 禁用抢占
        bool interrupt_disable;     // 禁用中断
        int cpu_isolation;         // CPU隔离
        int rt_throttling;         // 实时节流
    } scheduling;
};

// 实时系统的信号处理
void setup_realtime_signal_handling() {
    struct sched_param param;
    sigset_t rt_set;
    struct sigaction sa;

    // 1. 设置实时调度策略
    param.sched_priority = 99; // 最高优先级
    if (sched_setscheduler(0, SCHED_FIFO, &param) == -1) {
        perror("sched_setscheduler");
        return;
    }

    // 2. 设置实时信号
    sigemptyset(&rt_set);
    for (int sig = SIGRTMIN; sig <= SIGRTMAX; sig++) {
        sigaddset(&rt_set, sig);
    }

    // 3. 配置实时信号处理
    sa.sa_sigaction = realtime_signal_handler;
    sa.sa_mask = rt_set;
    sa.sa_flags = SA_SIGINFO | SA_RESTART;

    for (int sig = SIGRTMIN; sig <= SIGRTMAX; sig++) {
        sigaction(sig, &sa, NULL);
    }

    // 4. 锁定内存防止页面交换
    if (mlockall(MCL_CURRENT | MCL_FUTURE) == -1) {
        perror("mlockall");
    }
}

// 实时信号处理函数
void realtime_signal_handler(int sig, siginfo_t *info, void *context) {
    // 记录处理开始时间
    struct timespec start_time;
    clock_gettime(CLOCK_MONOTONIC, &start_time);

    // 根据信号优先级处理
    int priority = sig - SIGRTMIN;

    switch (priority) {
    case 0: // 最高优先级
        handle_critical_realtime_event(info);
        break;
    case 1:
        handle_high_priority_event(info);
        break;
    default:
        handle_normal_realtime_event(info);
        break;
    }

    // 检查处理时间
    struct timespec end_time;
    clock_gettime(CLOCK_MONOTONIC, &end_time);

    uint64_t elapsed_ns = (end_time.tv_sec - start_time.tv_sec) * 1000000000 +
                         (end_time.tv_nsec - start_time.tv_nsec);

    if (elapsed_ns > MAX_RT_SIGNAL_HANDLING_TIME) {
        log_rt_violation(sig, elapsed_ns);
    }
}

// 中断与信号的调试框架
struct debug_framework {
    // 跟踪功能
    struct tracing_capabilities {
        bool interrupt_tracing;     // 中断跟踪
        bool signal_tracing;       // 信号跟踪
        bool latency_tracing;      // 延迟跟踪
        bool call_stack_tracing;   // 调用栈跟踪
    } tracing;

    // 统计信息
    struct statistics {
        uint64_t interrupt_counts[256];    // 中断计数
        uint64_t signal_counts[64];        // 信号计数
        uint64_t latency_histogram[100];   // 延迟直方图
        uint64_t error_counts[16];         // 错误计数
    } stats;

    // 调试接口
    struct debug_interfaces {
        int debugfs_root;          // debugfs根目录
        int proc_entries;          // proc条目
        int sysfs_attributes;      // sysfs属性
        int trace_events;          // trace事件
    } interfaces;
};

// 性能分析工具实现
void implement_performance_analysis() {
    // 1. 创建debugfs接口
    create_debugfs_entries();

    // 2. 注册trace事件
    register_trace_events();

    // 3. 启动性能监控
    start_performance_monitoring();
}

// debugfs接口示例
static ssize_t interrupt_stats_read(struct file *file, char __user *buf,
                                   size_t count, loff_t *ppos) {
    char tmp[4096];
    int len = 0;

    len += snprintf(tmp + len, sizeof(tmp) - len,
                   "Interrupt Statistics:\n");

    for (int i = 0; i < 256; i++) {
        if (interrupt_stats[i] > 0) {
            len += snprintf(tmp + len, sizeof(tmp) - len,
                           "IRQ %d: %llu\n", i, interrupt_stats[i]);
        }
    }

    return simple_read_from_buffer(buf, count, ppos, tmp, len);
}

// trace事件定义
TRACE_EVENT(interrupt_entry,
    TP_PROTO(int irq, const char *name),
    TP_ARGS(irq, name),
    TP_STRUCT__entry(
        __field(int, irq)
        __string(name, name)
        __field(u64, timestamp)
    ),
    TP_fast_assign(
        __entry->irq = irq;
        __assign_str(name, name);
        __entry->timestamp = local_clock();
    ),
    TP_printk("irq=%d name=%s timestamp=%llu",
              __entry->irq, __get_str(name), __entry->timestamp)
);

// 设计权衡的核心考量
struct design_tradeoffs {
    // 性能 vs 复杂度
    struct performance_complexity {
        bool fast_path_optimization;    // 快路径优化
        bool feature_completeness;      // 功能完整性
        int code_maintainability;       // 代码可维护性
    } perf_complex;

    // 实时性 vs 吞吐量
    struct realtime_throughput {
        uint64_t max_interrupt_latency;  // 最大中断延迟
        uint64_t system_throughput;      // 系统吞吐量
        bool preemption_control;         // 抢占控制
    } rt_throughput;

    // 安全性 vs 灵活性
    struct security_flexibility {
        bool strict_permission_check;    // 严格权限检查
        bool signal_spoofing_protection; // 信号欺骗保护
        int user_customization_level;    // 用户定制化程度
    } sec_flex;

    // 向后兼容 vs 创新发展
    struct compatibility_innovation {
        bool legacy_api_support;         // 传统API支持
        bool modern_interface_adoption;  // 现代接口采用
        int migration_complexity;        // 迁移复杂度
    } compat_innov;
};