kthread_work和kthread_worker机制

目录

结构体分析

• kthread_worker
• kthread_work

使用方式

• kthread_worker
•  kthread_work
• 启动 work
• flush工作队列
• 停止当前的线程

实现源码

• kthread_init_worker
• 执行线程 kthread_worker_fn
• kthread_init_work
• kthread_queue_work

---

最近在看spi的驱动，驱动中有一个队列化机制，看起来不是很懂，所以就整理了下这块的内容，即kthread_work队列化机制，其实也可以理解为一种内核线程机制。

我们首先来分析一下下面两个结构体 kthread_worker 和 kthread_work 。

结构体分析

kthread_worker

数据结构定义在：include/linux/kthread.h 

struct kthread_worker {
    unsigned int flags;
    spinlock_t lock;      //保护work_list链表的自旋锁
    struct list_head work_list;    //kthread_work 链表,相当于流水线
    struct list_head delayed_work_list;   // 延时工作 list
    struct task_struct *task;      //为该kthread_worker执行任务的线程对应的task_struct结构
    struct kthread_work *current_work;    //当前正在处理的kthread_work
};

kthread_work

数据结构定义在：include/linux/kthread.h ：

struct kthread_work {
    struct list_head    node;  //kthread_work链表的链表元素
    kthread_work_func_t    func;  //执行函数,该kthread_work所要做的事情
    struct kthread_worker    *worker;  //处理该kthread_work的kthread_worker
    /* Number of canceling calls that are running at the moment. */
    int canceling;
};

根据结构体定义，不难看出他们之间的关系：

 

使用方式

kthread_worker

struct kthread_worker hi_worker; // 声明一个kthread_worker
kthread_init_worker(&hi_worker); // 初始化kthread_worker

初始化完成后，为 kthread_worker 创建一个内核线程来处理 work.：

struct task_struct *kworker_task = kthread_run(kthread_worker_fn, &hi_worker, "nvme%d", dev->instance);

注意，这里传入的 kthread_worker_fn 函数是固定的，是内核写好的函数。

 kthread_work

定义一个 kthread_work 并初始化他，为他指定工作函数 xxx_work_fn，此函数是具体处理信息的函数，函数由我们自行编写：

struct kthread_work hi_work;//声明一个kthread_work
kthread_init_work(&hi_work, xxx_work_fn); //初始化kthread_work,设置work执行函数.

启动 work

上面两步准备好了 worker 和 work，如果有需要处理的 work 的话，那么需要把这个 work 挂到 worker 上：

kthread_queue_work(&hi_worker, &hi_work);

flush工作队列

刷新指定 worker 上所有 work，将指定的 worker 上的所有 work 全部执行完，一般会在kthread_stop之前使用

kthread_flush_worker(&hi_worker);

停止当前的线程

停止当前线程一般和kthread_flush_worker一起使用，一般都会在队列的所有任务都完成之后再停止进程

kthread_stop(kworker_task);

 

实现源码

上面列举了结构和基本用法，接着咱们来欣赏源码。照样，一步一步来看

kthread_init_worker

用于初始化一个 kthread_worker：

