30.linux内核 阻塞/非阻塞IO

最新推荐文章于 2023-10-01 08:59:06 发布
最新推荐文章于 2023-10-01 08:59:06 发布
阅读量225 收藏 1
点赞数
分类专栏： # linux驱动 文章标签： linux内核 poll select epoll 阻塞io
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16054639/article/details/107558532
版权

当欲执行的条件不满足的时候，可以休眠进程等待，也可以返回不可操作标志。休眠等待就是阻塞IO模式，直接返回就是非阻塞IO模式。

阻塞IO

在驱动中休眠线程可以使用互斥锁(mutex)、信号量(smaphare)、完成量(complition)。这些都是基于等待队列实现的，很多时候需要直接使用等待队列进行更加复杂的调度操作。
最基本的等待队列的操作是：

  1. 判断条件是否需要休眠，休眠的话吧当前进程放入等待队列，休眠后被唤醒了继续检查条件，是否还需要休眠。对应的函数一般是（wait_event）
  2. 唤醒等待队列中的一个进程
    相关API在wait.h中
//定义等待队列
wait_queue_head_t wait_task;
//初始化等待队列
init_waitqueue_head(&wait_task);
//判断并休眠
wait_event(queue, condition) 								//非中断休眠。
wait_event_interruptible(queue, condition) 					//可以被信号中断，返回非零表示休眠被某个信号中断。
wait_event_timeout(queue, condition, timeout) 				//限时版本，超时返回0。
wait_event_interruptible_timeout(queue, condition, timeout) //限时版本，超时返回0。
//唤醒函数
void wake_up(wait_queue_head_t *queue); 				//唤醒等待在给定queue上的所有进程。
void wake_up_interruptible(wait_queue_head_t *queue); 	//只会唤醒那些执行可中断休眠的进程。

用等待队列简单实现一下字符设备的FIFO，使用wait_event_interruptible可以被ctrl+c打断

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <asm/uaccess.h>

MODULE_LICENSE("GPL");

static int data = 1;
module_param(data, int, 0644);  //声明模块参数
dev_t devid;
struct cdev char_dev;
struct class * char_class;
int buffer_size = 100;
char * char_data;
unsigned char has_data_flag;
static wait_queue_head_t wait_task;

static int open(struct inode * node, struct file * fl){
	return 0;
}

static long ioctl(struct file * fl, unsigned int cmd, unsigned long arg){
	return 0;
}

static ssize_t read(struct file * fl, char __user * buf, size_t len, loff_t * offset){
	int ret = 0,copy_len,data_len;
	wait_event_interruptible(wait_task,has_data_flag != 0);
	has_data_flag = 0;

	data_len = strlen(char_data)+1;
	if(fl->f_pos + len > data_len)
		copy_len = data_len - fl->f_pos; //超过长度，复制剩余部分
	else
		copy_len = len;					 //没超过

	ret = copy_to_user(buf,char_data+fl->f_pos,copy_len);
	ret = copy_len - ret;
	*offset += ret;						 //移动文件指针
	return ret;
}

static ssize_t write(struct file * fl, const char __user * buf, size_t len, loff_t * offset){
	int ret = 0,copy_len,data_len = buffer_size;

	if(fl->f_pos + len > data_len)
		copy_len = data_len - fl->f_pos; //超过长度，复制剩余部分
	else
		copy_len = len;					 //没超过

	ret = copy_from_user(char_data+fl->f_pos,buf,copy_len);
	ret = copy_len - ret;
	*offset += ret;						 //移动文件指针
	has_data_flag = 1;
	wake_up_interruptible(&wait_task);
	return ret;
}

struct file_operations my_opts = {
	.owner = THIS_MODULE,
	.open = open,
	.read = read,
	.write = write,
	.unlocked_ioctl = ioctl
};

