Linux内核-如何停止等待信号量的kthread？

Question

在编写 Linux 内核模块时，我遇到了一个 kthread 问题，我在等待信号量解锁时无法唤醒。这会导致线程无法停止并且rmmod 在尝试卸载模块时冻结。

请注意：此模块在 3.10 内核上运行，我无法将其更新到较新版本（客户要求在具有 3.10 内核的库存 CentOS 7 上运行）。 p>

以下是模块源代码中有趣的部分。它代表了一个简单的生产者消费者问题，列表不受大小限制（因此不需要生产者信号量）并由互斥锁保护。从列表中获取某些内容的函数由一个信号量保护，该信号量由生产者升高并由消费者降低。生产者函数是从这个代码中没有显示的外部事件（实际上是一个字符设备）调用的，sn-ps 保持尽可能小。该过程完美无缺，除了模块卸载。

导致冻结的部分在代码sn-ps中用cmets标记。我知道停止 kthread 的唯一方法是在其上调用 kthread_stop，在这种情况下它会失败，因为它显然无法唤醒睡眠线程。因为它等待线程退出，所以调用永远不会返回，模块也不会卸载。

如何唤醒和停止等待信号量成功卸载模块的kthread？

列表实现：

#include <linux/mutex.h>
#include <linux/list.h>
#include <linux/semaphore.h>

static LIST_HEAD(list);
DEFINE_MUTEX(list_lock);
DEFINE_SEMAPHORE(sem_list_consumer);

void add_to_list(struct *some_struct) {
    int rv = mutex_lock_interruptible(&list_lock);
    if(rv != 0) {
        return;
    }

    list_add(&some_struct->list, &list);
    mutex_unlock(&list_lock);
    up(&sem_list_consumer);
}

struct some_struct * take_from_list() {
    int rv;
    some_struct *entry;

    /* this is where the kthread will freeze when module is unloaded */
    rv = down_interruptible(&sem_list_consumer);
    if(rv != 0) {
        return NULL;
    }

    rv = mutex_lock_interruptible(&list_lock);
    if(rv != 0) {
        up(&sem_list_consumer);
        return NULL;
    }

    if (list_empty(&list)) {
        mutex_unlock(&list_lock);
        return NULL;
    } else {
        entry = list_last_entry(&list, struct some_struct, list);
        if (entry) {
            list_del(&entry->list);
        }
    }

    mutex_unlock(&list_lock);
    return entry;
}

消费者kthread实现：

#include <linux/kthread.h>
#include <linux/sched.h>

int consumer_kthread(void *data) {
    struct some_struct *entry;

    set_current_state(TASK_INTERRUPTIBLE);
    while (!kthread_should_stop()) {
        /* Here the function including the semaphore is called */
        entry = take_from_list();
        if(entry != NULL) {
            /* Do something with 'entry' here */
        } else {
            /* Some handling of returned NULL pointers */
        }

        set_current_state(TASK_INTERRUPTIBLE);
    }
    set_current_state(TASK_RUNNING);

    return 0;
}

模块实现：

#include <linux/init.h>
#include <linux/kthread.h>
#include <linux/module.h>
#include <linux/sched.h>

static struct task_struct *consumer_task;

static int __init initModule(void) {
    consumer_task = kthread_run(consumer_kthread, NULL, "list-consumer");

    return 0;
}

static void __exit exitModule(void) {
    /* this call will cause rmmod to freeze forever */
    kthread_stop(consumer_task);
}

module_init(initModule);
module_exit(exitModule);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("My Module");

Answer 1

您需要向等待进程发送信号。然后该进程将从 TASK_INTERRUPTABLE 更改为 TASK_RUNNING，然后将安排并运行 down_interruptable 返回 EINTR。

Answer 2

缺少的代码意味着这个答案只能使用有根据的猜测。

以下是我对您丢失的代码的假设：

1. 如果take_from_list 返回一个有效条目，consumer_kthread 会对该条目进行处理并调用up(&sem_list_consumer) 以匹配take_from_list 中对down_interruptible(&sem_list_consumer) 的调用。

2. 如果take_from_list 返回NULL，consumer_kthread 会对NULL 指针进行一些处理，并假定sem_list_consumer 信号量处于其原始状态。

鉴于这些假设，take_from_list 中存在一个错误，因为它有时会返回 NULL 而没有先调用 up(&sem_list_consumer)。这意味着对take_from_list 的任何后续调用都将阻塞对down_interruptible(&sem_list_consumer) 的调用，直到它们被信号中断。要修复该错误，请将take_from_list 更改为始终将信号量保持在它返回NULL 时离开的状态：

struct some_struct * take_from_list() {
    int rv;
    some_struct *entry;

    rv = down_interruptible(&sem_list_consumer);
    if(rv != 0) {
        return NULL;
    }

    rv = mutex_lock_interruptible(&list_lock);
    if(rv != 0) {
        up(&sem_list_consumer);
        return NULL;
    }

    if (list_empty(&list)) {
        mutex_unlock(&list_lock);
        up(&sem_list_consumer);  /* <-- this line was missing */
        return NULL;
    } else {
        entry = list_last_entry(&list, struct some_struct, list);
        if (entry) {
            list_del(&entry->list);
        }
    }

    mutex_unlock(&list_lock);
    return entry;
}

修正

如果consumer_kthread 的缺失代码中有某个地方将自身添加到等待队列并进入睡眠状态，则应在唤醒条件中包含对kthread_should_stop() 的调用。唤醒条件应满足其他条件 OR (||) kthread_should_stop()。

从您的exitModule 函数调用kthread_stop(consumer_task) 将唤醒消费者线程。如果它正在等待一个事件，它首先会检查唤醒条件，如果不满足则返回睡眠。通过将kthread_should_stop() 包括为可能的唤醒条件之一，您可以确保消费者线程不会立即返回睡眠状态。