linux工作队列--浅析

好帖子：https://blog.youkuaiyun.com/mr_enthusiasm/article/details/54912503

工作队列

 

为什么使用 workqueue?

 

在内核代码中, 经常希望延缓部分工作到将来某个时间执行, 这样做的原因很多, 比如

 

.在持有锁时做大量(或者说费时的)工作不合适.

.希望将工作聚集以获取批处理的性能.

.调用了一个可能导致睡眠的函数使得在此时执行新调度非常不合适.

...

内核中提供了许多机制来提供延迟执行, 使用最多则是 workqueue.

中断底半部机制有三种：1.工作队列 2.tasklet 3.软中断

注：软中断和tasklet运行于软中断上下文，仍然属于原子上下文的一种，而工作队列则运行于进程上下文，因此，软中断和taeklet处理函数中不能睡眠

而工作队列处理函数中允许睡眠。

 

本程序实现方法：

利用系统共享的工作队列，自己创建节点并添加到系统共享工作队列

过程：

        第一步：声明或编写一个工作处理函数

static void key_work(struct work_struct *work)

 

　      第二步：创建一个工作结构体变量，并将处理函数和参数的入口地址赋给这个工作结构体变量

 法二： static struct work_struct key_wk //创建一个名为key_wk的结构体变量，创建后才能使用INIT_WORK()                   

　　 INIT_WORK(&key_wk, key_work) //初始化已经创建的key_wk，其实就是往这个结构体变量中添加处理函数key_work的入口地址

 

　　    第三步：将工作结构体变量添加入系统的共享工作队列

schedule_work(&key_wk); //添加入队列的工作完成后会自动从队列中删除

　或schedule_delayed_work(&key_wk,tick); //延时tick个滴答后再提交工作

 

----------------------------------程序分析----------------------------------------------------------------------

#include <linux/module.h>

2 #include <linux/init.h>

3 #include <linux/major.h>

4 #include <linux/cdev.h>

5 #include <linux/device.h>

6 #include <linux/types.h>

7 #include <linux/fs.h>

8 #include <asm/uaccess.h>

9 #include <linux/io.h>

10 #include <linux/sched.h>

11 //#include <asm/irq.h>

12 #include <linux/gpio.h>

13 #include <linux/interrupt.h>

14 #include <linux/input.h>

15

16 #define TAG "keyvol"

17 #define INT_GPIO 91

18 #define MY_KEY_CODE KEY_A

19

20 static int irq;

21 static struct input_dev *kinput;

（2）22 static struct work_struct key_wk; //创建一个名为key_wk的结构体变量，创建后才能使用INIT_WORK()

23

24 volatile unsigned long *tlmm_gpio_cfg;

25 volatile unsigned long *tlmm_in_out;

26

27（1） static void key_work(struct work_struct *work) //声明或编写一个工作处理函数

28 {

29 int value;

30

31 printk(TAG"%s\n", __func__);

32 value = *tlmm_in_out;

33 value &= 0x1;

34 if (value) {

35 input_report_key(kinput, KEY_RIGHTSHIFT, 0);

36 input_report_key(kinput, MY_KEY_CODE, 0);

37 input_sync(kinput);

38 printk(TAG"key is release\n");

39 } else {

40 input_report_key(kinput, KEY_RIGHTSHIFT, 1);

41 input_report_key(kinput, MY_KEY_CODE, 1);

42 input_sync(kinput);

43 printk(TAG"key is press\n");

44 }

45 }

46

47 static irqreturn_t key_irq_thread(int irq, void *data) //中断处理

48 {

49 printk(TAG"%s\n", __func__);

（ 3） schedule_work(&key_wk); ////添加入队列的工作完成后会自动从队列中删除

51

52 return IRQ_HANDLED;

3 }

54

55 static int my_key_init(void)

56 {

57 int retval;

58

59 printk(TAG" func:%s line%d\n", __func__, __LINE__);

60 kinput = input_allocate_device();

61 if (!kinput)

62 return -ENOMEM;

63 kinput->name = "keyt";

64 __set_bit(EV_KEY, kinput->evbit);

65 __set_bit(MY_KEY_CODE, kinput->keybit);

66 __set_bit(KEY_RIGHTSHIFT, kinput->keybit);

67

68 retval = input_register_device(kinput);

69 if(retval)

70 goto input_register_error;

71

72 tlmm_gpio_cfg = (volatile unsigned long *)ioremap(0x105B000, 8);

73 tlmm_in_out = tlmm_gpio_cfg + 1;

74 *tlmm_gpio_cfg |= 0x3;

75

76 irq = gpio_to_irq(INT_GPIO);

77 printk(TAG"%s irq is %d\n", __func__, irq);

78 retval = request_threaded_irq(irq, NULL, key_irq_thread, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING |IRQF_ONESHOT, "vol_k ey", NULL);

79 printk(TAG"%s ret is %d\n", __func__, retval);

80

81 （2） INIT_WORK(&key_wk, key_work); // //初始化已经创建的key_Wk，其实就是往这个结构体变量中添加处理函数的入口地址key_work和data的地址，或INIT_DELAYED_WORK（）这里没有data

82

83 return 0;

84

85 input_register_error:

86 input_free_device(kinput);

87 return retval;

88 }

89

90 static void key_exit(void)

91 {

92 printk(TAG" func:%s line%d\n", __func__, __LINE__);

93 iounmap(tlmm_gpio_cfg);

94 free_irq(irq, NULL);

95 input_unregister_device(kinput);

96 printk(TAG" func:%s line%d\n", __func__, __LINE__);

97 }

98

99 module_init(my_key_init);

100 module_exit(key_exit);

101 MODULE_LICENSE("GPL");