linux 内核工作队列

本文介绍: linux 内核工作队列12 / 100

工作队列（ work queue）是使用内核线程异步执行函数的通用机制。
工作队列是中断处理程序的一种下半部机制，中断处理程序可以把耗时比较长并且可能睡眠的函数交给工作队列执行。
工作队列不完全是中断处理程序的下半部。内核的很多模块需要异步执行函数，这些模块可以创建一个内核线程来异步执行函数。但是，如果每个模块都创建自己的内核线程，会造成内核线程的数量过多，内存消耗比较大，影响系统性能。所以，最好的方法是提供一种通用机制，让这些模块把需要异步执行的函数交给工作队列执行，共享内核线程，节省资源。
所以 Wo rk queue 的主要设计思想：一个是并行，多个 work 不要相互阻塞；另外一个是节省资源，多个 work 尽量共享资源 ( 进程、调度、内存 )，不要造成系统过多的资源浪费。
为了实现的设计思想，work queue 的设计实现也更新了很多版本。最新的 work queue 实现叫做 CMWQ(Con cur re nc y Mana g e d Wo rk queue)并发可管理工作队列，也就是用更加智能的算法来实现“并行和节省”。新版本的 workque ue 创建函数改成 alloc _workque ue()，旧版本的函数 create_workque ue() 逐渐会被被废弃。

内核使用工作项保存需要异步执行的函数，工作项的数据类型是 work_struct，需要异步执行的函数的原型如下所示：
struct wo rk_struct {
atomic_long_t data;
struct list_head entry;
wo rk_func_t func;
#ifdef CONFIG_LOCKDEP
struct lock de p_map lock de p_map;
#endif
};

typedef void(*wo rk_func_t)(struct work_struct *wor k)

有一类工作项称为延迟工作项，数据类型是 delay ed_wor k。把延迟工作项添加到工作队列中的时候，延迟一段时间才会真正地把工作项添加到工作队列中。延迟工作项是工作项和定时器的结合，可以避免使用者自己创建定时器。
我们可以使用内核定义的工作队列，也可以自己创建专用的工作队列。内核定义了以下工作队列：
include/linux/wor kqueue.h
extern struc t workqueue_struc t *system_wq;
extern struc t workqueue_struc t *system_hi g h pri_wq;
extern s truc t workqueue_s truc t *system_long_wq;
extern s truct workqueue_s truct *system_unbound_wq;
extern s truct workqueue_s truct *system_fre ez a ble_wq;
extern struct workqueue_struct *system_power_effi cient_wq;
extern struct workqueue_struct *system_fre ez a ble_power_effi cient_wq;

kernel/workqueue.c
int __init workqueue_init_ea rl y(void)
{
……
system_wq = alloc_workqueue(“events“, 0, 0);
system_hi g h pri_wq = alloc_workqueue(“events_hi g h pri”, WQ_HIGHPRI, 0);
system_long_wq = alloc_workqueue(“events_long“, 0, 0);
system_unbound_wq = alloc_workqueue(“events_unbound”, WQ_UNBOUND,
WQ_UNBOUND_MAX_ACTIVE);
system_fre ez a ble_wq = alloc_workqueue(“events_fre ezable“,
WQ_FREEZABLE, 0);
system_power_effi cient_wq = alloc_workqueue(“events_power_effi cient”,
WQ_POWER_EFFICIENT, 0);
system_fre ezable_power_effi cient_wq = alloc_workqueue(“events_freezable_power_effi cient”,
WQ_FREEZABLE | WQ_POWER_EFFICIENT,
0);
BUG_ON(!system_wq || !system_hi g h pri_wq || !sy stem_long_wq ||
!system_unbound_wq || !system_freezable_wq ||
!system_power_effi cient_wq ||
!system_freezable_power_effi cient_wq);

return 0;
}

system_wq：如果工作项的执行时间比较短，应该使用这个工作队列。早期的内核版本只提供了这个工作队列，称为全局工作队列，函数 schedule_work()和 schedule_delayed_work()使用这个工作队列。
system_hi g h pri_wq：高优先级的工作队列。
system_long_wq：如果工作项的执行时间比较长，应该使用这个工作队列。
system_unbound_wq：这个工作队列使用的内核线程不绑定到某个特定的处理器。
system_freezable_wq：这个工作队列可以冻结。
system_power_effi cient_wq：如果开启了工作队列模块的参数“ wq_power_eff ic ient”，那么这个工作队列倾向于省电；否则和 system_wq 相同。
system_freezable_power_efficient_wq：这个工作队列和 system_power_efficient_wq 的区别是可以冻结。

（1）定义工作项。
定义一个静态的工作项，参数 n 是变量名称，参数 f 是工作项的处理函数。
DECLARE_WORK(n, f)
定义一个静态的延迟工作项，参数 n 是变量名称，参数 f 是工作项的处理函数。
DECLARE_DELAYED_WORK(n, f)

使用 DECLARE_DEFERRABLE_WORK(n, f)也可以定义一个静态的延迟工作项，和DECLARE_DELAYED_WORK()的区别是它使用可推迟的定时器（ deferrable timer）。
可推迟的定时器在系统忙的时候工作正常，但是在处理器空闲的时候不会处理可推迟的定时器。当一个不可推迟的定时器唤醒处理器的时候，才会处理可推迟的定时器。

