linux 基础知识点之工作队列workqueue

        多年前就了解了workqueue着玩意，但理解上就并不是很很深刻，今天重新梳理一下，本文重点的是哪个些现成的demo代码，都是可以直接拿来用的，这就是写这文章的目的和作用，就是为了备份后续工作用到的时候，可以快速Ctrl+c and Ctrl + v，接下来复制些前辈写好的理解概念，再结合一下个所整理得demo。

一、workqueue工作队列简介

        工作队列是除软中断和tasklet以外最常用的一种下半部机制，其基本原理是：把work（需要推迟执行的函数）交由一个内核线程来执行，工作队列总是在进程上下文执行。                               工作队列 ( workqueue )是将操作（或回调）延期异步执行的一种机制。工作队列可以把工作推后，交由一个内核线程去执行，并且工作队列是执行在线程上下文中，因此工作执行过程中可以被重新调度、抢占、睡眠。

​ 工作队列的优点：

    因工作队列在进程下文中执行，因此工作队列允许重新调度和睡眠，是异步执行的进程上下文。
    解决了如果软中断和tasklet执行时间过长会导致系统实时性下降等问题。

（1-1）work_struct工作

在 Linux 内核中，work_struct 是工作队列（workqueue）机制的核心数据结构，用于表示一个工作项。工作队列允许内核将任务推迟到其他线程中执行，这在处理中断或其他需要快速响应的场景中非常有用

struct my_work {struct work_struct work;int data;
};定义一个包含 work_struct 的结构体，用于存储工作项的数据

linux内核中使用work_struct结构体来表示一个工作，如下定义（/inlcude/linux/workqueue.h）：

struct work_struct {atomic_long_t data;struct list_head entry;work_func_t func;
#ifdef CONFIG_LOCKDEPstruct lockdep_map lockdep_map;
#endif
};

（1-2）workqueue工作队列

把工作（包括该工作任务的执行回调函数）添加到一个队列，称为workqueue，即工作队列，然后通过worker-pool中的内核工作线程（worker）去执行这个回调函数。工作队列使用workqueue_struct结构体来表示，定义如下（/kernel/workqueue.c）：

    创建工作队列：my_workqueue = create_workqueue("my_workqueue");使用 create_workqueue 创建一个工作队列，名称为 "my_workqueue"

（1-3）worker工作者线程

​ linux 内核使用工作者线程(worker thread)来处理工作队列中的各个工作，linux 内核使用
worker 结构体表示工作者线程，worker 结构体定义如下（/kernel/workqueue_internal.h）
  
二、workqueue工作队列的使用

​ 每一个worker工作线程中都有一个工作队列，工作线程处理自己工作队列中的所有工作。

在实际开发中，推荐使用默认的workqueue·工作队列，而不是新创建workqueue。使用方法如下：

​ 直接定义一个work_struct结构体变量，然后使用INIT_WORK宏来完成初始化工作，INIT_WORK定义如下：

#define INIT_WORK(_work, _func)

_work表示要初始化的工作，_func是工作对应的处理函数。

也可以使用 DECLARE_WORK 宏一次性完成工作的创建和初始化，宏定义如下：

#define DECLARE_WORK(n, f)

​ n 表示定义的工作(work_struct)，f 表示工作对应的处理函数。和 tasklet 一样，工作也是需要调度才能运行的，工作的调度函数为schedule_work()，函数原型如下所示：

bool schedule_work(struct work_struct *work) //其实你就理解为工作队列启动回调的函数

使用cancel_work_sync()取消一个工作，函数原型如下所示：

bool cancel_work_sync(struct work_struct *work)

当然也可以自己创建一个workqueue，特别是网络子系统、块设备子系统情况下等。具体步骤如下：

    使用alloc_workqueue()创建新的workqueue。
    使用INIT_WORK()宏声明一个work和该work的回调函数。
    使用queue_work()在新的workqueue上调度一个work //其实就理解为工作队列启动回调的函数
    使用flush_workqueue()去flush 工作队列上的所有work。