static int __init char_init(void){
	int ret = 0;

    devid = MKDEV(241, 1);								//换算设备号
    ret = register_chrdev_region(devid, 1, "char_test");//注册设备，在/proc/drivers下面可以看到
    if (ret < 0)
        goto err0;

    cdev_init(&char_dev,&my_opts);						//绑定opt结构体
    char_dev.owner = THIS_MODULE;
    ret = cdev_add(&char_dev,devid,1);					//注册字符设备驱动
    if (ret < 0)
    	goto err1;

    char_class = class_create(THIS_MODULE,"char_test"); //在/sys/class中创建文件夹
    device_create(char_class,NULL,devid,NULL,"char_test_dev_%d",1);//在上一步文件夹中创建char_test_dev_1

    char_data = kzalloc(buffer_size,GFP_KERNEL);

    has_data_flag = 0;
    init_waitqueue_head(&wait_task);
	printk("char init\n");
    return 0;

	err1:
	    unregister_chrdev_region(devid, 1);
    err0:
        return ret;
}

static void __exit char_exit(void){
	kfree(char_data);
	unregister_chrdev_region(devid, 1);
	cdev_del(&char_dev);
	device_destroy(char_class,devid);
	class_destroy(char_class);
	printk("char exit\n");
}

module_init(char_init);
module_exit(char_exit);

大多是时候等待队列的使用并没有这么简单，配合上锁机制实现更加精细化的控制。精细化使用一般就不用wait_event函数了，而是自己实现wait_event，基本流程是：

  1. 吧当前进程控制块封装成等待队列对象。
  2. 吧等待对象加入等待队列。
  3. 判断条件，不满足的话改变自己的进程状态为休眠(设置状态不会立刻改变线程的行为)，调用schedule函数主动放弃CPU，让系统重新调度。
  4. 醒来判断是否是信号唤醒的，比如ctrl+c，可以就此返回
  5. 执行任务
  6. 移出等待队列
  7. 设置自己的状态为运行状态

看一下wait_event源码：

do {
	DEFINE_WAIT(__wait);

	for (;;) {
		prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);
		if (condition)
			break;
		schedule();
	}
	finish_wait(&wq, &__wait);
} while (0)

大致就是这个过程，例子不演示了。

非阻塞IO

非阻塞IO有两种实现，一种是在用户空间打开设备文件后设置是否需要阻塞访问。驱动中直接判断文件描述符的f_flags就可以了。设置了非阻塞访问就直接返回。

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <asm/uaccess.h>

MODULE_LICENSE("GPL");

static int data = 1;
module_param(data, int, 0644);  //声明模块参数
dev_t devid;
struct cdev char_dev;
struct class * char_class;
int buffer_size = 100;
char * char_data;
unsigned char has_data_flag;
static wait_queue_head_t wait_task;

static int open(struct inode * node, struct file * fl){
	return 0;
}

static long ioctl(struct file * fl, unsigned int cmd, unsigned long arg){
	return 0;
}

static ssize_t read(struct file * fl, char __user * buf, size_t len, loff_t * offset){
	int ret = 0,copy_len,data_len;

	if (fl->f_flags & O_NONBLOCK && has_data_flag == 0)
		return -EAGAIN;					//直接返回

	wait_event_interruptible(wait_task,has_data_flag != 0);
	has_data_flag = 0;

	data_len = strlen(char_data)+1;
	if(fl->f_pos + len > data_len)
		copy_len = data_len - fl->f_pos; //超过长度，复制剩余部分
	else
		copy_len = len;					 //没超过

	ret = copy_to_user(buf,char_data+fl->f_pos,copy_len);
	ret = copy_len - ret;
	*offset += ret;						 //移动文件指针
	return ret;
}

static ssize_t write(struct file * fl, const char __user * buf, size_t len, loff_t * offset){
	int ret = 0,copy_len,data_len = buffer_size;

	if(fl->f_pos + len > data_len)
		copy_len = data_len - fl->f_pos; //超过长度，复制剩余部分
	else
		copy_len = len;					 //没超过

	ret = copy_from_user(char_data+fl->f_pos,buf,copy_len);
	ret = copy_len - ret;
	*offset += ret;						 //移动文件指针
	has_data_flag = 1;
	wake_up_interruptible(&wait_task);
	return ret;
}

struct file_operations my_opts = {
	.owner = THIS_MODULE,
	.open = open,
	.read = read,
	.write = write,
	.unlocked_ioctl = ioctl
};

