linux工作队列

最新推荐文章于 2024-07-19 15:34:26 发布

weixin_42678199

最新推荐文章于 2024-07-19 15:34:26 发布

阅读量810

点赞数

参考：

http://blog.chinaunix.net/uid-24148050-id-296982.html

http://blog.csdn.net/myarrow/article/details/8090504

1 简介

workqueue与tasklet类似，都是允许内核代码请求某个函数在将来的时间被调用（抄《ldd3》上的）每个workqueue就是一个内核进程。

workqueue与tasklet的区别：
   1.tasklet是通过软中断实现的，在软中断上下文中运行，tasklet代码必须是原子的，workqueue是通过内核进程实现的，就没有上述限制的，最爽的是，工作队列函数可以休眠
      PS: 我的驱动模块就是印在计时器中调用了可休眠函数，所以出现了cheduling while atomic告警
        内核计时器也是通过软中断实现的
   2.tasklet始终运行在被初始提交的同一处理器上，workqueue不一定
   3.tasklet不能确定延时时间（即使很短），workqueue可以设定延迟时间

二、workqueue的API

workqueue的API自2.6.20后发生了变化

1. #include <linux/workqueue.h>

2. struct workqueue_struct;

3. struct work_struct;

5. structworkqueue_struct *create_workqueue(const char *name);

6. void destroy_workqueue(struct workqueue_struct *queue);

8. INIT_WORK(_work, _func);

9. INIT_DELAYED_WORK(_work, _func);

10.

11.int queue_work(struct workqueue_struct *wq, struct work_struct *work);

12.int queue_delayed_work(struct workqueue_struct *wq,struct delayed_work *dwork, unsigned long delay);

13.

14.int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,

15. structdelayed_work *dwork, unsigned long delay);

16.

17.int cancel_work_sync(struct work_struct *work);

18.int cancel_delayed_work_sync(struct delayed_work *dwork);

19.

20.void flush_workqueue(struct workqueue_struct *wq);

每个工作队列有一个或多个专用的进程("内核线程"), 它运行提交给这个队列的函数. 如果你使用create_workqueue, 你得到一个工作队列它有一个专用的线程在系统的每个处理器上. 在很多情况下, 所有这些线程是简单的过度行为; 如果一个单个工作者线程就足够, 使用create_singlethread_workqueue 来代替创建工作队列。

工作队列有一个 struct workqueue_struct 类型, 在 <Linux/workqueue.h> 中定义. 一个工作队列必须明确的在使用前创建,使用一个下列的 2 个函数:

struct workqueue_struct *create_workqueue(const char *name);

struct workqueue_struct *create_singlethread_workqueue(const char *name);

提交一个任务给一个工作队列, 你需要填充一个 work_struct结构.这可以在编译时完成,如下:

DECLARE_WORK(name, void (*function)(void *), void *data);

这里 name 是声明的结构名称,function 是从工作队列被调用的函数,以及 data 是一个传递给这个函数的值. 如果你需要建立work_struct 结构在运行时,使用下面 2 个宏定义:

INIT_WORK(struct work_struct *work, void (*function)(void *), void *data);

PREPARE_WORK(struct work_struct *work, void (*function)(void *), void *data);

INIT_WORK做更加全面的初始化结构的工作;你应当在第一次建立结构时使用它.PREPARE_WORK 做几乎同样的工作,但是它不初始化用来连接work_struct 结构到工作队列的指针.如果有任何的可能性这个结构当前被提交给一个工作队列,并且你需要改变这个队列,使用PREPARE_WORK 而不是INIT_WORK.

有 2 个函数来提交工作给一个工作队列:

int queue_work(struct workqueue_struct *queue, struct work_struct *work);

int queue_delayed_work(struct workqueue_struct *queue, struct work_struct *work, unsigned long delay);

每个都添加工作到给定的队列. 如果使用queue_delay_work, 但是,实际的工作没有进行直到至少delay jiffies 已过去.从这些函数的返回值是0 如果工作被成功加入到队列;一个非零结果意味着这个work_struct 结构已经在队列中等待,并且第 2 次没有加入.

在将来的某个时间, 这个工作函数将被使用给定的 data 值来调用. 这个函数将在工作者线程的上下文运行,因此它可以睡眠如果需要-- 尽管你应当知道这个睡眠可能怎样影响提交给同一个工作队列的其他任务.这个函数不能做的是,但是, 是存取用户空间. 因为它在一个内核线程中运行, 完全没有用户空间来存取.

