简介

当您编写Linux驱动程序，模块或内核程序时，某些进程应等待或休眠某些事件。在Linux中，有几种处理睡眠和唤醒的方法，每种方法都适合不同的需求。Waitqueue也是处理这种情况的方法之一。
每当进程必须等待事件（例如数据到达或进程终止）时，它就应该进入睡眠状态。睡眠会导致进程挂起执行，从而释放处理器以供其他用途。一段时间后，该过程将被唤醒，并在我们等待的事件到达时继续其工作。
等待队列是内核提供的用于实现等待的机制。顾名思义，waitqueue是等待事件的进程列表。换句话说，当特定条件为真时，使用等待队列来等待有人将您唤醒。必须小心使用它们，以确保没有比赛状况。

使用步骤

  1. 初始化等待队列
  2. 排队（使任务进入睡眠状态，直到事件发生）
  3. 唤醒排队的任务

    初始化方法

  • 静态方法
  • 动态方法 ```c

    静态

    DECLARE_WAIT_QUEUE_HEAD(wq);

动态

wait_queue_head_t wq; init_waitqueue_head (&wq);

  1. <a name="e7tIz"></a>
  2. ### 睡眠API
  3. ```c
  4. wait_event(wq_head, condition)
  5. wait_event_timeout(wq, condition, timeout);
  6. wait_event_cmd(wq, condition, cmd1, cmd2);
  7. wait_event_interruptible(wq, condition);
  8. wait_event_interruptible_timeout(wq, condition, timeout);
  9. wait_event_killable(wq, condition);

唤醒ＡＰＩ

  1. wake_up(&wq)
  2. wake_up_all(&wq);
  3. wake_up_interruptible(&wq);
  4. wake_up_sync(&wq);
  5. wake_up_interruptible_sync(&wq);