static int __init char_init(void){
	int ret = 0;

    devid = MKDEV(241, 1);								//换算设备号
    ret = register_chrdev_region(devid, 1, "char_test");//注册设备，在/proc/drivers下面可以看到
    if (ret < 0)
        goto err0;

    cdev_init(&char_dev,&my_opts);						//绑定opt结构体
    char_dev.owner = THIS_MODULE;
    ret = cdev_add(&char_dev,devid,1);					//注册字符设备驱动
    if (ret < 0)
    	goto err1;

    char_class = class_create(THIS_MODULE,"char_test"); //在/sys/class中创建文件夹
    device_create(char_class,NULL,devid,NULL,"char_test_dev_%d",1);//在上一步文件夹中创建char_test_dev_1

    char_data = kzalloc(buffer_size,GFP_KERNEL);

    has_data_flag = 0;
    init_waitqueue_head(&wait_task);
	printk("char init\n");
    return 0;

	err1:
	    unregister_chrdev_region(devid, 1);
    err0:
        return ret;
}

static void __exit char_exit(void){
	kfree(char_data);
	unregister_chrdev_region(devid, 1);
	cdev_del(&char_dev);
	device_destroy(char_class,devid);
	class_destroy(char_class);
	printk("char exit\n");
}

module_init(char_init);
module_exit(char_exit);

另外就是使用系统调用poll/select/epoll。这些系统调用可以一次性监控多个文件描述符，实现的基本原理是将当前进程加入到所有驱动的阻塞队列然后再阻塞，任何一个文件唤醒进程都会唤醒到自己。
这些系统调用监控文件描述符之后，会调用到驱动中的poll函数，实现对文件的监控。驱动中的poll函数主要完成以下几件事：

  1. 将当前进程等待对象加入到等待队列中去
  2. 判断条件是否满足(目的是触发一开始就满足条件的文件描述符的操作)
  3. 返回条件
    条件定义在poll.h中
/* These are specified by iBCS2 */
#define POLLIN		0x0001
#define POLLPRI		0x0002
#define POLLOUT		0x0004
#define POLLERR		0x0008
#define POLLHUP		0x0010
#define POLLNVAL	0x0020

/* The rest seem to be more-or-less nonstandard. Check them! */
#define POLLRDNORM	0x0040
#define POLLRDBAND	0x0080
#ifndef POLLWRNORM
#define POLLWRNORM	0x0100
#endif
#ifndef POLLWRBAND
#define POLLWRBAND	0x0200
#endif
#ifndef POLLMSG
#define POLLMSG		0x0400
#endif
#ifndef POLLREMOVE
#define POLLREMOVE	0x1000
#endif
#ifndef POLLRDHUP
#define POLLRDHUP       0x2000
#endif

POLLIN 如果设备无阻塞的读，就返回该值。
POLLRDNORM 通常的数据已经准备好，可以读了，就返回该值。通常的做法是会返回（POLLLIN|POLLRDNORA）。
POLLRDBAND 如果可以从设备读出带外数据，就返回该值，它只可在linux内核的某些网络代码中使用，通常不用在设备驱动程序中
POLLPRI 如果可以无阻塞的读取高优先级（带外）数据，就返回该值，返回该值会导致select报告文件发生异常，以为select八带外数据当作异常处理。
POLLHUP 当读设备的进程到达文件尾时，驱动程序必须返回该值，依照select的功能描述，调用select的进程被告知进程时可读的。
POLLERR 如果设备发生错误，就返回该值。
POLLOUT 如果设备可以无阻塞地些，就返回该值。
POLLWRNORM 设备已经准备好，可以写了，就返回该值。通常地做法是（POLLOUT|POLLNORM）。
POLLWRBAND 于POLLRDBAND类似。

驱动中poll定义为unsigned int (*poll) (struct file *filep, struct poll_table_struct *wait);跟read,write,open一样添加到file_operations就可以了。简单例子。

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <asm/uaccess.h>

MODULE_LICENSE("GPL");

static int data = 1;
module_param(data, int, 0644);  //声明模块参数
dev_t devid;
struct cdev char_dev;
struct class * char_class;
int buffer_size = 100;
char * char_data;
unsigned char has_data_flag;
static wait_queue_head_t wait_task;

static int open(struct inode * node, struct file * fl){
	return 0;
}

static long ioctl(struct file * fl, unsigned int cmd, unsigned long arg){
	return 0;
}

