162 工作队列实验

一、tasklet机制

软中断环境下执行
不允许休眠、不允许进程调度
不能调用sleep，但是可以调用mdelay，因为sleep会引起进程调度

二、工作队列机制

进程上下文环境执行
允许休眠、允许进程调度、不影响实时性

类似于 kthread_worker
把中断下半部要处理的函数放在内核线程里面执行。

三、创建工作队列

kernel已经默认为我们创建了 一个工作队列，通常不需要我们调用这些api创建工作队列，使用kernel创建的工作队列即可。
下面这两个宏返回的都是：struct workqueue_struct *

1、alloc_workqueue() 宏

include/linux/workqueue.h

#define alloc_workqueue(fmt, flags, max_active, args...)		\
	__alloc_workqueue_key((fmt), (flags), (max_active),		\
			      NULL, NULL, ##args)

2、create_singlethread_workqueue(const char *name) 宏

这个宏最终调用的还是 alloc_workqueue

四、使用工作队列

1、work_struct结构体

表示一个具体的工作
include/linux/workqueue.h

struct work_struct {
	// 具体工作处理函数的参数
	atomic_long_t data;
	// 工作队列中的具体工作通过此成员串联成一个链表
	struct list_head entry;
	// 函数指针成员，具体的工作处理函数
	// typedef void (*work_func_t)(struct work_struct *work);
	work_func_t func;
#ifdef CONFIG_LOCKDEP
	struct lockdep_map lockdep_map;
#endif
};

1、entry 我们不去过问，这个和以前的版本完全相同。
2、data 类型是 atomic_long_t，这个类型从字面上看可以知道是一个原子类型。第一次看到这个变量时，很容易误认为和以前的data是同样的用法，只不过类型变了而已，其实不然，这里的 data 是之前版本的 pending 和 wq_data 的复合体，起到了以前的 pending 和 wq_data 的作用。
3、func 的参数是一个work_struct指针，指向的数据就是定义func的work_struct。

看到这里，会有两个疑问：
第一，如何把用户的数据作为参数传递给 func 呢？以前有 void *data 来作为参数，现在好像完全没有办法做到；
第二，如何实现延迟工作？目前版本的 work_struct 并没有定义 timer。

解决 第一个问题 ，需要换一种思路。2.6.20版本之后使用工作队列需要把work_struct定义在用户的数据结构中，然后通过container_of来得到用户数据。具体用法可以参考稍后的实作。

对于 第二个问题，定义了一个新的结构 delayed_work 用于处理延迟执行：

struct delayed_work {undefined

    struct work_struct work;

    struct timer_list timer;

};

2、工作队列和工作者线程

1、工作队列 workqueue_struct 结构体

表示一个工作队列。
workqueue.h

2、工作者线程：worker 结构体

每个worker结构体中都有一个工作队列成员，工作者线程处理自己工作队列中的所有工作。

但在实际开发中，我们只需要定义具体工作（work_struct）即可，工作队列和工作者线程已经由系统初始化好，我们直接通过api使用即可。

3、INIT_WORK 宏

include/linux/workqueue.h
初始化具体工作，即初始化struct work_struct中的各个成员。
将 自己写的具体的工作函数 绑定 `work_struct 结构体。

#define INIT_WORK(_work, _func)						\
	__INIT_WORK((_work), (_func), 0)

• _work：具体工作，即struct work_struct，注意是结构体指针
• _func：工作处理函数，void func(struct work_struct *)

4、schedule_work()函数

include/linux/workqueue.h
将具体的工作加入到内核创建的工作队列中，并让工作队列开始工作

static inline bool schedule_work(struct work_struct *work)

五、例程

1、驱动源文件

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <asm/mach/map.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/io.h>
#include <linux/device.h>
#include <linux/irq.h>
#include <linux/of_irq.h>


/*------------------字符设备内容----------------------*/
#define DEV_NAME "button"
#define DEV_CNT (1)

static dev_t button_devno;		 //定义字符设备的设备号
static struct cdev button_chr_dev; //定义字符设备结构体chr_dev
struct class *class_button;		 //保存创建的类
struct device *device_button;		 // 保存创建的设备


struct device_node	*button_device_node = NULL;  //定义按键设备节点结构体
unsigned  button_GPIO_number = 0;  //保存button使用的GPIO引脚编号
u32  interrupt_number = 0;         // button 引脚中断编号
atomic_t   button_status = ATOMIC_INIT(0);  //定义整型原子变量，保存按键状态 ，设置初始值为0
struct work_struct button_work;

void work_hander(struct work_struct *work)
{

	printk(KERN_EMERG "work_hander is running!\r\n");

}

static irqreturn_t button_irq_hander(int irq, void *dev_id)
{
	// printk_green("button on \n");
	/*按键状态加一*/
	printk(KERN_EMERG "button_irq_hander is running!");
	atomic_inc(&button_status);
	schedule_work(&button_work);
	printk(KERN_EMERG "button_irq_hander is end!");
	return IRQ_HANDLED;
}

static int button_open(struct inode *inode, struct file *filp)
{
	int error = -1;
	
	
	/*添加初始化代码*/
	// printk_green("button_open");

	/*获取按键 设备树节点*/
	button_device_node = of_find_node_by_path("/button_interrupt");
	if(NULL == button_device_node)
	{
		printk("of_find_node_by_path error!");
		return -1;
	}

	/*获取按键使用的GPIO*/
	button_GPIO_number = of_get_named_gpio(button_device_node ,"button_gpio", 0);
	if(0 == button_GPIO_number)
	{
		printk("of_get_named_gpio error");
		return -1;
	}

	/*申请GPIO  , 记得释放*/
	error = gpio_request(button_GPIO_number, "button_gpio");
	if(error < 0)
	{
		printk("gpio_request error");
		gpio_free(button_GPIO_number);
		return -1;
	}

	error = gpio_direction_input(button_GPIO_number);//设置引脚为输入模式

	/*获取中断号*/
	interrupt_number = irq_of_parse_and_map(button_device_node, 0);
	printk("\n irq_of_parse_and_map! =  %d \n",interrupt_number);


	/*申请中断, 记得释放*/
	error = request_irq(interrupt_number,button_irq_hander,IRQF_TRIGGER_RISING,"button_interrupt",device_button);
	if(error != 0)
	{
		printk("request_irq error");
		free_irq(interrupt_number, device_button);
		return -1;
	}

	INIT_WORK(&button_work,work_hander);

	/*申请之后已经开启了，切记不要再次打开，否则运行时报错*/
	// // enable_irq(interrupt_number);

	return 0;

}

static int button_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	int error = -1;
	int button_countervc = 0;

	/*读取按键状态值*/
	button_countervc = atomic_read(&button_status);

	/*结果拷贝到用户空间*/
	error = copy_to_user(buf, &button_countervc, sizeof(button_countervc));
	if(error < 0)
	{
		printk("copy_to_user error");
		return -1;
	}

	/*清零按键状态值*/
	atomic_set(&button_status,0);
	return 0;
}

/*字符设备操作函数集，.release函数实现*/
static int button_release(struct inode *inode, struct file *filp)
{
	/*释放申请的引脚,和中断*/
	gpio_free(button_GPIO_number);
	free_irq(interrupt_number, device_button);
	return 0;
}



/*字符设备操作函数集*/
static struct file_operations button_chr_dev_fops = {
	.owner = THIS_MODULE,
	.open = button_open,
	.read = button_read,
	.release = button_release};

/*
*驱动初始化函数
*/
static int __init button_driver_init(void)
{
	int error = -1;

	/*采用动态分配的方式，获取设备编号，次设备号为0，*/
	error = alloc_chrdev_region(&button_devno, 0, DEV_CNT, DEV_NAME);
	if (error < 0)
	{
		printk("fail to alloc button_devno\n");
		goto alloc_err;
	}

	/*关联字符设备结构体cdev与文件操作结构体file_operations*/
	button_chr_dev.owner = THIS_MODULE;
	cdev_init(&button_chr_dev, &button_chr_dev_fops);

	/*添加设备至cdev_map散列表中*/ 
	error = cdev_add(&button_chr_dev, button_devno, DEV_CNT);
	if (error < 0) 
	{
		printk("fail to add cdev\n");
		goto add_err;
	}

	class_button = class_create(THIS_MODULE, DEV_NAME);                         //创建类
	device_button = device_create(class_button, NULL, button_devno, NULL, DEV_NAME);//创建设备 DEV_NAME 指定设备名，


	return 0;

add_err:
	unregister_chrdev_region(button_devno, DEV_CNT);    // 添加设备失败时，需要注销设备号
	printk("\n error! \n");
	
alloc_err:
	return -1;
}



/*
*驱动注销函数
*/
static void __exit button_driver_exit(void)
{
	pr_info("button_driver_exit\n");
	/*删除设备*/

	device_destroy(class_button, button_devno);		   //清除设备
	class_destroy(class_button);					   //清除类
	cdev_del(&button_chr_dev);					       //清除设备号
	unregister_chrdev_region(button_devno, DEV_CNT);   //取消注册字符设备
}



module_init(button_driver_init);
module_exit(button_driver_exit);

MODULE_LICENSE("GPL");

2、测试app源文件

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
    int error = -20;
    int button_status = 0;

    /*打开文件*/
    int fd = open("/dev/button", O_RDWR);
    if (fd < 0)
    {
        printf("open file : /dev/button error!\n");
        return -1;
    }

    printf("wait button down... \n");
    printf("wait button down... \n");

    do
    {
        /*读取按键状态*/
        error = read(fd, &button_status, sizeof(button_status));
        if (error < 0)
        {
            printf("read file error! \n");
        }
        usleep(1000 * 100); //延时100毫秒
    } while (0 == button_status);
    printf("button Down !\n");

    /*关闭文件*/
    error = close(fd);
    if (error < 0)
    {
        printf("close file error! \n");
    }
    return 0;
}

六、总结

工作队列的作用就是把工作交由一个内核线程去执行，可以指定内核线程立即执行，也可以指定延迟时间执行（static inline bool schedule_delayed_work(struct delayed_work *dwork, unsigned long delay)）。

	立即执行	延时执行
1、定义数据结构	struct work_struct	struct delayed_work（内嵌 struct work_struct）
2、自定义的具体工作函数	typedef void (*work_func_t)(struct work_struct *work);	typedef void (*work_func_t)(struct work_struct *work);
3、创建一个内核线程来接收上一步编写具体的工作函数，通常不用这一步，用内核创建好的默认线程即可。	alloc_workqueue或者create_singlethread_workqueue，返回值类型为：struct workqueue_struct *	alloc_workqueue或者create_singlethread_workqueue，返回值类型为：struct workqueue_struct *
4、初始化第1步中的数据结构，具体的工作函数、工作函数的参数都保存在各自的结构体中	INIT_WORK(struct work_struct *work, work_func_t func);	INIT_DELAYED_WORK(struct delayed_work*, work_func_t func)
5、将任务提交给工作队列	若是自创了一个内核线程：queue_work(struct workqueue_struct *wq, struct work_struct *work); 若是使用默认的内核线程：schedule_work(struct work_struct*)	若是自创了一个内核线程：queue_work(struct workqueue_struct *wq, struct work_struct *work); 若是使用默认的内核线程：static inline bool schedule_delayed_work(struct delayed_work *dwork, unsigned long delay)
6、释放第3步创建的内核线程相关资源，若果你创了的话	void destory_workqueue(struct workqueue_struct *wq);	void destory_workqueue(struct workqueue_struct *wq);