Linux workqueue工做原理【转】

时间 2019-11-24

原文原文链接

转自：http://blog.chinaunix.net/uid-21977330-id-3754719.htmlcss

转自：http://bgutech.blog.163.com/blog/static/18261124320116181119889/
1. 什么是workqueue
Linux中的Workqueue机制就是为了简化内核线程的建立。经过调用workqueue的接口就能建立内核线程。而且能够根据当前系统CPU的个数建立线程的数量，使得线程处理的事务可以并行化。workqueue是内核中实现简单而有效的机制，他显然简化了内核daemon的建立，方便了用户的编程.html

工做队列（workqueue）是另一种将工做推后执行的形式.工做队列能够把工做推后，交由一个内核线程去执行，也就是说，这个下半部分能够在进程上下文中执行。最重要的就是工做队列容许被从新调度甚至是睡眠。
那么，什么状况下使用工做队列，什么状况下使用tasklet。若是推后执行的任务须要睡眠，那么就选择工做队列。若是推后执行的任务不须要睡眠，那么就选择tasklet。另外，若是须要用一个能够从新调度的实体来执行你的下半部处理，也应该使用工做队列。它是惟一能在进程上下文运行的下半部实现的机制，也只有它才能够睡眠。这意味着在须要得到大量的内存时、在须要获取信号量时，在须要执行阻塞式的I/O操做时，它都会很是有用。若是不须要用一个内核线程来推后执行工做，那么就考虑使用tasklet。编程

2. 数据结构
咱们把推后执行的任务叫作工做（work），描述它的数据结构为work_struct:数据结构

struct work_struct {
    atomic_long_t data;       /*工做处理函数func的参数*/
#define WORK_STRUCT_PENDING 0        /* T if work item pending execution */
#define WORK_STRUCT_STATIC 1        /* static initializer (debugobjects) */
#define WORK_STRUCT_FLAG_MASK (3UL)
#define WORK_STRUCT_WQ_DATA_MASK (~WORK_STRUCT_FLAG_MASK)
    struct list_head entry;        /*链接工做的指针*/
    work_func_t func;              /*工做处理函数*/
#ifdef CONFIG_LOCKDEP
    struct lockdep_map lockdep_map;
#endif
};

这些工做以队列结构组织成工做队列（workqueue），其数据结构为workqueue_struct:多线程

struct workqueue_struct {
 struct cpu_workqueue_struct *cpu_wq;
 struct list_head list;
 const char *name;   /*workqueue name*/
 int singlethread;   /*是否是单线程 - 单线程咱们首选第一个CPU -0表示采用默认的工做者线程event*/
 int freezeable;  /* Freeze threads during suspend */
 int rt;
};

若是是多线程，Linux根据当前系统CPU的个数建立cpu_workqueue_struct 其结构体就是:函数

truct cpu_workqueue_struct {
 spinlock_t lock;/*由于工做者线程须要频繁的处理链接到其上的工做，因此须要枷锁保护*/
 struct list_head worklist;
 wait_queue_head_t more_work;
 struct work_struct *current_work; /*当前的work*/
 struct workqueue_struct *wq;   /*所属的workqueue*/
 struct task_struct *thread; /*任务的上下文*/
} ____cacheline_aligned;

在该结构主要维护了一个任务队列，以及内核线程须要睡眠的等待队列，另外还维护了一个任务上下文，即task_struct。
三者之间的关系以下：ui

3. 建立工做
3.1 建立工做queue
a. create_singlethread_workqueue(name)
该函数的实现机制以下图所示，函数返回一个类型为struct workqueue_struct的指针变量，该指针变量所指向的内存地址在函数内部调用kzalloc动态生成。因此driver在再也不使用该work queue的状况下调用:atom

void destroy_workqueue(struct workqueue_struct *wq)来释放此处的内存地址。.net

图中的cwq是一per-CPU类型的地址空间。对于create_singlethread_workqueue而言，即便是对于多CPU系统，内核也只负责建立一个worker_thread内核进程。该内核进程被建立以后，会先定义一个图中的wait节点，而后在一循环体中检查cwq中的 worklist，若是该队列为空，那么就会把wait节点加入到cwq中的more_work中，而后休眠在该等待队列中。线程

Driver调用queue_work（struct workqueue_struct *wq, struct work_struct *work）向wq中加入工做节点。work会依次加在cwq->worklist所指向的链表中。queue_work向 cwq->worklist中加入一个work节点，同时会调用wake_up来唤醒休眠在cwq->more_work上的 worker_thread进程。wake_up会先调用wait节点上的autoremove_wake_function函数，而后将wait节点从 cwq->more_work中移走。

worker_thread再次被调度，开始处理cwq->worklist中的全部work节点...当全部work节点处理完毕，worker_thread从新将wait节点加入到cwq->more_work，而后再次休眠在该等待队列中直到Driver调用 queue_work...

b. create_workqueue

相对于create_singlethread_workqueue, create_workqueue一样会分配一个wq的工做队列，可是不一样之处在于，对于多CPU系统而言，对每个CPU，都会为之建立一个per- CPU的cwq结构，对应每个cwq，都会生成一个新的worker_thread进程。可是当用queue_work向cwq上提交work节点时，是哪一个CPU调用该函数，那么便向该CPU对应的cwq上的worklist上增长work节点。

