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結構體

16

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

2 #include

3

4 #include

5 #include

6

7 #define DEBUG_SWITCH 1

8 #if DEBUG_SWITCH

9 #define P_DEBUG(fmt, args...) printk("<1>" "[%s]"fmt, __FUNCTI ON__, ##args)

10 #else

11 #define P_DEBUG(fmt, args...) printk("<7>" "[%s]"fmt, __FUNCTI ON__, ##args)

12 #endif

13

14 struct workqueue_struct *xiaobai_wq; //1.定義工作佇列

15 struct work_struct xiaobai_work; //2定義work結構體

16

17 void xiaobai_func(struct work_struct *work) //2實現處理函式

18 {

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

20 }

21

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;

31

32 /*work*/

33 xiaobai_wq = create_workqueue("xiaobai"); //1初始化工作對列

34 INIT_WORK(&xiaobai_work, xiaobai_func); //2初始化work結構體

35

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 }

42

43 printk("hello irq\n");

44 return 0;

45 }

46

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 }

54

55 module_init(test_init);

56 module_exit(test_exit);

57

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

二、使用共享的工作佇列

在核心中有一個預設的工作佇列events，使用共享的工作佇列可以省去建立和登出工作佇列的步驟。當然，佇列是共享的，用起來當然會不爽，如果有多個不同的任務都加入到這個工作對列中，每個任務排程的速度就會比較慢，肯定不如自己建立一個爽。不過，一般預設工作佇列都能滿足要求，不需要建立一個新的。

少了上面建立和登出等待佇列兩步，使用共享工作佇列步驟相對少一點

步驟一、實現處理函式，定義並初始化work結構體：

這一步驟上一節介紹的步驟二完全一樣，所以就不說了。

步驟二、排程任務：

預設工作佇列的中任務的排程不需要指定工作對列，所以函式有所不同：

/*kernel/workqueue.c*/

620 int schedule_work(struct work_struct *work)

該函式會把work_struct結構體加入到預設工作對列events中。

上函式：

/*6th_irq_3/3rd/test.c*/

1 #include

2 #include

3

4 #include

5 #include

6

7 #define DEBUG_SWITCH 1

8 #if DEBUG_SWITCH

9 #define P_DEBUG(fmt, args...) printk("<1>" "[%s]"fmt, __FUNCTI ON__, ##args)

10 #else

11 #define P_DEBUG(fmt, args...) printk("<7>" "[%s]"fmt, __FUNCTI ON__, ##args)

12 #endif

13

14 struct work_struct xiaobai_work; //定義work結構體

15

16 void xiaobai_func(struct work_struct *work)

17 {

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

19 }

20

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;

30

31 /*work*/

32 INIT_WORK(&xiaobai_work, xiaobai_func); //初始化worl結構體

33

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 }

40

41 printk("hello irq\n");

42 return 0;

43 }

44

45 static void __exit test_exit(void) //模組解除安裝函式

46 {

47 free_irq(IRQ_EINT1, NULL);

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

相關推薦