如果你需要取消一个挂起的工作队列入口, 你可以调用:

int cancel_delayed_work(struct work_struct *work);

返回值是非零如果这个入口在它开始执行前被取消. 内核保证给定入口的执行不会在调用cancel_delay_work 后被初始化.如果cancel_delay_work 返回0, 但是, 这个入口可能已经运行在一个不同的处理器,并且可能仍然在调用cancel_delayed_work 后在运行.要绝对确保工作函数没有在cancel_delayed_work 返回0 后在任何地方运行,你必须跟随这个调用来调用:

void flush_workqueue(struct workqueue_struct *queue);

在 flush_workqueue 返回后, 没有在这个调用前提交的函数在系统中任何地方运行.

当你用完一个工作队列, 你可以去掉它, 使用:

void destroy_workqueue(struct workqueue_struct *queue);

Workqueue编程接口

序号	接口函数	说明
1	create_workqueue	用于创建一个workqueue队列，为系统中的每个CPU都创建一个内核线程。输入参数： @name：workqueue的名称
2	create_singlethread_workqueue	用于创建workqueue，只创建一个内核线程。输入参数： @name：workqueue名称
3	destroy_workqueue	释放workqueue队列。输入参数： @ workqueue_struct：需要释放的workqueue队列指针
4	schedule_work	调度执行一个具体的任务，执行的任务将会被挂入Linux系统提供的workqueue——keventd_wq输入参数： @ work_struct：具体任务对象指针
5	schedule_delayed_work	延迟一定时间去执行一个具体的任务，功能与schedule_work类似，多了一个延迟时间，输入参数： @work_struct：具体任务对象指针 @delay：延迟时间
6	queue_work	调度执行一个指定workqueue中的任务。输入参数： @ workqueue_struct：指定的workqueue指针 @work_struct：具体任务对象指针
7	queue_delayed_work	延迟调度执行一个指定workqueue中的任务，功能与queue_work类似，输入参数多了一个delay。

下面实例是不指定delay时间的workqueue
(代码基于2.6.24)

1. struct my_work_stuct{

2. int test;

3. structwork_stuct save;

4. };

6. struct my_work_stucttest_work;

7. structworkqueue_struct *test_workqueue;

9. void do_save(struct work_struct *p_work)

10.{

11. structmy_work_struct *p_test_work = container_of(p_work, struct my_work_stuct, save);

12. printk("%d\n",p_test_work->test);

13.}

14.

15.void test_init()

16.{

17. test_workqueue = create_workqueue("test_workqueue");

18. if (!test_workqueue)

19. panic("Failed to createtest_workqueue\n");

20.

21. INIT_WORK(&(test_work.save), do_save);

22.

23. queue_work(test_workqueue, &(test_work.save));

24.}

25.

26.void test_destory(void)

27.{

28. if(test_workqueue)

29. destroy_workqueue(test_workqueue);

30.}

三、workqueue的实现

工作队列workqueue不是通过软中断实现的，它是通过内核进程实现的

我们把推后执行的任务叫做工作（work），描述它的数据结构为work_struct:

[cpp] view plain copy

1. struct work_struct {

2. atomic_long_t data; /*工作处理函数func的参数*/

3. #define WORK_STRUCT_PENDING 0 /* T if work item pending execution */

4. #define WORK_STRUCT_STATIC 1 /* static initializer (debugobjects) */

5. #define WORK_STRUCT_FLAG_MASK (3UL)

6. #define WORK_STRUCT_WQ_DATA_MASK (~WORK_STRUCT_FLAG_MASK)

7. struct list_head entry; /*连接工作的指针*/

8. work_func_t func; /*工作处理函数*/

9. #ifdef CONFIG_LOCKDEP

10. struct lockdep_map lockdep_map;

11. #endif

12. };

这些工作以队列结构组织成工作队列（workqueue），其数据结构为workqueue_struct:

[cpp] view plain copy

1. struct workqueue_struct {

2. struct cpu_workqueue_struct *cpu_wq;

3. struct list_head list;

4. const char *name; /*workqueue name*/

5. int singlethread; /*是不是单线程 - 单线程我们首选第一个CPU -0表示采用默认的工作者线程event*/

6. int freezeable; /* Freeze threads during suspend */

7. int rt;

8. };

