工作队列——workqueue 与 tasklet
workqueue与tasklet功能相似，都是让某个函数在将来被调用。但是两者件也有一些区别：
- tasklet在软件中断上下文中运行，tasklet代码必须是原子的。工作队列在一个特殊的内核线程的上下文中运行，工作队列允许休眠；
- tasklet始终运行在被初始提交的同一处理器上，工作队列不是一定的；
- tasklet函数通常立即得到执行，但始终不会晚于下一个定时器滴答；工作队列函数延迟执行的时间间隔可以设定；
工作队列
工作队列（workqueue）是一种将工作推后执行的形式。工作队列可以把工作推后，交由一个内核线程去执行。
数据结构：
把推后执行的任务叫做工作（work），描述它的数据结构为work_struct：
struct work_struct {
atomic_long_t data; /*工作处理函数func的参数*/
#define WORK_STRUCT_PENDING 0 /* T if work item pending execution */
#define WORK_STRUCT_STATIC 1 /* static initializer (debugobjects) */
#define WORK_STRUCT_FLAG_MASK (3UL)
#define WORK_STRUCT_WQ_DATA_MASK (~WORK_STRUCT_FLAG_MASK)
struct list_head entry; /*连接工作的指针*/
work_func_t func; /*工作处理函数*/
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
}; 把工作（work）连接成队列称为工作队列（workqueue），其数据结构为workqueue_struct：
头文件
struct workqueue_struct {
struct cpu_workqueue_struct *cpu_wq;
struct list_head list;
const char *name; /*workqueue name*/
int singlethread; /*是不是单线程 - 单线程我们首选第一个CPU -0表示采用默认的工作者线程event*/
int freezeable; /* Freeze threads during suspend */
int rt;
}; 1. 创建工作队列
struct workqueue_struct *create_workqueue(const char *name) //多处理下 创建多个内核线程
struct workqueue_struct *create_singlethread_workqueue(const char *name) // 仅对应一个内核线程
函数传参是内核中工作队列的名称，返回值是workqueue_struct结构体的指针，该结构体用来维护一个等待队列。
例如：
struct workqueue_struct * test_wq; //定义工作队列
test_wq = create_workqueue(" testwq");2. 创建工作（work）
- 静态创建
DECLARE_WORK(n, f)；
DECLARE_DELAYED_WORK(n, f)；
头文件#include 定义并初始化一个叫 n 的work_struct 数据结构，它对应的的处理函数是f。
- 动态创建
/*初始化之前需要定义一个work_struct 结构*/
INIT_WORK(struct work_struct work, work_func_t func); /*初始化work_struct 结构*/
PREPARE_WORK(struct work_struct work, work_func_t func); /*一般用于更新work_struct 结构*/
INIT_DELAYED_WORK(struct delayed_work work, work_func_t func); /*初始化一个延时任务*/
PREPARE_DELAYED_WORK(struct delayed_work work, work_func_t func); /*linux/workqueue.h*/
#define INIT_WORK(_work, _func) \
do { \
(_work)->data = (atomic_long_t) WORK_DATA_INIT(); \
INIT_LIST_HEAD(&(_work)->entry); \
PREPARE_WORK((_work), (_func)); \
} while (0)
#endif3. 将work添加到queue
工作队列和worl结构体都已经实现了，接下来就可以调度了，使用一下函数：
/*kernel/workqueue.c*/
int queue_work(struct workqueue_struct *wq, struct work_struct *work);
int queue_delayed_work(struct workqueue_struct *wq, struct work_struct *work, unsigned long delay);
将指定的任务（work_struct），添加到指定的工作队列中。调度并不代表处理函数能够马上执行，这由内核进程调度决定。
4. 注销工作队列
刷新等待队列函数：
/*kernel/workqueue.c*/
void flush_workqueue(struct workqueue_struct *wq)
该函数会一直等待，知道指定的等待队列中所有的任务都执行完毕并从等待队列中移除。
注销等待队列：
/*kernel/workqueue.c*/
void destroy_workqueue(struct workqueue_struct *wq)
该函数是是创建等待队列的反操作，注销掉指定的等待队列。普通任务示例：
struct workqueue_struct *wq;
struct work_struct work;
wq = create_workqueue("workqueue");
INIT_WORK(&work, func);
queue_work(wq, &work);
destroy_workqueue(wq);延迟任务示例：
struct workqueue_struct *wq;
struct delayed_work work;
wq = create_workqueue("workqueue");
INIT_DELAYED_WORK(&work, func);
queue_delayed_work(wq, &work, timeout * HZ);
cancel_delayed_work(&work);
destroy_workqueue(wq);工作队列应用示例：
#include [%s]" fmt, __FUNCTI ON__, ##args)
#else
#define P_DEBUG(fmt, args...) printk("<7>" "[%s]" fmt, __FUNCTI ON__, ##args)
#endif
struct workqueue_struct *ZP1015_wq; //1.定义工作队列
struct work_struct ZP1015_work; //2定义work结构体
void ZP1015_func(struct work_struct *work) //2实现处理函数
{
printk("hello ZP1015!\n");
}
irqreturn_t irq_handler(int irqno, void *dev_id)
{
printk("key down\n");
queue_work(ZP1015_wq ,&ZP1015_work); //3调度任务
return IRQ_HANDLED;
}
static int __init test_init(void) //模块初始化函数
{
int ret;
/*work*/
ZP1015_wq = create_workqueue("ZP1015"); //1初始化工作对列
INIT_WORK(&ZP1015_work, ZP1015_func); //2初始化work结构体
ret = request_irq(IRQ_EINT1, irq_handler,
IRQF_TRIGGER_FALLING, "key INT_EINT1", NULL);
if(ret){
P_DEBUG("request irq failed!\n");
return ret;
}
printk("hello irq\n");
return 0;
}
static void __exit test_exit(void) //模块卸载函数
{
flush_workqueue(ZP1015_wq); //4刷新工作队列
destroy_workqueue(ZP1015_wq); //4注销工作队列
free_irq(IRQ_EINT1, NULL);
printk("good bye irq\n");
}
module_init(test_init);
module_exit(test_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ZP1015");
MODULE_VERSION("v0.1");
共享队列
共享队列就是使用共享的工作队列，从而省去创建和注销工作队列的步骤。
当然，如果有多个不同的任务都加入到这个工作对列中，每个任务调度的速度就会比较慢，肯定不如自己创建一个爽。不过，一般默认工作队列都能满足要求，不需要创建一个新的。
共享队列使用分为两步：
1. 定义并初始化work_struct结构体；定义 func 函数；（这里和上面的初始化完全相同）
2. 任务调度；
任务调度：
/*kernel/workqueue.c*/
int schedule_work(struct work_struct *work)
int schedule_work(struct work_struct *work)
{
return queue_work(keventd_wq, work);
}该函数会把 work_struct 结构体加入到默认工作队列events中。
代码示例：
#include [%s]"fmt, __FUNCTI ON__, ##args)
#else
#define P_DEBUG(fmt, args...) printk("<7>" "[%s]"fmt, __FUNCTI ON__, ##args)
#endif
struct work_struct ZP1015_work; //定义work结构体
void ZP1015_func(struct work_struct *work)
{
printk("hello Linux world!\n");
}
irqreturn_t irq_handler(int irqno, void *dev_id) //中断处理函数
{
printk("key down\n");
schedule_work(&ZP1015_work); //调度任务
return IRQ_HANDLED;
}
static int __init test_init(void) //模块初始化函数
{
int ret;
/*work*/
INIT_WORK(&ZP1015_work, ZP1015_func); //初始化work结构体
ret = request_irq(IRQ_EINT1, irq_handler,
IRQF_TRIGGER_FALLING, "key INT_EINT1", NULL);
if(ret){
P_DEBUG("request irq failed!\n");
return ret;
}
printk("hello irq\n");
return 0;
}
static void __exit test_exit(void) //模块卸载函数
{
free_irq(IRQ_EINT1, NULL);
printk("good bye irq\n");
}
module_init(test_init);
module_exit(test_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ZP1015");
MODULE_VERSION("v0.1");