#define kthread_init_worker(worker) \
    do { \
    static struct lock_class_key __key; \
    __kthread_init_worker((worker), "("#worker")->lock", &__key); \
} while (0)

进而调用到 __kthread_init_worker：

void __kthread_init_worker(struct kthread_worker *worker,
    const char *name,
    struct lock_class_key *key)
{
    memset(worker, 0, sizeof(struct kthread_worker));
    spin_lock_init(&worker->lock);
    lockdep_set_class_and_name(&worker->lock, key, name);
    INIT_LIST_HEAD(&worker->work_list);
    INIT_LIST_HEAD(&worker->delayed_work_list);
}
EXPORT_SYMBOL_GPL(__kthread_init_worker);

其实就是初始化他的成员变量为 0， 然后就他的 work_list 和 delayed_work_list 初始化；

执行线程 kthread_worker_fn

定义并初始化完 kthread_worker 后，就要调用前面说的 thread_run 一个 kthread_worker_fn 函数，传入的参数是 kthread_worker 的指针：

int kthread_worker_fn(void *worker_ptr)
{
	struct kthread_worker *worker = worker_ptr;
	struct kthread_work *work;

	/*
	 * FIXME: Update the check and remove the assignment when all kthread
	 * worker users are created using kthread_create_worker*() functions.
	 */
	WARN_ON(worker->task && worker->task != current);
	worker->task = current;

	if (worker->flags & KTW_FREEZABLE)
		set_freezable();

repeat:
	set_current_state(TASK_INTERRUPTIBLE);	/* mb paired w/ kthread_stop */

	if (kthread_should_stop()) {
		__set_current_state(TASK_RUNNING);
		spin_lock_irq(&worker->lock);
		worker->task = NULL;
		spin_unlock_irq(&worker->lock);
		return 0;
	}

	work = NULL;
	spin_lock_irq(&worker->lock);
	if (!list_empty(&worker->work_list)) {
		work = list_first_entry(&worker->work_list,
					struct kthread_work, node);
		list_del_init(&work->node);
	}
	worker->current_work = work;
	spin_unlock_irq(&worker->lock);

	if (work) {
		__set_current_state(TASK_RUNNING);
		work->func(work);
	} else if (!freezing(current))
		schedule();

	try_to_freeze();
	goto repeat;
}
EXPORT_SYMBOL_GPL(kthread_worker_fn);

代码的逻辑比较简单：

1、首先是赋值了传入的 worker->task 为 current，当前进程，设置状态为 TASK_INTERRUPTIBLE；

2、Check 标志位，看是否需要关闭这个 kthread_worker_fn 内核线程，如果需要关闭，则进程状态，并清空 worker 下对应的 work

3、判断当前的 worker 的 work_list 上是否为空，如果非空，那么取出它，设置成为 worker->current_work，即当前的 work

4、执行取出的 work->func，这个最终就会掉用我们之前注册的回调函数xxx_work_fn

5、如果 worker 的 work_list 上为空，也就是没有任务，那么就会调用 schedule()，这个 kthread_worker_fn 执行线程进入睡眠。

6、如果没有退出，则 goto repeat，继续执行

kthread_init_work

kthread_init_work 用于初始化一个已经定义了的 kthread_work：

#define kthread_init_work(work, fn) \
do { \
    memset((work), 0, sizeof(struct kthread_work)); \
    INIT_LIST_HEAD(&(work)->node); \
    (work)->func = (fn); \
} while (0)

其实只是清零了传入的 kthread_work 类型的 work，并将他的链表元素初始化，最后将 work 的执行函数的指针挂接上去

kthread_queue_work

这个函数用于将已经完成了初始化的 kthread_worker 和 kthread_work 后，将 work 推进一个 worker 执行：

bool kthread_queue_work(struct kthread_worker *worker,
			struct kthread_work *work)
{
	bool ret = false;
	unsigned long flags;

	spin_lock_irqsave(&worker->lock, flags);
	if (!queuing_blocked(worker, work)) {
		kthread_insert_work(worker, work, &worker->work_list);
		ret = true;
	}
	spin_unlock_irqrestore(&worker->lock, flags);
	return ret;
}
EXPORT_SYMBOL_GPL(kthread_queue_work);

进而调用到 kthread_insert_work ：

static void kthread_insert_work(struct kthread_worker *worker,
				struct kthread_work *work,
				struct list_head *pos)
{
	kthread_insert_work_sanity_check(worker, work);

	list_add_tail(&work->node, pos);
	work->worker = worker;
	if (!worker->current_work && likely(worker->task))
		wake_up_process(worker->task);
}

将 work->node 添加进入 worker->work_list，并指定了这个 work 所属的 worker，最后唤醒那个沉睡了的 worker->task，也就是 kthread_worker_fn 执行函数，此刻 worker 上的 work 上的 work->func 得以执行！