c.小结
当用户调用workqueue的初始化接口create_workqueue或者create_singlethread_workqueue对 workqueue队列进行初始化时，内核就开始为用户分配一个workqueue对象，而且将其链到一个全局的workqueue队列中。而后 Linux根据当前CPU的状况，为workqueue对象分配与CPU个数相同的cpu_workqueue_struct对象，每一个 cpu_workqueue_struct对象都会存在一条任务队列。紧接着，Linux为每一个cpu_workqueue_struct对象分配一个内核thread，即内核daemon去处理每一个队列中的任务。至此，用户调用初始化接口将workqueue初始化完毕，返回workqueue的指针。

workqueue初始化完毕以后，将任务运行的上下文环境构建起来了，可是具体尚未可执行的任务，因此，须要定义具体的work_struct对象。而后将work_struct加入到任务队列中，Linux会唤醒daemon去处理任务。

上述描述的workqueue内核实现原理能够描述以下：

3.2 建立工做
       要使用工做队列，首先要作的是建立一些须要推后完成的工做。能够经过DECLARE_WORK在编译时静态地建该结构：
       DECLARE_WORK(name,void (*func) (void *), void *data);
      这样就会静态地建立一个名为name，待执行函数为func，参数为data的work_struct结构。
      一样，也能够在运行时经过指针建立一个工做：
      INIT_WORK(structwork_struct *work, woid(*func) (void *), void *data);

4. 调度
a. schedule_work

在大多数状况下, 并不须要本身创建工做队列，而是只定义工做, 将工做结构挂接到内核预约义的事件工做队列中调度, 在kernel/workqueue.c中定义了一个静态全局量的工做队列static struct workqueue_struct *keventd_wq;默认的工做者线程叫作events/n，这里n是处理器的编号，每一个处理器对应一个线程。好比，单处理器的系统只有events /0这样一个线程。而双处理器的系统就会多一个events/1线程。
调度工做结构, 将工做结构添加到全局的事件工做队列keventd_wq，调用了queue_work通用模块。对外屏蔽了keventd_wq的接口，用户无需知道此参数，至关于使用了默认参数。keventd_wq由内核本身维护，建立，销毁。这样work立刻就会被调度，一旦其所在的处理器上的工做者线程被唤醒，它就会被执行。

b. schedule_delayed_work(&work,delay);
有时候并不但愿工做立刻就被执行，而是但愿它通过一段延迟之后再执行。在这种状况下，同时也能够利用timer来进行延时调度，到期后才由默认的定时器回调函数进行工做注册。延迟delay后，被定时器唤醒，将work添加到工做队列wq中。

工做队列是没有优先级的，基本按照FIFO的方式进行处理。

5. work queue API

1. create_workqueue用于建立一个workqueue队列，为系统中的每一个CPU都建立一个内核线程。输入参数：

@name：workqueue的名称

2. create_singlethread_workqueue用于建立workqueue，只建立一个内核线程。输入参数：

@name：workqueue名称

3. destroy_workqueue释放workqueue队列。输入参数：

@ workqueue_struct：须要释放的workqueue队列指针

4. schedule_work调度执行一个具体的任务，执行的任务将会被挂入Linux系统提供的workqueue——keventd_wq输入参数：

@ work_struct：具体任务对象指针

5. schedule_delayed_work延迟必定时间去执行一个具体的任务，功能与schedule_work相似，多了一个延迟时间，输入参数：

@work_struct：具体任务对象指针

@delay：延迟时间

6. queue_work调度执行一个指定workqueue中的任务。输入参数：

@ workqueue_struct：指定的workqueue指针

@work_struct：具体任务对象指针

7. queue_delayed_work延迟调度执行一个指定workqueue中的任务，功能与queue_work相似，输入参数多了一个delay。

6. 示例

//声明
static struct workqueue_struct *mdp_pipe_ctrl_wq; /* mdp mdp pipe ctrl wq */
static struct delayed_work mdp_pipe_ctrl_worker;
mdp_pipe_ctrl_wq = create_singlethread_workqueue("mdp_pipe_ctrl_wq");//建立工做队列
INIT_DELAYED_WORK(&mdp_pipe_ctrl_worker,mdp_pipe_ctrl_workqueue_handler);//delayed_work与task_func绑定。
//处理函数
static void mdp_pipe_ctrl_workqueue_handler(struct work_struct *work)
{
mdp_pipe_ctrl(MDP_MASTER_BLOCK, MDP_BLOCK_POWER_OFF, FALSE);
}
//开始调用工做队列，delay时间到了就执行处理函数。
unsigned long mdp_timer_duration = (HZ/20); /* 50 msecond */
/* send workqueue to turn off mdp power */
queue_delayed_work(mdp_pipe_ctrl_wq,&mdp_pipe_ctrl_worker, mdp_timer_duration);
/* cancel pipe ctrl worker */
cancel_delayed_work(&mdp_pipe_ctrl_worker);
/* for workder can't be cancelled... */
flush_workqueue(mdp_pipe_ctrl_wq);
/* for workder can't be cancelled... */
flush_workqueue(mdp_pipe_ctrl_wq);

在driver 程序中许多不少状况须要设置延后执行的，这样工做队列就很好帮助咱们实现。

Linux workqueue工做原理 【转】

Linux workqueue工做原理【转】