内核空间捕获SIGINT信号的实现方案及问题排查咨询

首先得明确一个核心点：内核空间和用户态处理信号的逻辑完全不一样，你之前尝试的方法本质上就走偏了——SIGINT是发给用户进程的信号，内核本身不会收到这个信号，也不能像用户态那样直接给进程注册信号处理函数。下面给你拆解问题本质和可行的解决方案：

为什么你之前的方法无效？ #

用户态的signal()是给当前进程注册信号处理逻辑，但内核里的kernel_sigaction根本不是干这个的——内核无权随意修改用户进程的信号处理表，这会破坏进程的上下文安全性，而且你的sysfs函数是运行在触发它的用户进程上下文里，直接在这里注册信号处理函数既不符合内核规范，也无法达到你想要的“中断时清理缓冲区”的目的。

正确的解决思路 #

你遇到的问题本质是：用户按下Ctrl+C后，触发SIGINT信号导致用户进程退出，进而让sysfs的update_function提前返回，没来得及清理固件更新的缓冲区。我们需要做的不是“捕获SIGINT”，而是在sysfs函数被信号中断时，检测到这个情况并执行清理逻辑，同时把长时间的固件更新逻辑放到更安全的内核线程中。

方案1：在sysfs上下文检测信号并清理

sysfs的写函数运行在用户进程上下文，当进程收到信号时，系统调用会提前返回，你可以通过检查信号状态来触发清理：

static bool update_in_progress = false;
static char *update_buffer;
static size_t buffer_size;

static void cleanup_update_resources(void) {
    if (update_buffer) {
        kfree(update_buffer);
        update_buffer = NULL;
    }
    buffer_size = 0;
    update_in_progress = false;
    printk(KERN_INFO "Firmware update interrupted, resources cleaned up\n");
}

static ssize_t update_function(struct device *dev, struct device_attribute *dev_attr, const char *buf, size_t count)
{
    if (update_in_progress) {
        return -EBUSY;
    }

    // 初始化缓冲区和更新状态
    update_buffer = kmemdup(buf, count, GFP_KERNEL);
    if (!update_buffer) {
        return -ENOMEM;
    }
    buffer_size = count;
    update_in_progress = true;

    // 模拟阻塞的固件更新过程（实际中应该放到内核线程）
    while (1) {
        // 检查当前进程是否有未处理的信号（比如SIGINT）
        if (signal_pending(current)) {
            cleanup_update_resources();
            // 返回-ERESTARTSYS让内核处理信号，或者直接返回-EINTR
            return -ERESTARTSYS;
        }

        // 执行一小步更新逻辑
        if (do_single_update_step()) {
            break; // 更新完成
        }

        // 短暂休眠，让出CPU
        schedule_timeout(HZ/10);
    }

    // 更新完成后的清理
    cleanup_update_resources();
    return count;
}

方案2：把固件更新放到内核线程（更推荐）

长时间的阻塞操作不应该放在sysfs函数里，因为sysfs属于文件操作上下文，阻塞在这里容易引发各种问题。把更新逻辑放到内核线程，sysfs函数只负责触发更新，同时通过原子标志来控制线程停止：

static atomic_t stop_update = ATOMIC_INIT(0);
static struct task_struct *update_thread;
static char *update_buffer;
static size_t buffer_size;

static void cleanup_update_resources(void) {
    if (update_buffer) {
        kfree(update_buffer);
        update_buffer = NULL;
    }
    buffer_size = 0;
}

static int firmware_update_thread(void *data)
{
    set_current_state(TASK_INTERRUPTIBLE);

    while (!atomic_read(&stop_update)) {
        // 执行固件更新步骤
        if (do_single_update_step()) {
            break; // 更新完成
        }

        schedule_timeout(HZ/10);
        set_current_state(TASK_INTERRUPTIBLE);
    }

    // 不管是正常完成还是被中断，都清理资源
    cleanup_update_resources();
    set_current_state(TASK_RUNNING);
    return 0;
}

static ssize_t update_function(struct device *dev, struct device_attribute *dev_attr, const char *buf, size_t count)
{
    if (update_thread) {
        return -EBUSY;
    }

    // 初始化缓冲区
    update_buffer = kmemdup(buf, count, GFP_KERNEL);
    if (!update_buffer) {
        return -ENOMEM;
    }
    buffer_size = count;
    atomic_set(&stop_update, 0);

    // 创建内核线程执行更新
    update_thread = kthread_run(firmware_update_thread, NULL, "firmware_update");
    if (IS_ERR(update_thread)) {
        cleanup_update_resources();
        return PTR_ERR(update_thread);
    }

    // 如果你需要在sysfs函数里等待更新完成，需检测信号
    while (!kthread_should_stop(update_thread)) {
        if (signal_pending(current)) {
            // 收到信号，通知线程停止
            atomic_set(&stop_update, 1);
            kthread_stop(update_thread);
            update_thread = NULL;
            return -ERESTARTSYS;
        }
        schedule_timeout(HZ/10);
    }

    update_thread = NULL;
    return count;
}

关键要点总结 #

1. 内核不会收到用户进程的SIGINT信号，你要处理的是用户进程收到信号后导致sysfs函数提前返回的场景；
2. 用signal_pending(current)可以检测当前进程是否有未处理的信号，以此触发清理逻辑；
3. 长时间的阻塞操作一定要放到内核线程中，避免在文件操作上下文（比如sysfs）中阻塞；
4. 永远不要尝试在内核中修改用户进程的信号处理表，这既不安全也不符合内核规范。

备注：内容来源于stack exchange，提问作者lilijobo1