linux设备驱动归纳总结（六）：3.中断的上半部和下半部——工作队列

ゝ一纸荒年。 2022-04-23 10:58 303阅读 0赞

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

这节介绍另外一种的下半部实现——工作队列。相对于软中断/tasklet，工作对列运行在进程上下文，允许睡眠，接下来慢慢介绍。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

1、工作队列的使用

按惯例，在介绍工作队列如何实现之前，先说说如何使用工作队列实现下半部。

步骤一、定义并初始化工作队列：

创建工作队列函数：

struct workqueue\_struct \*create\_workqueue(const char \*name)

函数传参是内核中工作队列的名称，返回值是workqueue\_struct结构体的指针，该结构体用来维护一个等待队列。

我的代码如下：

/\*6th\_irq\_3/4th/test.c\*/

14 struct workqueue\_struct \*xiaobai\_wq; //定义工作队列

33 xiaobai\_wq = create\_workqueue("xiaobai");

步骤二、定义并初始化work结构体：

内核使用结构体来维护一个加入工作队列的任务：

/\*linux/workqueue.h\*/

25 struct work\_struct \{

26 atomic\_long\_t data;

27 \#define WORK\_STRUCT\_PENDING 0 /\* T if work item pending execution \*/

28 \#define WORK\_STRUCT\_FLAG\_MASK (3UL)

29 \#define WORK\_STRUCT\_WQ\_DATA\_MASK (~WORK\_STRUCT\_FLAG\_MASK)

30 struct list\_head entry;

31 work\_func\_t func; //这个是重点，下半部实现的处理函数指针就放在这

32 \#ifdef CONFIG\_LOCKDEP

33 struct lockdep\_map lockdep\_map;

34 \#endif

35 \};

同样有静态和动态两种方法：

静态定义并初始化work结构体：

/\*linux/workqueue.h\*/

72 \#define DECLARE\_WORK(n, f) \\

73 struct work\_struct n = \_\_WORK\_INITIALIZER(n, f)

定义并初始化一个叫n的work\_struct数据结构，它对应的的处理函数是f。

对应的动态初始化方法，该函数返回work\_struct指针，所以需要先定义一个work\_struct结构：

/\*linux/workqueue.h\*/

107 \#define INIT\_WORK(\_work, \_func) \\

108 do \{ \\

109 (\_work)->data = (atomic\_long\_t) WORK\_DATA\_INIT(); \\

110 INIT\_LIST\_HEAD(&(\_work)->entry); \\

111 PREPARE\_WORK((\_work), (\_func)); \\

112 \} while (0)

113 \#endif

跟tasklet一样，在初始化的同时，需要将处理函数实现，代码如下：

/\*6th\_irq\_3/4th/test.c\*/

15 struct work\_struct xiaobai\_work; //定义work结构体

17 void xiaobai\_func(struct work\_struct \*work) //处理函数

18 \{

19 printk("hello xiaobai!\\n"); //同样什么都没干，只是打印

20 \}

34 INIT\_WORK(&xiaobai\_work, xiaobai\_func); //初始化work结构体

步骤三、在中断处理函数中调度任务：

工作队列和worl结构体都已经实现了，接下来就可以调度了，使用一下函数：

/\*kernel/workqueue.c\*/

161 int queue\_work(struct workqueue\_struct \*wq, struct work\_struct \*work)

将指定的任务（work\_struct），添加到指定的工作队列中。同样的，调度并不代表处理函数能够马上执行，这由内核进程调度决定。

步骤四、在卸载模块时，刷新并注销等待队列：

刷新等待队列函数：

/\*kernel/workqueue.c\*/

411 void flush\_workqueue(struct workqueue\_struct \*wq)

该函数会一直等待，知道指定的等待队列中所有的任务都执行完毕并从等待队列中移除。

注销等待队列：

/\*kernel/workqueue.c\*/

904 void destroy\_workqueue(struct workqueue\_struct \*wq)

该函数是是创建等待队列的反操作，注销掉指定的等待队列。

四个步骤讲完，贴个代码：

/\*6th\_irq\_3/4th/test.c\*/

1 \#include <linux/module.h>

2 \#include <linux/init.h>

4 \#include <linux/interrupt.h>

5 \#include <linux/workqueue.h>

7 \#define DEBUG\_SWITCH 1

8 \#if DEBUG\_SWITCH

9 \#define P\_DEBUG(fmt, args...) printk("<1>" "<kernel>\[%s\]"fmt, \_\_FUNCTI ON\_\_, \#\#args)

10 \#else

11 \#define P\_DEBUG(fmt, args...) printk("<7>" "<kernel>\[%s\]"fmt, \_\_FUNCTI ON\_\_, \#\#args)

12 \#endif

14 struct workqueue\_struct \*xiaobai\_wq; //1.定义工作队列

15 struct work\_struct xiaobai\_work; //2定义work结构体

17 void xiaobai\_func(struct work\_struct \*work) //2实现处理函数