如果是多线程，Linux根据当前系统CPU的个数创建cpu_workqueue_struct 其结构体就是:

[cpp] view plain copy

1. struct cpu_workqueue_struct {

2. spinlock_t lock;/*因为工作者线程需要频繁的处理连接到其上的工作，所以需要枷锁保护*/

3. struct list_head worklist;

4. wait_queue_head_t more_work;

5. struct work_struct *current_work; /*当前的work*/

6. struct workqueue_struct *wq; /*所属的workqueue*/

7. struct task_struct *thread; /*任务的上下文*/

8. } ____cacheline_aligned;

在该结构主要维护了一个任务队列，以及内核线程需要睡眠的等待队列，另外还维护了一个任务上下文，即task_struct。

三者之间的关系如下：

首先，创建一个workqueue，实际上就是建立一个内核进程

1. create_workqueue("tap_workqueue")

2. --> __create_workqueue(“tap_workqueue”, 0, 0)

3. --> __create_workqueue_key((name), (singlethread), (freezeable), NULL, NULL){

4. wq = kzalloc(sizeof(*wq), GFP_KERNEL);

5. wq->cpu_wq = alloc_percpu(struct cpu_workqueue_struct);

6. wq->name = name;

7. wq->singlethread = singlethread;

8. wq->freezeable = freezeable;

9. INIT_LIST_HEAD(&wq->list);

10.

11. for_each_possible_cpu(cpu) {

12. cwq = init_cpu_workqueue(wq, cpu);

13. err = create_workqueue_thread(cwq, cpu);

14. start_workqueue_thread(cwq, cpu);

15. }

16. }

create_workqueue_thread 建立了一个内核进程 worker_thread（linux_2_6_24/kernel/workqueue.c）

1. create_workqueue_thread(struct cpu_workqueue_struct *cwq, int cpu)

2. {

3. structworkqueue_struct *wq = cwq->wq;

5. const char *fmt = is_single_threaded(wq) ? "%s" : "%s/%d";

6. structtask_struct *p;

8. p = kthread_create(worker_thread, cwq, fmt, wq->name, cpu);

10. if (IS_ERR(p))

11. returnPTR_ERR(p);

12.

13. cwq->thread = p;

14.

15. return0;

16.}

内核进程worker_thread做的事情很简单，死循环而已，不停的执行workqueue上的work_list
（linux_2_6_24/kernel/workqueue.c）

1. int worker_thread (void *__cwq)

2. {

3. structcpu_workqueue_struct *cwq = __cwq;

4. /*下面定义等待队列项*/

5. DEFINE_WAIT(wait);

7. /*下面freezeable一般为0*/

8. if (cwq->wq->freezeable)

9. set_freezable();

10.

11. /*提高优先级别*/

12. set_user_nice(current, -5);

13.

14. for (;;) {

15. /*在cwq->more_work上等待, 若有人调用queue_work,该函数将调用wake_up(&cwq->more_work) 激活本进程*/

16. prepare_to_wait(&cwq->more_work, &wait, TASK_INTERRUPTIBLE);

17.

18. /*work队列空则切换出去*/

19. if (!freezing(current) && !kthread_should_stop() && list_empty(&cwq->worklist))

20. schedule();

21.

22.

23. /*切换回来则结束等待说明有人唤醒cwq->more_work上的等待有work需要处理*/

24. finish_wait(&cwq->more_work, &wait);

25.

26. /*下面空，因为没有定义电源管理*/

27. try_to_freeze();

28.

29. if (kthread_should_stop())

30. break;

31.

32. /*run_workqueue依次处理工作队列上所有的work*/

33. run_workqueue(cwq);

34. }

35. return0;

36.}

37.

38.

39./*run_workqueue依次处理工作队列上所有的work*/

40.static voidrun_workqueue(struct cpu_workqueue_struct *cwq)

