linux中断控制之工作队列

工作队列是将工作推后执行的一种机制，并且可以睡眠。

工作队列结构

定义于#include<linux/workqueue.h>  内核3.1.4  源码位于kernel/workqueue.c

先看工作队列结构

struct work_struct {

atomic_long_t data;

struct list_head entry;

work_func_t func;

#ifdef CONFIG_LOCKDEP

struct lockdep_map lockdep_map;

#endif

};

data的类型是atomic_long_t，只是个原子类型，相当于老版内核中的pending和wq_data的复合体。

entry循环链表结构。

func的参数是work_struct指针，typedef void (*work_func_t)(struct work_struct *work)。

1.怎么把用户的数据作为参数传递给func呢？

与老版2.6.19不同，老版的有定义void* data作为传递参数，而这里是通过container_of来得到用户数据

2.如何延时操作？

老版2.6.19以前有定义timer，这里定义了新的结构delayed_work

struct delayed_work {

struct work_struct work;

struct timer_list timer;

};

创建工作队列

#define   create_workqueue(name) \

alloc_workqueue((name), WQ_MEM_RECLAIM, 1)

#define create_freezable_workqueue(name) \

alloc_workqueue((name), WQ_FREEZABLE | WQ_UNBOUND | WQ_MEM_RECLAIM, 1)

#define create_singlethread_workqueue(name) \

alloc_workqueue((name), WQ_UNBOUND | WQ_MEM_RECLAIM, 1)

创建工作

#define DECLARE_WORK(n, f) \

struct work_struct n = __WORK_INITIALIZER(n, f)

#define __WORK_INITIALIZER(n, f) { \

.data = WORK_DATA_STATIC_INIT(), \

.entry = { &(n).entry, &(n).entry }, \

.func = (f), \

__WORK_INIT_LOCKDEP_MAP(#n, &(n)) \

}

定义名为n的work_struct类型变量，func是work_func_t类型

#define   INIT_WORK(_work, _func) \

do { \

__INIT_WORK((_work), (_func), 0); \

} while (0)

#ifdef CONFIG_LOCKDEP

#define __INIT_WORK(_work, _func, _onstack) \

do { \

static struct lock_class_key __key; \

\

__init_work((_work), _onstack); \

(_work)->data = (atomic_long_t) WORK_DATA_INIT(); \

lockdep_init_map(&(_work)->lockdep_map, #_work, &__key, 0);\

INIT_LIST_HEAD(&(_work)->entry); \

PREPARE_WORK((_work), (_func)); \

} while (0)

#else

#define __INIT_WORK(_work, _func, _onstack) \

do { \

__init_work((_work), _onstack); \

(_work)->data = (atomic_long_t) WORK_DATA_INIT(); \

INIT_LIST_HEAD(&(_work)->entry); \

PREPARE_WORK((_work), (_func)); \      工作已提交到工作队列，只需修改该结构

} while (0)

#endif

宏里面还是宏，一层一层的展开，有兴趣的可以研究下。添加work变量，首次构造该结构时使用

提交工作

int   queue_work(struct workqueue_struct *wq, struct work_struct *work)

{

int ret;

ret = queue_work_on(get_cpu(), wq, work);    // 通过queue_work_on()调用__queue_work()

put_cpu();

return ret;

}

int   schedule_work(struct work_struct *work)

{

return queue_work(system_wq, work);

}

对于工作和工作队列的操作，效果是一样 其他也类似

int queue_delayed_work(struct workqueue_struct *wq,

struct delayed_work *dwork, unsigned long delay)

{

if (delay == 0)

return queue_work(wq, &dwork->work);

return queue_delayed_work_on(-1, wq, dwork, delay);

}

延时delay后才被执行

取消工作

bool cancel_delayed_work_sync(struct delayed_work *dwork)

{

return __cancel_work_timer(&dwork->work, &dwork->timer);

}

void flush_workqueue(struct workqueue_struct *wq);

flush_workqueue并不会取消任何延迟执行的工作，因此如果要取消延迟工作，应该调用cancel_delayed_work_sync()。

释放工作队列

void destroy_workqueue(struct workqueue_struct *queue);

用例：

struct my_struct_t {

    char *name;

    struct work_struct my_work;

};

 

void my_func(struct work_struct *work)

{

    struct my_struct_t *my_name = container_of(work, struct my_struct_t, my_work);

    printk(KERN_INFO “my name is %s!\n”, my_name->name);

}

 

struct workqueue_struct *my_wq;    //全局变量

struct my_struct_t my_name;            //全局变量

 

//初始化函数中定义

my_wq = create_workqueue(“my wq”);

my_name.name = “William”; 

INIT_WORK(&(my_name.my_work), my_func);

queue_work(my_wq, &(my_name.my_work));

 

//卸载函数中使用

destroy_workqueue(my_wq);