静态方法创建

  1. #include <linux/kernel.h>
  2. #include <linux/init.h>
  3. #include <linux/module.h>
  4. #include <linux/kdev_t.h>
  5. #include <linux/fs.h>
  6. #include <linux/cdev.h>
  7. #include <linux/device.h>
  8. #include <linux/slab.h>    //kmalloc()
  9. #include <linux/uaccess.h> //copy_to/from_user()
  11. #include <linux/kthread.h>
  12. #include <linux/wait.h> // Required for the wait queues
  14.     uint32_t read_count = 0;
  15. static struct task_struct *wait_thread;
  17. DECLARE_WAIT_QUEUE_HEAD(wait_queue_etx);
  19. dev_t dev = 0;
  20. static struct class *dev_class;
  21. static struct cdev etx_cdev;
  22. int wait_queue_flag = 0;
  24. static int __init etx_driver_init(void);
  25. static void __exit etx_driver_exit(void);
  27. /*************** Driver Fuctions **********************/
  28. static int etx_open(struct inode *inode, struct file *file);
  29. static int etx_release(struct inode *inode, struct file *file);
  30. static ssize_t etx_read(struct file *filp, char __user *buf, size_t len, loff_t *off);
  31. static ssize_t etx_write(struct file *filp, const char *buf, size_t len, loff_t *off);
  33. static struct file_operations fops =
  34.     {
  35.         .owner = THIS_MODULE,
  36.         .read = etx_read,
  37.         .write = etx_write,
  38.         .open = etx_open,
  39.         .release = etx_release,
  40. };
  42. static int wait_function(void *unused)
  43. {
  45.   while (1)
  46.   {
  47.     printk(KERN_INFO "Waiting For Event...\n");
  48.     wait_event_interruptible(wait_queue_etx, wait_queue_flag != 0);
  49.     if (wait_queue_flag == 2)
  50.     {
  51.       printk(KERN_INFO "Event Came From Exit Function\n");
  52.       return 0;
  53.     }
  54.     printk(KERN_INFO "Event Came From Read Function - %d\n", ++read_count);
  55.     wait_queue_flag = 0;
  56.   }
  57.   do_exit(0);
  58.   return 0;
  59. }
  61. static int etx_open(struct inode *inode, struct file *file)
  62. {
  63.   printk(KERN_INFO "Device File Opened...!!!\n");
  64.   return 0;
  65. }
  67. static int etx_release(struct inode *inode, struct file *file)
  68. {
  69.   printk(KERN_INFO "Device File Closed...!!!\n");
  70.   return 0;
  71. }
  73. static ssize_t etx_read(struct file *filp, char __user *buf, size_t len, loff_t *off)
  74. {
  75.   printk(KERN_INFO "Read Function\n");
  76.   wait_queue_flag = 1;
  77.   wake_up_interruptible(&wait_queue_etx);
  78.   return 0;
  79. }
  80. static ssize_t etx_write(struct file *filp, const char __user *buf, size_t len, loff_t *off)
  81. {
  82.   printk(KERN_INFO "Write function\n");
  83.   return 0;
  84. }
  86. static int __init etx_driver_init(void)
  87. {
  88.   /*Allocating Major number*/
  89.   if ((alloc_chrdev_region(&dev, 0, 1, "etx_Dev")) < 0)
  90.   {
  91.     printk(KERN_INFO "Cannot allocate major number\n");
  92.     return -1;
  93.   }
  94.   printk(KERN_INFO "Major = %d Minor = %d \n", MAJOR(dev), MINOR(dev));
  96.   /*Creating cdev structure*/
  97.   cdev_init(&etx_cdev, &fops);
  98.   etx_cdev.owner = THIS_MODULE;
  99.   etx_cdev.ops = &fops;
  101.   /*Adding character device to the system*/
  102.   if ((cdev_add(&etx_cdev, dev, 1)) < 0)
  103.   {
  104.     printk(KERN_INFO "Cannot add the device to the system\n");
  105.     goto r_class;
  106.   }
  108.   /*Creating struct class*/
  109.   if ((dev_class = class_create(THIS_MODULE, "etx_class")) == NULL)
  110.   {
  111.     printk(KERN_INFO "Cannot create the struct class\n");
  112.     goto r_class;
  113.   }
  115.   /*Creating device*/
  116.   if ((device_create(dev_class, NULL, dev, NULL, "etx_device")) == NULL)
  117.   {
  118.     printk(KERN_INFO "Cannot create the Device 1\n");
  119.     goto r_device;
  120.   }
  122.   //Initialize wait queue
  123.   init_waitqueue_head(&wait_queue_etx);
  125.   //Create the kernel thread with name 'mythread'
  126.   wait_thread = kthread_create(wait_function, NULL, "WaitThread");
  127.   if (wait_thread)
  128.   {
  129.     printk("Thread Created successfully\n");
  130.     wake_up_process(wait_thread);
  131.   }
  132.   else
  133.     printk(KERN_INFO "Thread creation failed\n");
  135.   printk(KERN_INFO "Device Driver Insert...Done!!!\n");
  136.   return 0;
  138. r_device:
  139.   class_destroy(dev_class);
  140. r_class:
  141.   unregister_chrdev_region(dev, 1);
  142.   return -1;
  143. }
  145. void __exit etx_driver_exit(void)
  146. {
  147.   wait_queue_flag = 2;
  148.   wake_up_interruptible(&wait_queue_etx);
  149.   device_destroy(dev_class, dev);
  150.   class_destroy(dev_class);
  151.   cdev_del(&etx_cdev);
  152.   unregister_chrdev_region(dev, 1);
  153.   printk(KERN_INFO "Device Driver Remove...Done!!!\n");
  154. }
  156. module_init(etx_driver_init);
  157. module_exit(etx_driver_exit);
  159. MODULE_LICENSE("GPL");
  160. MODULE_AUTHOR("zhouchengzhu <1073355312@qq.com>");
  161. MODULE_DESCRIPTION("A Sample Static Waitqueue Demo");
  162. MODULE_VERSION("2:1.0");