41.{

42. spin_lock_irq(&cwq->lock);

43. cwq->run_depth++;

44. if (cwq->run_depth > 3) {

45. /* morton gets to eat his hat */

46. printk("%s: recursion depth exceeded:%d\n",

47. __FUNCTION__, cwq->run_depth);

48. dump_stack();

49. }

50.

51. while (!list_empty(&cwq->worklist)) {

52. structwork_struct *work = list_entry(cwq->worklist.next,

53. structwork_struct, entry);

54. work_func_tf = work->func;

55.#ifdef CONFIG_LOCKDEP

56. /*

57. * It is permissible to free the struct work_struct

58. * from inside the function that is called from it,

59. * this we need to take into account for lockdep too.

60. * To avoid bogus "held lock freed" warnings as well

61. * as problems when looking intowork->lockdep_map,

62. * make a copy and use that here.

63. */

64. structlockdep_map lockdep_map = work->lockdep_map;

65.#endif

66.

67. cwq->current_work = work;

68. list_del_init(cwq->worklist.next);

69. spin_unlock_irq(&cwq->lock);

70.

71. BUG_ON(get_wq_data(work) != cwq);

72. work_clear_pending(work);

73. lock_acquire(&cwq->wq->lockdep_map, 0, 0, 0, 2, _THIS_IP_);

74. lock_acquire(&lockdep_map, 0, 0, 0, 2, _THIS_IP_);

75.

76. f(work); /*执行work项中的func*/

77.

78. lock_release(&lockdep_map, 1, _THIS_IP_);

79. lock_release(&cwq->wq->lockdep_map, 1, _THIS_IP_);

80.

81. if (unlikely(in_atomic() || lockdep_depth(current) > 0)) {

82. printk(KERN_ERR "BUG: workqueue leaked lock or atomic: "

83. "%s/0x%08x/%d\n",

84. current->comm, preempt_count(),

85. task_pid_nr(current));

86. printk(KERN_ERR " last function: ");

87. print_symbol("%s\n", (unsigned long)f);

88. debug_show_held_locks(current);

89. dump_stack();

90. }

91.

92. spin_lock_irq(&cwq->lock);

93. cwq->current_work = NULL;

94. }

95. cwq->run_depth--;

96. spin_unlock_irq(&cwq->lock);

97.}

将一个work加入到指定workqueue的work_list中（文件linux_2_6_24/kernel/workqueue.c）

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

1. {

2. int ret = 0;

4. if (!test_and_set_bit(WORK_STRUCT_PENDING, work_data_bits(work))) {

5. BUG_ON(!list_empty(&work->entry));

6. __queue_work(wq_per_cpu(wq, get_cpu()), work);

7. put_cpu();

8. ret = 1;

9. }

10. returnret;

11.}

12.

13.

14./* Preempt must be disabled. */

15.static void __queue_work(struct cpu_workqueue_struct *cwq, struct work_struct *work)

16.{

17. unsignedlong flags;

18.

19. spin_lock_irqsave(&cwq->lock, flags);

20. insert_work(cwq, work, 1);

21. spin_unlock_irqrestore(&cwq->lock, flags);

22.}

23.

24.static void insert_work(struct cpu_workqueue_struct *cwq,

25. structwork_struct *work, int tail)

26.{

27. set_wq_data(work, cwq);

28. /*

29. * Ensure that we get the right work->data if we see the

30. * result of list_add() below, see try_to_grab_pending().

31. */

32. smp_wmb();

33. if (tail)

34. list_add_tail(&work->entry, &cwq->worklist);

35. else

36. list_add(&work->entry, &cwq->worklist);

37. wake_up(&cwq->more_work);

38.}

四、共享队列

其实内核有自己的一个workqueue，叫keventd_wq，这个工作队列也叫做“共享队列”。
do_basic_setup --> init_workqueues -->create_workqueue("events");

若驱动模块使用的workqueue功能很简单的话，可以使用“共享队列”，不用自己再建一个队列
使用共享队列，有这样一套API

1. int schedule_work(struct work_struct *work)

2. {

3. queue_work(keventd_wq, work);

4. }

6. int schedule_delayed_work(struct delayed_work *dwork,unsigned long delay)

7. {

8. timer_stats_timer_set_start_info(&dwork->timer);

9. returnqueue_delayed_work(keventd_wq, dwork, delay);

10.}

11.

12.void flush_scheduled_work(void)

13.{

14. flush_workqueue(keventd_wq);

15.}

补充部分：

3. 创建工作
3.1 创建工作queue
a. create_singlethread_workqueue(name)
该函数的实现机制如下图所示，函数返回一个类型为struct workqueue_struct的指针变量，该指针变量所指向的内存地址在函数内部调用kzalloc动态生成。所以driver在不再使用该work queue的情况下调用:

void destroy_workqueue(struct workqueue_struct *wq)来释放此处的内存地址。

