Waitqueue in Linux

最新推荐文章于 2024-07-16 22:46:11 发布
最新推荐文章于 2024-07-16 22:46:11 发布
阅读量196 收藏 1
点赞数
分类专栏： linux-kernel-4.19 linux-驱动基础 文章标签： linux 内核
原文链接：https://embetronicx.com/tutorials/linux/device-drivers/waitqueue-in-linux-device-driver-tutorial/
版权

本文是Linux设备驱动程序系列的续篇，并对字符驱动程序及其实现进行了讨论。这是Linux设备驱动程序教程的第10部分。现在，我们将讨论Linux中的Waitqueue。

Waitqueue in Linux

Linux中的等待队列

介绍

当您编写Linux驱动程序，模块或内核程序时，某些进程应为某些事件等待或休眠。在Linux中有几种处理睡眠和唤醒的方法，每种方法都适合不同的需求。 Waitqueue也是处理这种情况的方法之一。

每当进程必须等待事件（例如数据到达或进程终止）时，它就应该进入睡眠状态。睡眠会导致进程挂起执行，将处理器释放出来以用于其他用途。一段时间后，该过程将被唤醒，并在我们等待的事件到达时继续其工作。
Waitqueue中有3个重要步骤。

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

初始化等待队列

将此头文件用于Waitqueue(#include /linux/wait.h）。有两种初始化等待队列的方法。

  1. 静态方法
  2. 动态方法
    您可以使用任何一种方法。

静态方法

DECLARE_WAIT_QUEUE_HEAD(wq);

其中“ wq”是将使任务进入休眠状态的队列的名称。

动态方法

wait_queue_head_t wq;
init_waitqueue_head(&wq);

您可以使用上述任何一种方法来创建等待队列。

排队

一旦声明并初始化了等待队列，进程便可以使用它进入睡眠状态。有几个宏可用于不同用途。我们将一一看到。

wait_event
wait_event_timeout
wait_event_cmd
wait_event_interruptible
wait_event_interruptible_timeout
wait_event_killable

旧的内核版本使用函数sleep_on（）和interruptible_sleep_on（），但是这两个函数会引入不良的竞争条件，因此不应使用。

每当我们使用上面的宏之一时，它将把该任务添加到由我们创建的等待队列中。然后它将等待事件。

wait_event

休眠直到条件成真。
wait_event(wq, condition);
wq:等待的等待队列
condition:等待事件的C表达式
进程进入睡眠状态（TASK_UNINTERRUPTIBLE），直到条件评估为true。每次唤醒等待队列wq时都会检查条件。

wait_event_timeout

休眠直到条件成真或者超时。
wait_event_timeout(wq, condition, timeout);
wq:等待的等待队列
condition:等待事件的C表达式
timeout – 超时, 单位jiffies
进程进入睡眠状态（TASK_UNINTERRUPTIBLE），直到条件评估为true或者超时。每次唤醒等待队列wq时都会检查条件。
如果在超时后将条件评估为假，则返回0;如果在超时后将条件评估为真，则返回1;如果在超时之前将条件评估为真，则返回剩余的jiffies（至少1）。

wait_event_cmd

休眠直到条件成真。
wait_event_cmd(wq, condition, cmd1, cmd2);
wq:等待的等待队列
condition:等待事件的C表达式
cmd1:该命令将在睡眠前执行
cmd2:该命令将在睡眠后执行
进程进入睡眠状态（TASK_UNINTERRUPTIBLE），直到条件评估为true。每次唤醒等待队列wq时都会检查条件。

wait_event_interruptible

休眠直到条件成真。
wait_event_interruptible(wq, condition);
wq:等待的等待队列
condition:等待事件的C表达式
cmd1:该命令将在睡眠前执行
cmd2:该命令将在睡眠后执行
进程进入睡眠状态（TASK_UNINTERRUPTIBLE），直到条件评估为true。每次唤醒等待队列wq时都会检查条件。
如果该函数被信号中断，则该函数将返回-ERESTARTSYS；如果条件被评估为true，则该函数将返回0。

wait_event_interruptible_timeout

休眠直到条件成真或者超时。
wait_event_timeout(wq, condition, timeout);
wq:等待的等待队列
condition:等待事件的C表达式
timeout – 超时, 单位jiffies
进程进入睡眠状态（TASK_INTERRUPTIBLE），直到条件评估为true或收到信号或超时超时。每次唤醒等待队列wq时都会检查条件。
返回：
如果在超时后将条件评估为false，则返回0;
如果在超时后将条件评估为true，则返回1;
如果在超时之前将条件评估为true，则返回剩余的抖动（至少1），或者返回-ERESTARTSYS它被信号打断了。

wait_event_killable

休眠直到条件成真
wait_event_killable(wq, condition);
wq:等待的等待队列
condition:等待事件的C表达式
该过程进入睡眠状态（TASK_KILLABLE），直到条件评估为true或收到信号为止。每次唤醒等待队列wq时都会检查条件。
如果该函数被信号中断，则该函数将返回-ERESTARTSYS；如果条件被评估为true，则该函数将返回0。

唤醒等待的任务

当某些任务由于等待队列而进入睡眠模式时，我们可以使用以下功能唤醒这些任务。

wake_up
wake_up_all
wake_up_interruptible
wake_up_sync and wake_up_interruptible_sync

wake_up

从处于不间断睡眠的等待队列中仅唤醒一个进程。
wake_up(&wq);
wq:唤醒的等待队列

wake_up_all

唤醒等待队列中的所有进程
wake_up_all(&wq);
wq:唤醒的等待队列

wake_up_interruptible

从处于中断睡眠状态的等待队列中仅唤醒一个进程
wake_up_interruptible(&wq);
wq:唤醒的等待队列

wake_up_sync and wake_up_interruptible_sync

wake_up_sync(&wq);
wake_up_interruptible_sync(&wq);

通常，wake_up调用会导致立即重新安排，这意味着其他进程可能在wake_up返回之前运行。相反，“同步”变体使所有唤醒的进程都可运行，但不会重新调度CPU。这用于避免在已知当前进程即将进入睡眠状态时进行重新计划，从而仍然强制重新计划。请注意，唤醒的进程可以立即在其他处理器上运行，因此不应期望这些功能提供相互排斥。

WaitQueue in Linux

首先，我将向您解释驱动程序代码的概念。
在此源代码中，我们在两个地方发送了一个wake_up。一个来自读取功能，另一个来自驱动程序退出功能。
我创建了一个具有while（1）的线程（wait_function）。该线程将始终等待事件。它将一直休眠，直到得到一个wake_up调用。当它获得了wake_up调用时，它将检查条件。如果条件为1，则唤醒来自读取功能。如果为2，则唤醒来自退出功能。如果wake_up来自读取函数，它将打印读取计数并再次等待。如果来自退出函数，它将从线程退出。
在这里，我添加了两个版本的代码。

  1. 静态方法创建的等待队列
  2. 通过动态方法创建的等待队列

通过静态方法创建的等待队列

github

/***************************************************************************//**
*  \file       driver.c
*
*  \details    Simple linux driver (Waitqueue Static method)
*
*  \author     EmbeTronicX
*
* *******************************************************************************/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/slab.h>                 //kmalloc()
#include <linux/uaccess.h>              //copy_to/from_user()
#include <linux/kthread.h>
#include <linux/wait.h>                 // Required for the wait queues
 
 
uint32_t read_count = 0;
static struct task_struct *wait_thread;
 
DECLARE_WAIT_QUEUE_HEAD(wait_queue_etx);
 
dev_t dev = 0;
static struct class *dev_class;
static struct cdev etx_cdev;
int wait_queue_flag = 0;
 
/*
** Function Prototypes
*/
static int      __init etx_driver_init(void);
static void     __exit etx_driver_exit(void);
 
/*************** Driver Fuctions **********************/
static int      etx_open(struct inode *inode, struct file *file);
static int      etx_release(struct inode *inode, struct file *file);
static ssize_t  etx_read(struct file *filp, char __user *buf, size_t len,loff_t * off);
static ssize_t  etx_write(struct file *filp, const char *buf, size_t len, loff_t * off);
 
/*
** File operation sturcture
*/
static struct file_operations fops =
{
        .owner          = THIS_MODULE,
        .read           = etx_read,
        .write          = etx_write,
        .open           = etx_open,
        .release        = etx_release,
};
 
/*
** Thread function
*/
static int wait_function(void *unused)
{
        
        while(1) {
                printk(KERN_INFO "Waiting For Event...\n");
                wait_event_interruptible(wait_queue_etx, wait_queue_flag != 0 );
                if(wait_queue_flag == 2) {
                        printk(KERN_INFO "Event Came From Exit Function\n");
                        return 0;
                }
                printk(KERN_INFO "Event Came From Read Function - %d\n", ++read_count);
                wait_queue_flag = 0;
        }
        do_exit(0);
        return 0;
}
 
/*
** This fuction will be called when we open the Device file
*/
static int etx_open(struct inode *inode, struct file *file)
{
        printk(KERN_INFO "Device File Opened...!!!\n");
        return 0;
}
 
/*
** This fuction will be called when we close the Device file
*/
static int etx_release(struct inode *inode, struct file *file)
{
        printk(KERN_INFO "Device File Closed...!!!\n");
        return 0;
}
 
/*
** This fuction will be called when we read the Device file
*/
static ssize_t etx_read(struct file *filp, char __user *buf, size_t len, loff_t *off)
{
        printk(KERN_INFO "Read Function\n");
        wait_queue_flag = 1;
        wake_up_interruptible(&wait_queue_etx);
        return 0;
}
 
/*
** This fuction will be called when we write the Device file
*/
static ssize_t etx_write(struct file *filp, const char __user *buf, size_t len, loff_t *off)
{
        printk(KERN_INFO "Write function\n");
        return 0;
}
 
/*
** Module Init function
*/
static int __init etx_driver_init(void)
{
        /*Allocating Major number*/
        if((alloc_chrdev_region(&dev, 0, 1, "etx_Dev")) <0){
                printk(KERN_INFO "Cannot allocate major number\n");
                return -1;
        }
        printk(KERN_INFO "Major = %d Minor = %d \n",MAJOR(dev), MINOR(dev));
 
        /*Creating cdev structure*/
        cdev_init(&etx_cdev,&fops);
        etx_cdev.owner = THIS_MODULE;
        etx_cdev.ops = &fops;
 
        /*Adding character device to the system*/
        if((cdev_add(&etx_cdev,dev,1)) < 0){
            printk(KERN_INFO "Cannot add the device to the system\n");
            goto r_class;
        }
 
        /*Creating struct class*/
        if((dev_class = class_create(THIS_MODULE,"etx_class")) == NULL){
            printk(KERN_INFO "Cannot create the struct class\n");
            goto r_class;
        }
 
        /*Creating device*/
        if((device_create(dev_class,NULL,dev,NULL,"etx_device")) == NULL){
            printk(KERN_INFO "Cannot create the Device 1\n");
            goto r_device;
        }
        
        //Initialize wait queue
        init_waitqueue_head(&wait_queue_etx);
 
        //Create the kernel thread with name 'mythread'
        wait_thread = kthread_create(wait_function, NULL, "WaitThread");
        if (wait_thread) {
                printk("Thread Created successfully\n");
                wake_up_process(wait_thread);
        } else
                printk(KERN_INFO "Thread creation failed\n");
 
        printk(KERN_INFO "Device Driver Insert...Done!!!\n");
        return 0;
 
r_device:
        class_destroy(dev_class);
r_class:
        unregister_chrdev_region(dev,1);
        return -1;
}
 
/*
** Module exit function
*/ 
static void __exit etx_driver_exit(void)
{
        wait_queue_flag = 2;
        wake_up_interruptible(&wait_queue_etx);
        device_destroy(dev_class,dev);
        class_destroy(dev_class);
        cdev_del(&etx_cdev);
        unregister_chrdev_region(dev, 1);
        printk(KERN_INFO "Device Driver Remove...Done!!!\n");
}
 
module_init(etx_driver_init);
module_exit(etx_driver_exit);
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("EmbeTronicX <embetronicx@gmail.com>");
MODULE_DESCRIPTION("Simple linux driver (Waitqueue Static method)");
MODULE_VERSION("1.7");

通过动态方法创建等待队列

GitHub

/****************************************************************************//**
*  \file       driver.c
*
*  \details    Simple linux driver (Waitqueue Dynamic method)
*
*  \author     EmbeTronicX
*
* *******************************************************************************/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/slab.h>                 //kmalloc()
#include <linux/uaccess.h>              //copy_to/from_user()
#include <linux/kthread.h>
#include <linux/wait.h>                 // Required for the wait queues
 
 
uint32_t read_count = 0;
static struct task_struct *wait_thread;
 
dev_t dev = 0;
static struct class *dev_class;
static struct cdev etx_cdev;
wait_queue_head_t wait_queue_etx;
int wait_queue_flag = 0;
 
/*
** Function Prototypes
*/
static int      __init etx_driver_init(void);
static void     __exit etx_driver_exit(void);
 
/*************** Driver Fuctions **********************/
static int      etx_open(struct inode *inode, struct file *file);
static int      etx_release(struct inode *inode, struct file *file);
static ssize_t  etx_read(struct file *filp, char __user *buf, size_t len,loff_t * off);
static ssize_t  etx_write(struct file *filp, const char *buf, size_t len, loff_t * off);
 
/*
** File operation sturcture
*/
static struct file_operations fops =
{
        .owner          = THIS_MODULE,
        .read           = etx_read,
        .write          = etx_write,
        .open           = etx_open,
        .release        = etx_release,
};
 
/*
** Thread function
*/
static int wait_function(void *unused)
{
        
        while(1) {
                printk(KERN_INFO "Waiting For Event...\n");
                wait_event_interruptible(wait_queue_etx, wait_queue_flag != 0 );
                if(wait_queue_flag == 2) {
                        printk(KERN_INFO "Event Came From Exit Function\n");
                        return 0;
                }
                printk(KERN_INFO "Event Came From Read Function - %d\n", ++read_count);
                wait_queue_flag = 0;
        }
        return 0;
}
 
/*
** This fuction will be called when we open the Device file
*/ 
static int etx_open(struct inode *inode, struct file *file)
{
        printk(KERN_INFO "Device File Opened...!!!\n");
        return 0;
}
 
/*
** This fuction will be called when we close the Device file
*/
static int etx_release(struct inode *inode, struct file *file)
{
        printk(KERN_INFO "Device File Closed...!!!\n");
        return 0;
}
 
/*
** This fuction will be called when we read the Device file
*/
static ssize_t etx_read(struct file *filp, char __user *buf, size_t len, loff_t *off)
{
        printk(KERN_INFO "Read Function\n");
        wait_queue_flag = 1;
        wake_up_interruptible(&wait_queue_etx);
        return 0;
}
 
/*
** This fuction will be called when we write the Device file
*/
static ssize_t etx_write(struct file *filp, const char __user *buf, size_t len, loff_t *off)
{
        printk(KERN_INFO "Write function\n");
        return 0;
}
 
/*
** Module Init function
*/
static int __init etx_driver_init(void)
{
        /*Allocating Major number*/
        if((alloc_chrdev_region(&dev, 0, 1, "etx_Dev")) <0){
                printk(KERN_INFO "Cannot allocate major number\n");
                return -1;
        }
        printk(KERN_INFO "Major = %d Minor = %d \n",MAJOR(dev), MINOR(dev));
 
        /*Creating cdev structure*/
        cdev_init(&etx_cdev,&fops);
 
        /*Adding character device to the system*/
        if((cdev_add(&etx_cdev,dev,1)) < 0){
            printk(KERN_INFO "Cannot add the device to the system\n");
            goto r_class;
        }
 
        /*Creating struct class*/
        if((dev_class = class_create(THIS_MODULE,"etx_class")) == NULL){
            printk(KERN_INFO "Cannot create the struct class\n");
            goto r_class;
        }
 
        /*Creating device*/
        if((device_create(dev_class,NULL,dev,NULL,"etx_device")) == NULL){
            printk(KERN_INFO "Cannot create the Device 1\n");
            goto r_device;
        }
        
        //Initialize wait queue
        init_waitqueue_head(&wait_queue_etx);
 
        //Create the kernel thread with name 'mythread'
        wait_thread = kthread_create(wait_function, NULL, "WaitThread");
        if (wait_thread) {
                printk("Thread Created successfully\n");
                wake_up_process(wait_thread);
        } else
                printk(KERN_INFO "Thread creation failed\n");
 
        printk(KERN_INFO "Device Driver Insert...Done!!!\n");
        return 0;
 
r_device:
        class_destroy(dev_class);
r_class:
        unregister_chrdev_region(dev,1);
        return -1;
}
 
/*
** Module exit function
*/
static void __exit etx_driver_exit(void)
{
        wait_queue_flag = 2;
        wake_up_interruptible(&wait_queue_etx);
        device_destroy(dev_class,dev);
        class_destroy(dev_class);
        cdev_del(&etx_cdev);
        unregister_chrdev_region(dev, 1);
        printk(KERN_INFO "Device Driver Remove...Done!!!\n");
}
 
module_init(etx_driver_init);
module_exit(etx_driver_exit);
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("EmbeTronicX <embetronicx@gmail.com>");
MODULE_DESCRIPTION("Simple linux driver (Waitqueue Dynamic method)");
MODULE_VERSION("1.8");

MakeFile

obj-m += driver.o
KDIR = /lib/modules/$(shell uname -r)/build
all:
    make -C $(KDIR)  M=$(shell pwd) modules
clean:
    make -C $(KDIR)  M=$(shell pwd) clean

编译测试

make
insmod driver.ko
dmesg

因此该线程正在等待事件。现在我们将通过使用

sudo cat /dev/etx_device

读取驱动程序来发送事件
我们发送来自读取功能的唤醒，因此它将打印读取计数，然后再次进入睡眠状态。现在通过sudo rmmod驱动程序从退出函数发送事件
现在条件是2。​​因此它将从线程返回并删除驱动程序。
这就是等待队列。在下一个教程中，我们将讨论Linux设备驱动程序中的sysfs。

山羊哥-老宋
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Linux实现简单的队列
05-15
1. **队列数据结构**：队列是一种先进先出（FIFO，First In First Out）的数据结构。元素在队尾添加（入队），在队头删除（出队）。这与现实生活中的排队等候类似，先到的人先服务。 2. **阻塞与非阻塞队列**： - ...
linux 等待队列
03-27
通过调用`init_waitqueue_head()`函数初始化，之后其他进程可以通过`add_wait_queue()`加入此队列，或者通过`remove_wait_queue()`退出队列。 2. **等待队列项**：每个等待的进程都有一个对应的等待队列项，通常...
Linux线程编程之生产者消费者问题
12-14
Linux线程编程中的生产者消费者问题是多线程编程中一个经典的同步问题，它涉及到线程间的协作和资源的共享。生产者线程负责生成数据并放入队列，而消费者线程则从队列中取出数据进行处理。在这个过程中，如何保证...
Embeded linux中的MMC驱动.docx
11-08
使用`init_waitqueue_head()`初始化等待队列，用于在中断处理中等待事件。 20. **注册中断处理函数**： 通过`request_irq()`注册中断处理函数`usr_irq()`，该函数在设备中断时被调用，用于处理中断事件，如唤醒...
页面置换算法模拟和Linux进程实验
07-11
4. 进程通信：Linux提供了多种进程间通信（IPC）机制，如管道（pipe）、套接字（socket）、信号量（semaphore）、共享内存（shared memory）和消息队列（message queue）。在实验中，你将学习使用消息队列进行进程...
【持续集成_05课_Linux部署SonarQube及结合开发项目部署】
weixin_42333261的博客
07-12 316
前置条件：sonarQube不能使用root账号进行启动，所以需要创建普通用户及。3）CMD上传qube文件-不能传到home路径下哦。2）添加用户、组名、密码。4）检查并解压上传的包。
Linux C | 管道open打开方式
I_feige的博客
07-12 332
1.
LINUX:懒汉单例模式线程池
W2155的博客
07-16 313
创建一个线程，就是要这个线程去完成某种任务的。池化技术就是，提前创建一批线程，有任务这一批线程就会执行。而不是有任务的时候在去创建线程。池化技术有着更高的效率，因为线程都是提前创建好的，直接执行任务。
Linux中的文件夹作用
qq_36634055的博客
07-16 323
这里放的是系统管理员（超级用户）使用的特殊工具，就像是工具箱里的专业工具，比如ifconfig（网络配置）、fdisk（磁盘分区）等，普通用户一般用不到。：这个目录存放了一些基本的用户命令，就像是工具箱里常用的工具，比如ls（列出文件）、cp（复制文件）等，这些命令对于普通用户和系统管理员都是可用的。：这个目录存放了各种可变数据，包括日志文件、邮件队列、打印队列等，就像是家里放杂物的地方，随着时间的推移，里面的东西会不断变化。：这里放的是可选的软件包，就像是额外的娱乐设施，可以根据需要添加。
Linux 安装 Docker Compose
m0_63004677的博客
07-12 388
Linux 系统安装 Docker Compose
linux dev shm扩容
hello__bug的博客
07-14 244
ctrl + x 保存。
Linux --- 高级IO
V_zjs的博客
07-12 849
Linux --- 高级IO
【Linux】文件管理常用命令【超详细】
最新发布
2301_82023330的博客
07-16 451
这篇博客介绍了Linux系统中的常用文件管理命令，包括`ls`、`cd`、`cp`、`mv`、`rm`和`mkdir`等。通过这些命令，用户可以高效地浏览目录、复制和移动文件、删除文件以及创建新目录。文章详细讲解了每个命令的基本用法和常见选项，并通过实例演示了这些命令在实际操作中的应用，帮助读者掌握文件管理的基本技能，提升Linux系统的使用效率。
Linux笔记之shell终端命令后显示指定行数的grep和head
小勇博客
07-14 522
在Linux中，grep命令和head命令常用于文本处理。grep命令用于搜索文本中的特定模式，而head命令用于显示文件的开头部分。了解如何结合这两个命令（例如使用管道）可以帮助你更高效地处理和查看文本数据。grep -A选项用于在匹配到的行之后显示指定数量的行。例如，将显示匹配到的行及其后面的三行。选项用于显示文件的前n行。例如，将显示file.txt的前五行。
Linux 入门教程 by 程序员鱼皮
努力做最接地气的编程干货分享，感谢关注
07-11 807
对初学 Linux 的同学来说，一般不会部署特别大的项目，1 核 1 G 的服务器，无论是用来学习 Linux 命令，还是用来部署个人博客和小项目都已经足够了。后续如果需要用到更高的配置，再升级即可。
[Linux+git+Gitee+Jenkins]持续集成实验安装配置详细
wumingzei的博客
07-16 1033
在Linux基于docker搭建一个Jenkins项目环境，包括git，gitee，jdk，maven等的安装配置过程记录。
【Linux】centos7安装PHP7.4报错：libzip版本过低
m0_52985087的博客
07-12 375
原因：当前服务器libzip的版本小于0.11比较低，需要更新升级，而且libzip升级版本不能是1.3.1,1.7.0的。安装完成后，查看是否存在/usr/local/lib/pkgconfig目录,如果存在，验证是否卸载成功：rpm -qa|grep libzip，如无输出信息则卸载成功。也可以直接在download后直接拼接要下载的libzip的版本。注意：只是在当前的shell会话中设置了这个环境变量。验证libzip：whereis libzip。查看服务器上libzip的版本。
windows 中的 Nsight Systems 通过ssh 链接分析 Linux 中的cuda程序性能
eloudy的专栏
07-12 161
安装 ssh-server安装较新版本的 cuda sdk下载cuda-samples github repo编辑修改 ssh 配置：删除相关注释，修改后如下：Port 22。
termux 安装 rockylinux
欢迎来到别往的博客
07-13 355
往找最新的文件目录,选择ARM版本的image。或者直接查看目录或者国内阿里云镜像,按照cpu架构(安卓9手机一般是aarch64arm最新架构)，获取镜像地址，以及checksum里的SHA256信息更新到以下rocky9.sh脚本，如果不需要直接使用即可。
how to used wait_event_interruptible_timeout
05-26
`wait_event_interruptible_timeout` is a function in the Linux kernel that allows a process to sleep until a certain condition is met or a timeout expires. The function prototype is as follows: ``` ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值