来个demo：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/time.h>#include <linux/jiffies.h>
#include <linux/workqueue.h>
#include <linux/slab.h> //kmalloc kfree#include <linux/sched.h>
#include <linux/delay.h>#define WAIT_TIMES 5000static char data[] = "[Tab] test for demo work";struct work_ctx{struct work_struct real_work;char *str;int arg;
}work_ctx;struct work_ctx *demo_work;// 定义工作队列
static struct workqueue_struct *my_workqueue;static void demo_work_func(struct work_struct *work){struct work_ctx *temp_work = container_of(work,struct work_ctx,real_work);printk(KERN_INFO "[work]=> PID: %d; NAME: %s\n", current->pid, current->comm);printk(KERN_INFO "[work]=> sleep 1 seconds\n");set_current_state(TASK_INTERRUPTIBLE);schedule_timeout(1 * HZ); //Wait 1 secondsprintk(KERN_INFO "[work]=> data is: %d  %s\n", temp_work->arg,temp_work->str);
}static int __init demo_thread_init(void){int count = 10;// 创建工作队列my_workqueue = create_workqueue("my_workqueue");if (!my_workqueue) {return -ENOMEM;}    demo_work = kmalloc(sizeof(*demo_work),GFP_KERNEL);	INIT_WORK(&demo_work->real_work, demo_work_func);demo_work->str = data;while(count--){//msleep(5000);msleep(WAIT_TIMES);//mdelay(WAIT_TIMES);demo_work->arg = count;//schedule_work(&demo_work->real_work);// 提交工作项到工作队列//queue_work(my_workqueue, &my_work->work);        queue_work(my_workqueue, &demo_work->real_work);}return 0;
}module_init(demo_thread_init);static void __exit demo_thread_exit(void){flush_work(&demo_work->real_work);kfree(demo_work);
}
module_exit(demo_thread_exit);MODULE_LICENSE("GPL");	

除此之外，linux内核还提供了一个workqueue机制与timer机制相结合的延时机制—delayed_work。
Talk is cheap，show me the code

结合hrtimer_demo升级了一下：
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/hrtimer.h>
#include <linux/ktime.h>#include <linux/time.h>#include <linux/jiffies.h>
#include <linux/workqueue.h>
#include <linux/slab.h> //kmalloc kfree#include <linux/sched.h>
#include <linux/delay.h>static struct hrtimer my_timer;
static int count = 0;#define WAIT_TIMES 5000static char data[] = "[Tab] test for demo work";struct work_ctx{struct work_struct real_work;char *str;int arg;
}work_ctx;struct work_ctx *demo_work;// 定义工作队列
static struct workqueue_struct *my_workqueue;static void demo_work_func(struct work_struct *work){struct work_ctx *temp_work = container_of(work,struct work_ctx,real_work);printk(KERN_INFO "[work]=> PID: %d; NAME: %s\n", current->pid, current->comm);printk(KERN_INFO "[work]=> sleep 1 seconds\n");set_current_state(TASK_INTERRUPTIBLE);schedule_timeout(1 * HZ); //Wait 1 secondsprintk(KERN_INFO "[work]=> data is: %d  %s\n", temp_work->arg,temp_work->str);
}#if 1
enum hrtimer_restart my_timer_callback(struct hrtimer *timer)
{count++;//pr_info("Timer expired! Count: %d\n", count);printk("enter [%s] line = %d, count = %d. \n", __func__, __LINE__, count);demo_work->arg = count;schedule_work(&demo_work->real_work);// 提交工作项到工作队列   //queue_work(my_workqueue, &demo_work->real_work); // 重新启动定时器，设置下次到期时间为 1 秒hrtimer_forward_now(timer, ms_to_ktime(2000));//调整高分辨率定时器（high-resolution timer，hrtimer）到期时间的一个函数return HRTIMER_RESTART; // 代表重复定时器 //重启方式
}
#elseenum hrtimer_restart my_timer_callback(struct hrtimer *timer)
{count++;//pr_info("Timer expired! Count: %d\n", count);printk("enter [%s] line = %d, count = %d. \n", __func__, __LINE__, count);// 重新启动定时器，设置下次到期时间为 1 秒hrtimer_forward_now(timer, ms_to_ktime(2000));//调整高分辨率定时器（high-resolution timer，hrtimer）到期时间的一个函数return HRTIMER_RESTART; // 代表重复定时器 //重启方式
}enum hrtimer_restart my_timer_callback(struct hrtimer *timer)
{pr_info(KERN_INFO "High-resolution timer expired after 1 second\n");printk("enter [%s] line = %d, count = %d. \n", __func__, __LINE__, count);return HRTIMER_NORESTART; // 代表不重复定时器
}
#endifstatic int __init my_module_init(void)
{ktime_t ktime;printk("enter [%s] line = %d \n", __func__, __LINE__);pr_info("High-Resolution Timer Example Module Loaded\n");// 创建工作队列my_workqueue = create_workqueue("my_workqueue");if (!my_workqueue) {return -ENOMEM;}    demo_work = kmalloc(sizeof(*demo_work),GFP_KERNEL);	INIT_WORK(&demo_work->real_work, demo_work_func);demo_work->str = data;// 设置定时器初始时间为 1 秒ktime = ktime_set(10, 0); // 1 秒, 0 纳秒hrtimer_init(&my_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);//初始化高分辨率定时器的函数my_timer.function = my_timer_callback;// 定时到期时的回调函数hrtimer_start(&my_timer, ktime, HRTIMER_MODE_REL);//启动高分辨率定时器的函数return 0;
}static void __exit my_module_exit(void)
{// 停止定时器hrtimer_cancel(&my_timer);pr_info("High-Resolution Timer Example Module Unloaded\n");
}module_init(my_module_init);
module_exit(my_module_exit);MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("High-Resolution Timer Example");
MODULE_AUTHOR("Pan Shuai");

                        原文链接：https://blog.csdn.net/iriczhao/article/details/122870227

 