图中的cwq是一per-CPU类型的地址空间。对于create_singlethread_workqueue而言，即使是对于多CPU系统，内核也只负责创建一个worker_thread内核进程。该内核进程被创建之后，会先定义一个图中的wait节点，然后在一循环体中检查cwq中的worklist，如果该队列为空，那么就会把wait节点加入到cwq中的more_work中，然后休眠在该等待队列中。

Driver调用queue_work（struct workqueue_struct *wq, structwork_struct *work）向wq中加入工作节点。work会依次加在cwq->worklist所指向的链表中。queue_work向cwq->worklist中加入一个work节点，同时会调用wake_up来唤醒休眠在cwq->more_work上的worker_thread进程。wake_up会先调用wait节点上的autoremove_wake_function函数，然后将wait节点从cwq->more_work中移走。

worker_thread再次被调度，开始处理cwq->worklist中的所有work节点...当所有work节点处理完毕，worker_thread重新将wait节点加入到cwq->more_work，然后再次休眠在该等待队列中直到Driver调用queue_work...

b.create_workqueue

相对于create_singlethread_workqueue,create_workqueue同样会分配一个wq的工作队列，但是不同之处在于，对于多CPU系统而言，对每一个CPU，都会为之创建一个per-CPU的cwq结构，对应每一个cwq，都会生成一个新的worker_thread进程。但是当用queue_work向cwq上提交work节点时，是哪个CPU调用该函数，那么便向该CPU对应的cwq上的worklist上增加work节点。

c.小结
当用户调用workqueue的初始化接口create_workqueue或者create_singlethread_workqueue对workqueue队列进行初始化时，内核就开始为用户分配一个workqueue对象，并且将其链到一个全局的workqueue队列中。然后Linux根据当前CPU的情况，为workqueue对象分配与CPU个数相同的cpu_workqueue_struct对象，每个cpu_workqueue_struct对象都会存在一条任务队列。紧接着，Linux为每个cpu_workqueue_struct对象分配一个内核thread，即内核daemon去处理每个队列中的任务。至此，用户调用初始化接口将workqueue初始化完毕，返回workqueue的指针。

workqueue初始化完毕之后，将任务运行的上下文环境构建起来了，但是具体还没有可执行的任务，所以，需要定义具体的work_struct对象。然后将work_struct加入到任务队列中，Linux会唤醒daemon去处理任务。

上述描述的workqueue内核实现原理可以描述如下：

3.2 创建工作
      要使用工作队列，首先要做的是创建一些需要推后完成的工作。可以通过DECLARE_WORK在编译时静态地建该结构：
       DECLARE_WORK(name,void (*func) (void *),void *data);
      这样就会静态地创建一个名为name，待执行函数为func，参数为data的work_struct结构。
      同样，也可以在运行时通过指针创建一个工作：
      INIT_WORK(structwork_struct *work,woid(*func) (void *), void *data);

4. 调度
a. schedule_work

在大多数情况下, 并不需要自己建立工作队列，而是只定义工作, 将工作结构挂接到内核预定义的事件工作队列中调度, 在kernel/workqueue.c中定义了一个静态全局量的工作队列static struct workqueue_struct*keventd_wq;默认的工作者线程叫做events/n，这里n是处理器的编号，每个处理器对应一个线程。比如，单处理器的系统只有events/0这样一个线程。而双处理器的系统就会多一个events/1线程。
调度工作结构, 将工作结构添加到全局的事件工作队列keventd_wq，调用了queue_work通用模块。对外屏蔽了keventd_wq的接口，用户无需知道此参数，相当于使用了默认参数。keventd_wq由内核自己维护，创建，销毁。这样work马上就会被调度，一旦其所在的处理器上的工作者线程被唤醒，它就会被执行。

b.schedule_delayed_work(&work,delay);
有时候并不希望工作马上就被执行，而是希望它经过一段延迟以后再执行。在这种情况下，同时也可以利用timer来进行延时调度，到期后才由默认的定时器回调函数进行工作注册。延迟delay后，被定时器唤醒，将work添加到工作队列wq中。

工作队列是没有优先级的，基本按照FIFO的方式进行处理。

5. 示例

[cpp] view plain copy

1. #include <linux/module.h>

2. #include <linux/init.h>

3. #include <linux/workqueue.h>

5. static struct workqueue_struct *queue=NULL;

6. static struct work_struct work;

8. staticvoid work_handler(struct work_struct *data)

9. {

10. printk(KERN_ALERT"work handler function.\n");

11. }