函数 INIT_WORK() / schedule_work()

1. 初始化工作队列INIT_WORK();

2. 调度工作队列 schedule_work();

转自http://blog.csdn.net/xiaopohaibebo/article/details/45648089

工作队列一般用来做滞后的工作，比如在中断里面要做很多事，但是比较耗时，这时就可以把耗时的工作放到工作队列。说白了就是系统延时调度的一个自定义函数。

1、定义struct work_struct irq_queue;

2、初始化INIT_WORK(&irq_queue,do_irq_queuework);

3、调用方法：schedule_work(&rq_queue);

注，调用完毕后系统会释放此函数，所以如果想再次执行的话，就再次调用schedule_work()即可。

另外，内核必须挂载文件系统才可以使用工作队列。我的理解是：工作队列也属于调度，如果内核挂了，他就不调度了，当然就不能用工作队列了。

Linux2.6内核使用了不少工作队列来处理任务，他在使用上和 tasklet最大的不同是工作队列的函数可以使用休眠，而tasklet的函数是不允许使用休眠的。

　　工作队列的使用又分两种情况，一种是利用系统共享的工作队列来添加自己的工作，这种情况处理函数不能消耗太多时间，这样会影响共享队列中其他任务的处理;另外一种是创建自己的工作队列并添加工作。

　　(一)利用系统共享的工作队列添加工作：

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

　　void my_func();

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

　　DECLARE_WORK(my_work,my_func,&data); //编译时创建名为my_work的结构体变量并把函数入口地址和参数地址赋给它;

　　如果不想要在编译时就用DECLARE_WORK()创建并初始化工作结构体变量，也可以在程序运行时再用INIT_WORK()创建

　　struct work_struct my_work; //创建一个名为my_work的结构体变量，创建后才能使用INIT_WORK()

　　INIT_WORK(&my_work,my_func,&data); //初始化已经创建的my_work，其实就是往这个结构体变量中添加处理函数的入口地址和data的地址，通常在驱动的open函数中完成

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

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

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

　　(二)创建自己的工作队列来添加工作

　　第一步：声明工作处理函数和一个指向工作队列的指针

　　void my_func();

　　struct workqueue_struct *p_queue;

　　第二步：创建自己的工作队列和工作结构体变量(通常在open函数中完成)

　　p_queue=create_workqueue("my_queue"); //创建一个名为my_queue的工作队列并把工作队列的入口地址赋给声明的指针

　　struct work_struct my_work;

　　INIT_WORK(&my_work, my_func, &data); //创建一个工作结构体变量并初始化，和第一种情况的方法一样

　　第三步：将工作添加入自己创建的工作队列等待执行

　　queue_work(p_queue, &my_work);

　　//作用与schedule_work()类似，不同的是将工作添加入p_queue指针指向的工作队列而不是系统共享的工作队列

　　第四步：删除自己的工作队列

　　destroy_workqueue(p_queue); //一般是在close函数中删除

内核中，有关函数的定义说明如下，

1. INIT_WORK()

#define INIT_WORK(_work, _func)						\
	do {								\
		__INIT_WORK((_work), (_func), 0);			\
	} while (0)

/*
 * initialize all of a work item in one go
 *
 * NOTE! No point in using "atomic_long_set()": using a direct
 * assignment of the work data initializer allows the compiler
 * to generate better code.
 */
#ifdef CONFIG_LOCKDEP
#define __INIT_WORK(_work, _func, _onstack)				\
	do {								\
		static struct lock_class_key __key;			\
									\
		__init_work((_work), _onstack);				\
		(_work)->data = (atomic_long_t) WORK_DATA_INIT();	\
		lockdep_init_map(&(_work)->lockdep_map, #_work, &__key, 0); \
		INIT_LIST_HEAD(&(_work)->entry);			\
		PREPARE_WORK((_work), (_func));				\
	} while (0)
#else
#define __INIT_WORK(_work, _func, _onstack)				\
	do {								\
		__init_work((_work), _onstack);				\
		(_work)->data = (atomic_long_t) WORK_DATA_INIT();	\
		INIT_LIST_HEAD(&(_work)->entry);			\
		PREPARE_WORK((_work), (_func));				\
	} while (0)
#endif

void __init_work(struct work_struct *work, int onstack)
{
	if (onstack)
		debug_object_init_on_stack(work, &work_debug_descr);
	else
		debug_object_init(work, &work_debug_descr);
}

2. schedule_work()

/**
 * schedule_work - put work task in global workqueue
 * @work: job to be done
 *
 * Returns %false if @work was already on the kernel-global workqueue and
 * %true otherwise.
 *
 * This puts a job in the kernel-global workqueue if it was not already
 * queued and leaves it in the same position on the kernel-global
 * workqueue otherwise.
 */
static inline bool schedule_work(struct work_struct *work)
{
	return queue_work(system_wq, work);
}