static ssize_t read(struct file * fl, char __user * buf, size_t len, loff_t * offset){
	int ret = 0,copy_len,data_len;
	wait_event_interruptible(wait_task,has_data_flag != 0);
	has_data_flag = 0;

	data_len = strlen(char_data)+1;
	if(fl->f_pos + len > data_len)
		copy_len = data_len - fl->f_pos; //超过长度，复制剩余部分
	else
		copy_len = len;					 //没超过

	ret = copy_to_user(buf,char_data+fl->f_pos,copy_len);
	ret = copy_len - ret;
	*offset += ret;						 //移动文件指针
	return ret;
}

static ssize_t write(struct file * fl, const char __user * buf, size_t len, loff_t * offset){
	int ret = 0,copy_len,data_len = buffer_size;

	if(fl->f_pos + len > data_len)
		copy_len = data_len - fl->f_pos; //超过长度，复制剩余部分
	else
		copy_len = len;					 //没超过

	ret = copy_from_user(char_data+fl->f_pos,buf,copy_len);
	ret = copy_len - ret;
	*offset += ret;						 //移动文件指针
	has_data_flag = 1;
	wake_up_interruptible(&wait_task);
	return ret;
}

unsigned int hello_poll(struct file *fl, struct poll_table_struct *wait)
{
    unsigned int mask = POLLOUT | POLLWRNORM;	//一直可写

    poll_wait(fl, &wait_task,  wait);			//当前进程加入被poll阻塞的等待队列
    if (has_data_flag) {
        mask |= POLLIN | POLLRDNORM;			//可读
    }

    return mask;
}

struct file_operations my_opts = {
	.owner = THIS_MODULE,
	.open = open,
	.read = read,
	.write = write,
	.poll = hello_poll,
	.unlocked_ioctl = ioctl
};

static int __init char_init(void){
	int ret = 0;

    devid = MKDEV(241, 1);								//换算设备号
    ret = register_chrdev_region(devid, 1, "char_test");//注册设备，在/proc/drivers下面可以看到
    if (ret < 0)
        goto err0;

    cdev_init(&char_dev,&my_opts);						//绑定opt结构体
    char_dev.owner = THIS_MODULE;
    ret = cdev_add(&char_dev,devid,1);					//注册字符设备驱动
    if (ret < 0)
    	goto err1;

    char_class = class_create(THIS_MODULE,"char_test"); //在/sys/class中创建文件夹
    device_create(char_class,NULL,devid,NULL,"char_test_dev_%d",1);//在上一步文件夹中创建char_test_dev_1

    char_data = kzalloc(buffer_size,GFP_KERNEL);

    has_data_flag = 0;
    init_waitqueue_head(&wait_task);
	printk("char init\n");
    return 0;

	err1:
	    unregister_chrdev_region(devid, 1);
    err0:
        return ret;
}

static void __exit char_exit(void){
	kfree(char_data);
	unregister_chrdev_region(devid, 1);
	cdev_del(&char_dev);
	device_destroy(char_class,devid);
	class_destroy(char_class);
	printk("char exit\n");
}

module_init(char_init);
module_exit(char_exit);

操作的application：