在运行时动态初始化工作项，方法如下。
1） INIT_WORK(_work, _func)：初始化一个工作项，参数_work 是工作项的地址，参数_func 是需要异步执行的函数。
2） INIT_WORK_ONSTACK(_work, _func)：初始化一个工作项，工作项是栈里面的局部变量，参数_work 是工作项的地址，参数_func 是需要异步执行的函数。
3） INIT_DELAYED_WORK(_work, _func)：初始化一个延迟工作项，参数_work 是延迟工作项的地址，参数_func 是需要异步执行的函数。
4） INIT_DELAYED_WORK_ONSTACK(_work, _func)：初始化一个延迟工作项，延迟工作项是栈里面的局部变量，参数_work 是延迟工作项的地址，参数_func 是需要异步执行的函数。
5） INIT_DEFERRABLE_WORK(_work, _func)：初始化一个延迟工作项，和 INIT_DELAYED_WORK()的区别是它使用可推迟的定时器。
6） INIT_DEFERRABLE_WORK_ONSTACK(_work, _func)：初始化一个延迟工作项，延迟工作项是栈里面的局部变量，和 INIT_DELAYED_WORK_ONSTACK()的区别是它使用可推迟的定时器。

（2）全局工作队列。
在全局工作队列中添加一个工作项。
bool schedule_work(struct work_struct *work);
在全局工作队列中添加一个工作项，并且指定执行工作项的处理器。
bool schedule_work_on(int cpu, struct work_struct *work);
在全局工作队列中添加一个延迟工作项，参数 delay 是把工作项添加到工作队列中之前等待的时间，单位是嘀嗒（ tick）。
bool schedule_delayed_work(struct delayed_work *dwork, unsigned long delay);
在全局工作队列中添加一个延迟工作项，并且指定执行工作项的处理器。
bool schedule_delayed_work_on(int cpu, struct delayed_work *dwork,unsigned long delay);
冲刷全局工作队列，确保全局工作队列中的所有工作项执行完。
void flush_scheduled_work(void);
（3）专用工作队列。
分配工作队列的函数是：
alloc_workqueue(fmt, flags, max_active, args…)
1）参数 fmt 是工作队列名称的格式。
2）参数 flags 是标志位，可以是 0，也可以是下面这些标志位的组合。
 WQ_UNBOUND：处理工作项的内核线程不绑定到任何特定的处理器。
 WQ_FREEZABLE：在系统挂起的时候冻结。
 WQ_MEM_RECLAIM：在内存回收的时候可能使用这个工作队列。
 WQ_HIGHPRI：高优先级。
 WQ_CPU_INTENSIVE：处理器密集型。
 WQ_POWER_EFFICIENT：省电。
3）参数 max_ac ti ve 是每个处理器可以同时执行的工作项的最大数量， 0 表示使用默认值256。
4）参数 args 是传给参数 fmt 的参数。

下面的函数用来分配一个有序的工作队列。有序的工作队列在任何时刻，按照入队的顺序只执行一个工作项。
alloc_ordered_workqueue(fmt, flags, args…)

#define alloc_ordered_workqueue(fmt, flags, args…)
alloc_workqueue(fmt, WQ_UNBOUND | __WQ_ORDERED |
__WQ_ORDERED_EXPLICIT | (flags), 1, ##args)

兼容旧旧接口
#define create_workqueue(name)
alloc_workqueue(“%s”, __WQ_LEGACY | WQ_MEM_RECLAIM, 1, (name))
#define create_freezable_workqueue(name)
alloc_workqueue(“%s”, __WQ_LEGACY | WQ_FREEZABLE | WQ_UNBOUND |
WQ_MEM_RECLAIM, 1, (name))
#define create_sin glethread_workqueue(name)
alloc_ordered_workqueue(“%s”, __WQ_LEGACY | WQ_MEM_RECLAIM, name)

在指定的工作队列中添加一个工作项。
bool queue_work(struct workqueue_struct *wq, struct work_struct *work);
在指定的工作队列中添加一个工作项，并且指定执行工作项的处理器。
bool queue_work_on(int cpu, struct workqueue_struct *wq, struct work_struct *work);
在指定的工作队列中添加一个延迟工作项，参数 delay 是把工作项添加到工作队列中之前等待的时间，单位是嘀嗒（ tick）。
bool queue_delayed_work(struct workqueue_struct *wq, struct delayed_work *dwork, unsigned long delay);
在指定的工作队列中添加一个延迟工作项，并且指定执行工作项的处理器。
bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq,struct delayed_work *work, unsigned lon g delay);
冲刷工作队列，确保工作队列中的所有工作项执行完。
void flush_workqueue(struct workqueue_struct *wq);
销毁工作队列的函数是：
void dest roy_workqueue(struct workqueue_struct *wq);

（4）其他编程接口。
取消一个工作项。
bool cancel_work(struct work_struct *work);
取消一个工作项，并且等待取消操作执行完。
bool ca ncel_work_sync(struct work_struct *work);
取消一个延迟工作项。
bool ca ncel_delayed_work(struct delayed_work *dwork);
取消一个延迟工作项，并且等待取消操作执行完。
bool ca ncel_delayed_work_sync(struct delayed_work *dwork);
等待一个工作项执行完。
bool flush_work(struct work_struct *work);
等待一个延迟工作项执行完。
bool flush_delayed_work(struct delayed_work *dwork);
判断任务项目是否在进行中
bool work_pend in g(struct work_struct work );/*返回值为真表示正在运行，假表示停止*/