Linux内核中的工作队列包括：共享工作队列和自定义工作队列。区别如下：

    1）共享工作队列：将新创建的工作任务添加到Linux内核创建的全局工作队列system_wq中，无需自己创建工作队列；

    2）自定义工作队列：将新创建的工作任务添加到自己创建的工作队列中；

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/kobject.h>
#include <linux/list.h>
#include <linux/kthread.h>
#include <asm/ptrace.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/interrupt.h>int data  = 10;static struct work_struct       work1;
static struct work_struct       work2;static void do_work1(struct work_struct *arg)
{printk(KERN_INFO "do_work1 .....");
}static void do_work2(struct work_struct *arg)
{printk(KERN_INFO "do_work2 .....");
}int threadfn(void *data)
{static int count =  0 ;int args = *(int *)data;printk(KERN_INFO "enter thead_fn");while(1){msleep(2*1000);printk(KERN_INFO "threadfn data: %d, count: %d",args , ++count);schedule_work(&work1);schedule_work(&work2);}
} static int __init test_kobj_init(void)
{INIT_WORK(&work1,do_work1);INIT_WORK(&work2,do_work2);struct task_struct *  thread =  kthread_create( threadfn,(void * )&data,"mythread");if(thread != NULL){printk(KERN_INFO "thread create success");wake_up_process(thread);}else{printk(KERN_ERR "thread create err");}return 0;
}static void __exit test_kobj_exit(void)
{printk(KERN_INFO "test_kobj_exit ");return;
}module_init(test_kobj_init);
module_exit(test_kobj_exit);MODULE_AUTHOR("copy other auther");
MODULE_LICENSE("GPL");

