简介

Linux中断的下半部分有四种处理方式。

  • 工作队列
  • Threaded IRQ
  • Softirq
  • Tasklet

这一片文章我们讲述工作队列的使用

linux中的工作队列

Work queues在linux 2.6版本加入的。工作队列是推迟工作的另一种形式。工作队列将工作推迟到内核线程中。下半部分始终在流程上下文中运行。因为工作队列允许用户创建内核线程并将工作绑定到内核线程。
在内核中有两种方式实现Workqueue。

  • 使用全局的工作队列
  • 创建自己的工作队列

全局工作队列的使用

工作队列的初始化

可以分为静态和动态两种方式。

  1. # 静态
  2. DECLARE_WORK(workqueuename,workqueue_fn);
  3. # 动态

对应的API

  1. int schedule_work( struct work_struct *work );
  2. int scheduled_delayed_work( struct delayed_work *dwork, unsigned long delay );
  3. int schedule_work_on( int cpu, struct work_struct *work );
  4. int scheduled_delayed_work_on(
  5.            int cpu, struct delayed_work *dwork, unsigned long delay );
  7. # 删除队列
  8. int flush_work( struct work_struct *work );
  9. void flush_scheduled_work( void );
  11. # 取消工作
  12. int cancel_work_sync( struct work_struct *work );
  13. int cancel_delayed_work_sync( struct delayed_work *dwork );
  15. # 检查工作
  16. work_pending( work );
  17. delayed_work_pending( work );

代码

静态使用

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/delay.h>
  4. #include <linux/workqueue.h>
  6. // struct workqueue_struct *workqueue_test;
  8. // struct work_struct work_test;
  10. void work_test_func(struct work_struct *work) { printk("now this static workqueue has run\n"); }
  12. /*Creating work by Static Method */
  13. DECLARE_WORK(workqueue,work_test_func);
  15. static int test_init(void) {
  16.   schedule_work(&workqueue);
  18.   return 0;
  19. }
  21. static void test_exit(void) {
  22.   printk("Goodbye,cruel world!\n");
  23.   // destroy_workqueue(workqueue_test);
  24. }
  26. module_init(test_init);
  27. module_exit(test_exit);
  29. MODULE_LICENSE("GPL");
  30. MODULE_AUTHOR("zhouchengzhu <1073355312@qq.com>");
  31. MODULE_DESCRIPTION("A simple  workqueue driver");
  32. MODULE_VERSION("2:1.0");

动态使用

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/delay.h>
  4. #include <linux/workqueue.h>
  6. /* Work structure */
  7. static struct work_struct workqueue;
  9. void work_test_func(struct work_struct *work) { printk("now this Dynamic workqueue has run\n"); }
  10. static int test_init(void) {
  11.   /*Creating work by Dynamic Method */
  12.   INIT_WORK(&workqueue,work_test_func);
  13.   schedule_work(&workqueue);
  15.   return 0;
  16. }
  18. static void test_exit(void) {
  19.   printk("Goodbye,cruel world!\n");
  20. }
  22. module_init(test_init);
  23. module_exit(test_exit);
  25. MODULE_LICENSE("GPL");
  26. MODULE_AUTHOR("zhouchengzhu <1073355312@qq.com>");
  27. MODULE_DESCRIPTION("A simple  workqueue driver");
  28. MODULE_VERSION("2:1.0");

创建自己的WorkQueue & 传递参数

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/delay.h>
  4. #include <linux/workqueue.h>
  6. struct workqueue_struct *workqueue_test;
  8. struct Mywork_struct
  9. {
  10.   struct work_struct work_test;
  11.   char *str;
  12.   int Id;
  13. };
  15. struct Mywork_struct Mywork_struct[2];
  16. static char teststr[] = "test for demo work";
  17. void work_test_func(struct work_struct *work)
  18. {
  19.   struct Mywork_struct *PMyWork = container_of(work, struct Mywork_struct, work_test);
  20.   printk("Id == %d,%s\n", PMyWork->Id, PMyWork->str);
  21. }
  23. static int test_init(void)
  24. {
  25.   int i = 0x00;
  26.   printk("Hello,world!\n");
  28.   /* 1. 自己创建一个workqueue， 中间参数为0，默认配置 */
  29.   /* 或者也可以 create_workqueue 
  30.     workqueue_test = create_workqueue("workqueue_test");*/
  31.   workqueue_test = alloc_workqueue("workqueue_test", 0, 0);
  32.   /*Creating workqueue */
  34.   for (i = 0x0; i < sizeof(Mywork_struct) / sizeof(Mywork_struct[0]); i++)
  35.   {
  36.     /* 2. 初始化工作项，并添加自己实现的函数 */
  37.     INIT_WORK(&Mywork_struct[i].work_test, work_test_func);
  38.     Mywork_struct[i].Id = i;
  39.     Mywork_struct[i].str = teststr;
  40.   }
  42.   /* 3. 将自己的工作项添加到指定的工作队列去， 同时唤醒相应线程处理 */
  43.   for (i = 0x0; i < sizeof(Mywork_struct) / sizeof(Mywork_struct[0]); i++)
  44.   {
  45.     queue_work(workqueue_test, &Mywork_struct[i].work_test);
  46.   }
  48.   return 0;
  49. }
  51. static void test_exit(void)
  52. {
  53.   printk("Goodbye,cruel world!\n");
  54.   destroy_workqueue(workqueue_test);
  55. }
  57. module_init(test_init);
  58. module_exit(test_exit);
  60. MODULE_LICENSE("GPL");
  61. MODULE_AUTHOR("zhouchengzhu <1073355312@qq.com>");
  62. MODULE_DESCRIPTION("A simple  workqueue driver");
  63. MODULE_VERSION("2:1.0");

参考资料