动态创建

  1. #include <linux/kernel.h>
  2. #include <linux/init.h>
  3. #include <linux/module.h>
  4. #include <linux/kdev_t.h>
  5. #include <linux/fs.h>
  6. #include <linux/cdev.h>
  7. #include <linux/device.h>
  8. #include <linux/slab.h>    //kmalloc()
  9. #include <linux/uaccess.h> //copy_to/from_user()
  10. #include <linux/kthread.h>
  11. #include <linux/wait.h> // Required for the wait queues
  13.     uint32_t read_count = 0;
  14. static struct task_struct *wait_thread;
  16. dev_t dev = 0;
  17. static struct class *dev_class;
  18. static struct cdev etx_cdev;
  19. wait_queue_head_t wait_queue_etx;
  20. int wait_queue_flag = 0;
  22. static int __init etx_driver_init(void);
  23. static void __exit etx_driver_exit(void);
  25. /*************** Driver Fuctions **********************/
  26. static int etx_open(struct inode *inode, struct file *file);
  27. static int etx_release(struct inode *inode, struct file *file);
  28. static ssize_t etx_read(struct file *filp, char __user *buf, size_t len, loff_t *off);
  29. static ssize_t etx_write(struct file *filp, const char *buf, size_t len, loff_t *off);
  31. static struct file_operations fops =
  32.     {
  33.         .owner = THIS_MODULE,
  34.         .read = etx_read,
  35.         .write = etx_write,
  36.         .open = etx_open,
  37.         .release = etx_release,
  38. };
  40. static int wait_function(void *unused)
  41. {
  43.   while (1)
  44.   {
  45.     printk(KERN_INFO "Waiting For Event...\n");
  46.     wait_event_interruptible(wait_queue_etx, wait_queue_flag != 0);
  47.     if (wait_queue_flag == 2)
  48.     {
  49.       printk(KERN_INFO "Event Came From Exit Function\n");
  50.       return 0;
  51.     }
  52.     printk(KERN_INFO "Event Came From Read Function - %d\n", ++read_count);
  53.     wait_queue_flag = 0;
  54.   }
  55.   return 0;
  56. }
  58. static int etx_open(struct inode *inode, struct file *file)
  59. {
  60.   printk(KERN_INFO "Device File Opened...!!!\n");
  61.   return 0;
  62. }
  64. static int etx_release(struct inode *inode, struct file *file)
  65. {
  66.   printk(KERN_INFO "Device File Closed...!!!\n");
  67.   return 0;
  68. }
  70. static ssize_t etx_read(struct file *filp, char __user *buf, size_t len, loff_t *off)
  71. {
  72.   printk(KERN_INFO "Read Function\n");
  73.   wait_queue_flag = 1;
  74.   wake_up_interruptible(&wait_queue_etx);
  75.   return 0;
  76. }
  77. static ssize_t etx_write(struct file *filp, const char __user *buf, size_t len, loff_t *off)
  78. {
  79.   printk(KERN_INFO "Write function\n");
  80.   return 0;
  81. }
  83. static int __init etx_driver_init(void)
  84. {
  85.   /*Allocating Major number*/
  86.   if ((alloc_chrdev_region(&dev, 0, 1, "etx_Dev")) < 0)
  87.   {
  88.     printk(KERN_INFO "Cannot allocate major number\n");
  89.     return -1;
  90.   }
  91.   printk(KERN_INFO "Major = %d Minor = %d \n", MAJOR(dev), MINOR(dev));
  93.   /*Creating cdev structure*/
  94.   cdev_init(&etx_cdev, &fops);
  96.   /*Adding character device to the system*/
  97.   if ((cdev_add(&etx_cdev, dev, 1)) < 0)
  98.   {
  99.     printk(KERN_INFO "Cannot add the device to the system\n");
  100.     goto r_class;
  101.   }
  103.   /*Creating struct class*/
  104.   if ((dev_class = class_create(THIS_MODULE, "etx_class")) == NULL)
  105.   {
  106.     printk(KERN_INFO "Cannot create the struct class\n");
  107.     goto r_class;
  108.   }
  110.   /*Creating device*/
  111.   if ((device_create(dev_class, NULL, dev, NULL, "etx_device")) == NULL)
  112.   {
  113.     printk(KERN_INFO "Cannot create the Device 1\n");
  114.     goto r_device;
  115.   }
  117.   //Initialize wait queue
  118.   init_waitqueue_head(&wait_queue_etx);
  120.   //Create the kernel thread with name 'mythread'
  121.   wait_thread = kthread_create(wait_function, NULL, "WaitThread");
  122.   if (wait_thread)
  123.   {
  124.     printk("Thread Created successfully\n");
  125.     wake_up_process(wait_thread);
  126.   }
  127.   else
  128.     printk(KERN_INFO "Thread creation failed\n");
  130.   printk(KERN_INFO "Device Driver Insert...Done!!!\n");
  131.   return 0;
  133. r_device:
  134.   class_destroy(dev_class);
  135. r_class:
  136.   unregister_chrdev_region(dev, 1);
  137.   return -1;
  138. }
  140. void __exit etx_driver_exit(void)
  141. {
  142.   wait_queue_flag = 2;
  143.   wake_up_interruptible(&wait_queue_etx);
  144.   device_destroy(dev_class, dev);
  145.   class_destroy(dev_class);
  146.   cdev_del(&etx_cdev);
  147.   unregister_chrdev_region(dev, 1);
  148.   printk(KERN_INFO "Device Driver Remove...Done!!!\n");
  149. }
  151. module_init(etx_driver_init);
  152. module_exit(etx_driver_exit);
  154. MODULE_LICENSE("GPL");
  155. MODULE_AUTHOR("zhouchengzhu <1073355312@qq.com>");
  156. MODULE_DESCRIPTION("A Sample Dynamic Waitqueue Demo");
  157. MODULE_VERSION("2:1.0");

参考资料