2、自定义工作队列举例（demol来源于网络）

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/kobject.h>
#include <linux/list.h>
#include <linux/kthread.h>
#include <asm/ptrace.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
int data  = 10;static struct workqueue_struct *workqueue;
static struct work_struct       work1;
static struct work_struct       work2;static void do_work1(struct work_struct *arg)
{printk(KERN_INFO "do_work1 .....");
}static void do_work2(struct work_struct *arg)
{printk(KERN_INFO "do_work2 .....");
}int threadfn(void *data)
{static int count =  0 ;int args = *(int *)data;printk(KERN_INFO "enter thead_fn");while(1){msleep(2*1000);printk(KERN_INFO "threadfn data: %d, count: %d",args , ++count);queue_work(workqueue,&work1);//将任务放到自己创建的工作队列上去执行queue_work(workqueue,&work2);}
} static int __init test_kobj_init(void)
{workqueue = create_workqueue("create_new_work_queue");INIT_WORK(&work1,do_work1);INIT_WORK(&work2,do_work2);struct task_struct *  thread =  kthread_create( threadfn,(void * )&data,"mythread");if(thread != NULL){printk(KERN_INFO "thread create success");wake_up_process(thread);}else{printk(KERN_ERR "thread create err");}return 0;
}static void __exit test_kobj_exit(void)
{printk(KERN_INFO "test_kobj_exit ");destroy_workqueue(workqueue);return;
}module_init(test_kobj_init);
module_exit(test_kobj_exit);MODULE_AUTHOR("copy other auther");
MODULE_LICENSE("GPL");

在使用如下函数时注意事项

    1、flush_work()：堵塞工作任务，直到工作任务完成

    2、flush_delayed_work()：等待延时工作任务完成

    3、cancel_work_sync()：取消工作任务并等待它完成

    4、cancel_delayed_work()：取消延时工作任务

    5、cancel_delayed_work_sync()：取消延时工作任务并等待它完成

    6、create_workqueue()：对于多CPU系统，内核会在每个CPU上创建一个工作队列，使线程处理并行化

    7、create_singlethread_workqueue()：内核只在一个CPU上创建一个工作队列

    8、queue_work_on()：在指定CPU上添加工作任务，queue_work()调用queue_work_on()在所有CPU上添加工作任务

常见的应用场景：

work_struct 是 Linux 内核中用于处理异步任务的机制，它允许内核将任务推迟到工作队列中，由工作线程在适当的时候执行。work_struct 可以处理多种类型的任务，以下是一些常见的应用场景：
1. 中断处理
中断处理程序需要快速完成，以避免过长时间占用 CPU。如果中断处理程序需要执行一些耗时的操作，可以将这些操作推迟到工作队列中执行。例如：

static void my_interrupt_handler(int irq, void *dev_id) {struct work_struct *work = (struct work_struct *)dev_id;queue_work(my_workqueue, work);
}

2. 定时任务
如果需要在特定时间后执行某些任务，可以使用 queue_delayed_work 将任务推迟到工作队列中。例如：

static void my_delayed_work_handler(struct work_struct *work) {printk(KERN_INFO "Delayed work handler called\n");
}static int __init my_module_init(void) {my_workqueue = create_workqueue("my_workqueue");if (!my_workqueue) {return -ENOMEM;}struct my_work *my_work = kmalloc(sizeof(struct my_work), GFP_KERNEL);if (!my_work) {return -ENOMEM;}INIT_DELAYED_WORK(&my_work->work, my_delayed_work_handler);queue_delayed_work(my_workqueue, &my_work->work, msecs_to_jiffies(1000)); // 延迟 1 秒return 0;
}

3. 文件系统操作
在文件系统操作中，某些耗时的操作可以推迟到工作队列中执行。例如，文件系统的同步操作可以使用工作队列来处理：

static void my_sync_handler(struct work_struct *work) {printk(KERN_INFO "File system sync handler called\n");// 执行文件系统同步操作
}static int __init my_module_init(void) {my_workqueue = create_workqueue("my_workqueue");if (!my_workqueue) {return -ENOMEM;}struct my_work *my_work = kmalloc(sizeof(struct my_work), GFP_KERNEL);if (!my_work) {return -ENOMEM;}INIT_WORK(&my_work->work, my_sync_handler);queue_work(my_workqueue, &my_work->work);return 0;
}

4. 设备驱动程序
在设备驱动程序中，某些操作（如硬件初始化、数据传输等）可以推迟到工作队列中执行。例如：

static void my_device_init_handler(struct work_struct *work) {printk(KERN_INFO "Device initialization handler called\n");// 执行设备初始化操作
}static int __init my_module_init(void) {my_workqueue = create_workqueue("my_workqueue");if (!my_workqueue) {return -ENOMEM;}struct my_work *my_work = kmalloc(sizeof(struct my_work), GFP_KERNEL);if (!my_work) {return -ENOMEM;}INIT_WORK(&my_work->work, my_device_init_handler);queue_work(my_workqueue, &my_work->work);return 0;
}

5. 网络协议栈
在网络协议栈中，某些操作（如数据包处理、连接管理等）可以推迟到工作队列中执行。例如：

static void my_packet_handler(struct work_struct *work) {printk(KERN_INFO "Packet handler called\n");// 处理数据包
}static int __init my_module_init(void) {my_workqueue = create_workqueue("my_workqueue");if (!my_workqueue) {return -ENOMEM;}struct my_work *my_work = kmalloc(sizeof(struct my_work), GFP_KERNEL);if (!my_work) {return -ENOMEM;}INIT_WORK(&my_work->work, my_packet_handler);queue_work(my_workqueue, &my_work->work);return 0;
}

6. 用户空间请求
在处理用户空间请求时，某些操作可以推迟到工作队列中执行。例如：

static void my_user_request_handler(struct work_struct *work) {printk(KERN_INFO "User request handler called\n");// 处理用户请求
}static int __init my_module_init(void) {my_workqueue = create_workqueue("my_workqueue");if (!my_workqueue) {return -ENOMEM;}struct my_work *my_work = kmalloc(sizeof(struct my_work), GFP_KERNEL);if (!my_work) {return -ENOMEM;}INIT_WORK(&my_work->work, my_user_request_handler);queue_work(my_workqueue, &my_work->work);return 0;
}

注意事项

    工作函数的执行环境：工作函数在工作线程中执行，允许睡眠，因此可以执行耗时操作。
    工作队列的销毁：在模块退出时，确保使用 flush_workqueue 等待所有工作完成，然后使用 destroy_workqueue 销毁工作队列。
    工作项的释放：在工作函数中，确保释放分配的工作项，避免内存泄漏。

通过这些示例，你可以看到 work_struct 可以处理多种类型的任务，包括中断处理、定时任务、文件系统操作、设备驱动程序、网络协议栈和用户空间请求等。这使得 work_struct 成为内核中处理异步任务的强大工具。