首页 > Linux教程 > 正文

linux下的工作队列

对于linux中的工作队列,当然有很多书上都写了,网上也有很多文章反复的写.但是这里还是要写一写,作为内核中虽然小但是很重要的一个应用,基础要打扎实,理清原理.在3.1.1内核中和以前内核中有了些许变化. 这里参考资料:《深入linux设备驱动程序内核机制》、《深入理解linux内核》 《精通linux驱动程序开发》等.

    内核中基本结构定义和基本操作函数:kernel/workqueue.c  

                                                       include/linux/workqueue.c

这里并不准备先介绍结构体定义和操作函数或者宏,而是先看一个实际代码的例子:

drivers/isdn/capi/kcapi.c


/*

* The notifier will result in adding/deleteing of devices. Devices can

* only removed in user process, not in bh.

*/

static int notify_push(unsigned int event_type, u32 controller)

{

struct capictr_event *event = kmalloc(sizeof(*event), GFP_ATOMIC);


if (!event)

return -ENOMEM;


INIT_WORK(&event->work, do_notify_work);

event->type = event_type;

event->controller = controller;


queue_work(kcapi_wq, &event->work);

return 0;

}

这里我们只关注粗体部分,INIT_WORK故名思意初始化工作,我们看看它具体做了什么.

#define INIT_WORK(_work, _func) \

do { \

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

} while (0)

/*

* initialize all of a work item in one go

*

* NOTE! No point in using "atomic_long_set()": using a direct

* assignment of the work data initializer allows the compiler

* to generate better code.

*/

#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

我们继续看PREPARE_WORK:

/*

* initialize a work item's function pointer

*/

#define PREPARE_WORK(_work, _func) \

do { \

(_work)->func = (_func); \

} while (0)

不用多说,很简单.不过这里觉得有必要把工作的结构体贴出来:

struct work_struct {

   atomic_long_t data;

   struct list_head entry;

   work_func_t func;

   #ifdef CONFIG_LOCKDEP

   struct lockdep_map lockdep_map;

   #endif

};

还有间接使用的结构体:

struct capictr_event {

   struct work_struct work;

   unsigned int type;

   u32 controller;

};

初始化完工作及其延时要执行的函数,这里我们看下延时执行的函数(也就是我们想要完成的任务).

static void do_notify_work(struct work_struct *work)

{

   struct capictr_event *event =

   container_of(work, struct capictr_event, work);



   blocking_notifier_call_chain(&ctr_notifier_list, event->type,

       (void *)(long)event->controller);

   kfree(event);

}

这里也不多解释,只需要注意下系统宏 container_of使用的意义就行.

我们回到刚开始的部分,接着是

queue_work(kcapi_wq, &event->work);


也就是把我们的工作加入到工作队列中,然后由队列管理延时操作.

/**

* queue_work - queue work on a workqueue

* @wq: workqueue to use

* @work: work to queue

*

* Returns 0 if @work was already on a queue, non-zero otherwise.

*

* We queue the work to the CPU on which it was submitted, but if the CPU dies

* it can be processed by another CPU.

*/

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

{

   int ret;


   ret = queue_work_on(get_cpu(), wq, work);

   put_cpu();


   return ret;

}

下面我们就看看工作队列的创建:

基本的创建工作队列函数有两个:

#define create_workqueue(name) \

alloc_workqueue((name), WQ_MEM_RECLAIM, 1)


******************************

我们看具体的初始化:

static struct workqueue_struct *kcapi_wq;

static int __init kcapi_init(void)

{

int err;


kcapi_wq = alloc_workqueue("kcapi", 0, 0);

if (!kcapi_wq)

return -ENOMEM;


register_capictr_notifier(&capictr_nb);


err = cdebug_init();

if (err) {

unregister_capictr_notifier(&capictr_nb);

destroy_workqueue(kcapi_wq);

return err;

}



kcapi_proc_init();

return 0;

}

到这里我想大家已经清晰了.

说到工作队列,我们就不得不提下软中断、tasklet. 基本原理是一样的.有兴趣的可以自己看相关代码分析学习.这里就简单总结下它们的区别和应用场景:

工作队列:延时操作运行在进程的上下文中,运行睡眠.

tasklet:动态分配,延时操作运行在中断上下文中,不能睡眠,并且一个tasklet任意时刻,只能运行一个实例.

软中断:它是静态分配的,可以并发的在多个cpu上运行,可重入,必须明确的使用自旋锁.


相关词搜索:linux 队列

上一篇:service命令用于管理Linux操作系统中服务
下一篇:MySQL 5.5 和 5.6 默认参数值的差异总结

版权声明:本站文章除非注明,均为原创内容,如需转载请务必注明出处,违者本站保留追究其法律责任之权利。