18 \{

19 printk("hello xiaobai!\\n");

20 \}

22 irqreturn\_t irq\_handler(int irqno, void \*dev\_id)

23 \{

24 printk("key down\\n");

25 queue\_work(xiaobai\_wq ,&xiaobai\_work); //3调度任务

26 return IRQ\_HANDLED;

27 \}

28 static int \_\_init test\_init(void) //模块初始化函数

29 \{

30 int ret;

32 /\*work\*/

33 xiaobai\_wq = create\_workqueue("xiaobai"); //1初始化工作对列

34 INIT\_WORK(&xiaobai\_work, xiaobai\_func); //2初始化work结构体

36 ret = request\_irq(IRQ\_EINT1, irq\_handler,

37 IRQF\_TRIGGER\_FALLING, "key INT\_EINT1", NULL);

38 if(ret)\{

39 P\_DEBUG("request irq failed!\\n");

40 return ret;

41 \}

43 printk("hello irq\\n");

44 return 0;

45 \}

47 static void \_\_exit test\_exit(void) //模块卸载函数

48 \{

49 flush\_workqueue(xiaobai\_wq); //4刷新工作队列

50 destroy\_workqueue(xiaobai\_wq); //4注销工作队列

51 free\_irq(IRQ\_EINT1, NULL);

52 printk("good bye irq\\n");

53 \}

55 module\_init(test\_init);

56 module\_exit(test\_exit);

58 MODULE\_LICENSE("GPL");

59 MODULE\_AUTHOR("xoao bai");

60 MODULE\_VERSION("v0.1");

和以往的一样，下半部仅仅是打印，没实质操作，看效果：

\[root: 4th\]\# insmod test.ko

hello irq

\[root: 4th\]\# key down

hello xiaobai!

key down

hello xiaobai!

\[root: 4th\]\# rmmod test

good bye irq

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

二、使用共享的工作队列

在内核中有一个默认的工作队列events，使用共享的工作队列可以省去创建和注销工作队列的步骤。当然，队列是共享的，用起来当然会不爽，如果有多个不同的任务都加入到这个工作对列中，每个任务调度的速度就会比较慢，肯定不如自己创建一个爽。不过，一般默认工作队列都能满足要求，不需要创建一个新的。

少了上面创建和注销等待队列两步，使用共享工作队列步骤相对少一点

步骤一、实现处理函数，定义并初始化work结构体：

这一步骤上一节介绍的步骤二完全一样，所以就不说了。

步骤二、调度任务：

默认工作队列的中任务的调度不需要指定工作对列，所以函数有所不同：

/\*kernel/workqueue.c\*/

620 int schedule\_work(struct work\_struct \*work)

该函数会把work\_struct结构体加入到默认工作对列events中。

上函数：

/\*6th\_irq\_3/3rd/test.c\*/

1 \#include <linux/module.h>

2 \#include <linux/init.h>

4 \#include <linux/interrupt.h>

5 \#include <linux/workqueue.h>

7 \#define DEBUG\_SWITCH 1

8 \#if DEBUG\_SWITCH

9 \#define P\_DEBUG(fmt, args...) printk("<1>" "<kernel>\[%s\]"fmt, \_\_FUNCTI ON\_\_, \#\#args)

10 \#else

11 \#define P\_DEBUG(fmt, args...) printk("<7>" "<kernel>\[%s\]"fmt, \_\_FUNCTI ON\_\_, \#\#args)

12 \#endif

14 struct work\_struct xiaobai\_work; //定义work结构体

16 void xiaobai\_func(struct work\_struct \*work)

17 \{

18 printk("hello xiaobai!\\n");

19 \}

21 irqreturn\_t irq\_handler(int irqno, void \*dev\_id) //中断处理函数

22 \{

23 printk("key down\\n");

24 schedule\_work(&xiaobai\_work); //调度任务

25 return IRQ\_HANDLED;

26 \}

27 static int \_\_init test\_init(void) //模块初始化函数

28 \{

29 int ret;

31 /\*work\*/

32 INIT\_WORK(&xiaobai\_work, xiaobai\_func); //初始化worl结构体

34 ret = request\_irq(IRQ\_EINT1, irq\_handler,

35 IRQF\_TRIGGER\_FALLING, "key INT\_EINT1", NULL);

36 if(ret)\{

37 P\_DEBUG("request irq failed!\\n");

38 return ret;

39 \}

41 printk("hello irq\\n");

42 return 0;

43 \}

45 static void \_\_exit test\_exit(void) //模块卸载函数

46 \{

47 free\_irq(IRQ\_EINT1, NULL);

48 printk("good bye irq\\n");

49 \}

51 module\_init(test\_init);

52 module\_exit(test\_exit);

54 MODULE\_LICENSE("GPL");

55 MODULE\_AUTHOR("xoao bai");

56 MODULE\_VERSION("v0.1");

再看一下实现效果，效果和之前的一样：