int main(int argc, char const *argv[])
{
    struct pollfd fds = { 0 };

    fds.fd = open(DEVICE_NAME, O_RDWR);
    if (fds.fd < 0) {
        printf("open failed! error:%s\n", strerror(errno));
        return 0;
    }

    fds.events = POLLIN;
    poll(&fds, 1, 5000); /* 五秒后自动返回 */
    printf("fds.revent: %d\n", fds.revents);

    close(fds.fd);

    return 0;
}
mini-coco
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LinuxIO模式及select、poll、epoll详解
02-26
同步IO和异步IO，阻塞IO和非阻塞IO分别是什么，到底有什么区别？不同的人在不同的上下文下给出的答案是不同的。所以先限定一下本文的上下文。本文讨论的背景是Linux环境下的networkIO。一概念说明在进行解释之前，...
linux内核 timeout,linux内核中的wait_event_interruptible_timeout接口解析
weixin_36165152的博客
04-29 375
1.原型#define wait_event_interruptible_timeout(wq_head, condition, timeout) \({ \long __ret = timeout; \might_sleep(); \if (!___wait_cond_timeout(condition)) \__ret = __wait_event_interruptible_timeout...
阻塞型与非阻塞型I/O，异步通知
Qinus的博客
07-06 1001
一、ioctl 1.ioctl系统调用可以实现用户空间的各种需求，比如报告错误信息，改变波特率，执行自破坏等 2.用户空间的ioctl(int fd, unsigned long cmd, …)后面的三个点表示的是可变参数目的参数表。这些点并不是数目不定的一串参数，而只是一个可选参数。另外这些点只是为了在编译时防止编译器进行类型检查。第三个参数的具体形式依赖于要完成的控制命令，也就是第二个参数。某...
深入理解Linux网络——内核与用户进程协作之同步阻塞方案（BIO）
qq_25046827的博客
07-09 561
我们自己的代码所在的进程：我们调用的socket()函数会进入内核态创建必要的内核对象。recv()函数会在进入内核态以后负责查看接收队列，以及在没有数据可以处理的时候把当前进程组色调，让出CPU。硬中断、软中断上下文：在这些组件中，将包处理完后会放到socket的接收队列中，然后根据socket内核对象找到其等待队列中正在因为等待而被阻塞掉的进程，将它唤醒。每次一个进程专门为了等待一个socket上的数据就被从CPU上拿出来，然后换上另一个进程。
深入理解Linux网络笔记（二）：内核和用户进程协作之阻塞方式
最新发布
hxt的博客
10-01 393
第一部分是我们自己的代码所在的进程，我们调用的socket()函数会进入内核态创建必要内核对象。recv()函数在进入内核态以后负责查看接收队列，以及在没有数据可处理的时候把当前进程阻塞掉，让出CPU第二部分是硬中断、软中断（系统线程ksoftirqd）。在这些组件中，将包处理完后会放到socket的接收队列中。
linux ioctlsocket头文件,ioctl 设置非阻塞SOCKET函数
weixin_39517199的博客
04-28 2634
很多情况下非阻塞的IO操作比阻塞的IO操作更加灵活。socket编程实际上也是一种IO操作，让我们来看一下socket编程如何设置非阻塞套接字呢。WINDOWS和linux下的方法分别见于下。windows 方法:u_long mode = 0;ioctlsocket(s,FIONBIO,&mode);控制为阻塞方式。u_long mode = 1;ioctlsocket(s,FIONBI...
你值得拥有的linux下的网络io 同步/异步/阻塞/非阻塞/BIO/NIO/AIO
qq_45206551的博客
04-09 248
所谓同步/异步，关注的是能不能同时开工。 所谓阻塞/非阻塞，关注的是能不能动。 通过推理进行组合： 同步阻塞，不能同时开工，也不能动。只有一条小道，一次只能过一辆车，可悲的是还TMD的堵上了。 同步非阻塞，不能同时开工，但可以动。只有一条小道，一次只能过一辆车，幸运的是可以正常通行。 异步阻塞，可以同时开工，但不可以动。有多条路，每条路都可以跑车，可气的是全都TMD的堵上了。 异步非阻塞，可以工时...
Linux非阻塞IO
summer_fish的专栏
06-01 696
非阻塞IO（Non-blocking IO）是一种IO模型，用于实现异步IO操作，使应用程序能够在等待IO操作完成的同时继续执行其他任务。在传统的阻塞IO模型中，当应用程序发起一个IO操作（如读取或写入数据），它会被阻塞，直到操作完成。而非阻塞IO模型中，应用程序可以通过非阻塞IO接口发起一个IO操作，并立即返回，不会被阻塞。应用程序可以继续执行其他任务，并定期轮询（或通过事件通知）来检查IO操作是否已完成。
Linux 五种网络IO模式(阻塞IO、非阻塞IO、IO多路复用、信号驱动IO、异步IO)
cpp_learner的博客
05-05 1549
介绍高并发服务器开发所需要的框架知识点，select、poll、epoll 和 libevent！
linux设备驱动程序：阻塞机制
m0_74282605的博客
06-29 394
一个对 read 的调用可能当没有数据时到来, 而以后会期待更多的数据. 或者一个进程可能试图写, 但是你的设备没有准备好接受数据, 因为你的输出缓冲满了. 调用进程往往不关心这种问题;的意思就是，你突然发现，你的雇工不知道在什么时候没经过你允许，自己睡觉呢，但是你不能怪雇工，肯定你这个雇主没注意，本来你让雇工扫地，结果扫帚被偷了或被邻居家借去了，你又没让雇工继续干别的活，他就只好睡觉了。阻塞对象上可以有非阻塞的调用方式，我们可以通过一定的API去轮询状态，在适当的时候调用阻塞函数，就可以避免阻塞。
Socket高性能IO模型浅析
03-03
（2）同步非阻塞IO（Non-blockingIO）：默认创建的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的NIO并非Java的NIO（NewIO）库。（3）IO多路复用（IOMultiplexing）：即经典的Reactor设计...
嵌入式Linux按键驱动，支持短按和长按检测
03-15
使用平台驱动框架，基于按键中断和内核定时器实现按键和长按检测，支持休眠-唤醒，POLL机制，异步通知和非阻塞的IO操作。
37.【linux驱动】pcie驱动入门
柏鑫的博客
08-05 2402
pcie总线向下兼容pci总线，文中所述pci默认等于pcie pcie拓扑结构 pcie拓扑主要由总线、桥和设备卡组成，桥将父总线与子总线连接在一起形成树型结构。桥主要分为一下三类： Host/PCI桥：用于连接CPU与PCI根总线，在PC中，内存控制器也通常被集成到Host/PCI桥设备芯片，Host/PCI桥通常被称 为“北桥芯片组”。 PCI/ISA桥：用于连接旧的ISA总线。PCI/ISA桥也被称为“南桥芯片组”。 PCI-to-PCI桥：用于连接PCI主总线与次总线。 pci总线编号采用
14.【linux驱动】spi(GPIO模拟)
柏鑫的博客
06-22 1853
代码
16.【linux驱动】spi驱动TFT液晶屏
柏鑫的博客
06-22 1617
代码
1.Linux内核从远程nfs启动（踩坑记录）
柏鑫的博客
06-02 1371
目录前言配置内核支持NFS启动搭建NFS服务器 前言 本次实验的启动方式是：通过网络挂载rootfs，内核从sd卡加载，并没有通过网络下载 关于uboot的两点配置bootargs，bootcmd bootargs：传递给内核使用的参数，对uboot来说只是一个环境变量 bootcmd：uboot启动命令，主要是加载内核，设备树，rootfs，然后用bootm启动内核 1.先将随便烧写个官方镜像到sd卡（也不能太随便，只要你要编译的内核要接近镜像的，否则后面替换内核可能导致uboot和内核版本不匹配，从而无
19.【linux驱动】IIC驱动（OLED屏）
柏鑫的博客
06-18 1336
代码
35.【linux驱动】spi framebuffer驱动
柏鑫的博客
07-27 1298
spi framebuffer驱动 上一节实现了一个framebuffer驱动，但是没有具体操作硬件，这节做一个SPI屏驱动，整个代码作为一个spi驱动去写。spi相关内容可以看()[]。 首先是spi驱动，屏幕的操作由厂家C51代码改编而来。屏幕控制器是ILI9488，分辨率320 * 480 spi部分 spi.h struct Lcd_dev { unsigned short width; //LCD 宽度 unsigned short height; //L
linux阻塞和休眠,Linux设备驱动之阻塞与非阻塞IO
05-19
Linux中的阻塞和休眠都是与进程或线程的状态相关的概念。 阻塞是指进程或线程在等待某个事件发生时，被挂起了，等待事件发生后才能继续执行。在Linux中，常见的阻塞方式有调用sleep()函数、等待信号量、等待I/O操作完成等。 休眠是指进程或线程主动让出CPU，挂起自己的执行并进入睡眠状态，直到某个事件唤醒它。在Linux中，常见的休眠方式有调用wait()函数、等待信号量、进入睡眠状态等。 在Linux设备驱动中，阻塞和非阻塞IO是一个常见的问题。阻塞IO是指当应用程序发起IO操作时，如果设备没有准备好数据或者无法立即完成IO操作，应用程序会一直等待，直到IO操作完成。相反，非阻塞IO是指应用程序发起IO操作时，如果设备没有准备好数据或者无法立即完成IO操作，应用程序会立即返回，可以继续执行其他操作。 在设备驱动中，如果使用阻塞IO，会导致内核线程被阻塞，从而无法响应其他请求，影响系统的性能。因此，在实现设备驱动时，通常会使用非阻塞IO或异步IO的方式来提高系统的性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值