\[root: 3rd\]\# insmod test.ko

hello irq

\[root: 3rd\]\# key down

hello xiaobai!

key down

hello xiaobai!

\[root: 3rd\]\# rmmod test

good bye irq

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

三、工作队列的实现

在介绍工作队列的实现之前，必须要介绍什么是工作者线程和三个数据结构。

工作者线程，是指负责执行在内核队列中任务的内核线程。在工作队列中，有专门的工作者线程来处理加入到工作对列中的任务。工作对列对应的工作者线程可能不止一个，每个处理器有且仅有一个工作队列对应的工作者线程。当然，如果内核中两个工作对列，那每个处理器就分别有两个工作者线程。

在内核中有一个默认的工作队列events，对于单处理器的ARM9，有一个对应的工作者线程。

工作队列结构体workqueue\_struct：

59 struct workqueue\_struct \{

60 struct cpu\_workqueue\_struct \*cpu\_wq; //一个工作者线程对应一个该结构体

61 struct list\_head list;

62 const char \*name;

63 int singlethread;

64 int freezeable; /\* Freeze threads during suspend \*/

65 int rt;

66 \#ifdef CONFIG\_LOCKDEP

67 struct lockdep\_map lockdep\_map;

68 \#endif

69 \};

工作对列workqueue\_struct有一个成员cpu\_workqueue\_struct，每个工作者线程对应一个cpu\_workqueue。所以，对于单处理器的ARM9，一个工作对列只有一个cpu\_workqueue\_struct。

结构体cpu\_workqueue\_struct：

41 struct cpu\_workqueue\_struct \{

43 spinlock\_t lock;

44 /\*这是内核链表，所有分配在这个处理器的work\_struct将通过链表连在一起，等待执行\*/

45 struct list\_head worklist;

46 wait\_queue\_head\_t more\_work;

47 struct work\_struct \*current\_work; //指向当前执行的work\_struct

49 struct workqueue\_struct \*wq; //指向关联自己的工作队列

50 struct task\_struct \*thread; //指向对应的内核线程，即工作者线程

52 int run\_depth; /\* Detect run\_workqueue() recursion depth \*/

53 \} \_\_\_\_cacheline\_aligned;

由上面知道，当我们调用queue\_work来调度任务时，并不是把work\_struct添加到等待队列中，而是会被分配到工作对列的成员cpu\_workqueue\_struct中。

work结构体work\_struct：

25 struct work\_struct \{

26 atomic\_long\_t data;

27 \#define WORK\_STRUCT\_PENDING 0 /\* T if work item pending execution \*/

28 \#define WORK\_STRUCT\_FLAG\_MASK (3UL)

29 \#define WORK\_STRUCT\_WQ\_DATA\_MASK (~WORK\_STRUCT\_FLAG\_MASK)

30 struct list\_head entry; //cpu\_workqueue\_struct通过这个成员，将wrok\_struct连在一起

31 work\_func\_t func; //每个任务的处理函数

32 \#ifdef CONFIG\_LOCKDEP

33 struct lockdep\_map lockdep\_map;

34 \#endif

35 \};

可能上面讲得很乱，下面将来个图来讲解一下，双处理器的情况下：

[![25014876_1295872994sst2.png][]][25014876_1295872994sst2.png][![25014876_12958730122EEd.png][]][25014876_12958730122EEd.png][![25014876_1295873020TCaZ.png][]][25014876_1295873020TCaZ.png]

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

四、选择哪个来实现下半部

在2.6内核，提供三种实现中断下半部的方法，软中断、tasklet和工作队列，其中tasklet是基于软中断实现的，两者很相近。而工作队列完全不同，它是靠内核线程实现的。

简单来说，软中断和tasklet优先级较高，性能较好，调度快，但不能睡眠。而工作队列是内核的进程调度，相对来说较慢，但能睡眠。所以，如果你的下半部需要睡眠，那只能选择动作队列。否则最好用tasklet。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

五、总结

这节简单介绍了工作队列的使用和实现。其中，还有函数能够使指定工作队列的任务延时执行，相关的结构体和函数有：

struct delayed\_work

DECLARE\_DELAYED\_WORK(n,f)

INIT\_DELAYED\_WORK(struct delayed\_work \*work, void (\*function)(void \*));

int queue\_delayed\_work(struct workqueue\_struct \*queue, struct delayed\_work \*work, unsigned long delay);

schedule\_delayed\_work(struct delayed\_work \*work, unsigned long delay)

有兴趣自己看看，很简单。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

[25014876_1295872994sst2.png]: http://blog168.chinaunix.net/attachment/201101/24/25014876_1295872994sst2.png
[25014876_12958730122EEd.png]: http://blog168.chinaunix.net/attachment/201101/24/25014876_12958730122EEd.png
[25014876_1295873020TCaZ.png]: http://blog168.chinaunix.net/attachment/201101/24/25014876_1295873020TCaZ.png