• Linux驱动实现IO模型

    在Linux系统分为内核态和用户态，CPU会在这两个状态之间进行切换。当进行IO操作时，应用程序会使用系统调用进入内核态，内核操作系统会准备好数据，把IO设备的数据加载到内核缓冲区。

    然后内核操作系统会把内核缓冲区的数据从内核空间拷贝到用户空间。但是进行IO操作时，CPU和内存的速度远远高于外设的速度，所以需要我们使用IO模型编程解决。

    IO模型的种类：

    • 阻塞IO
    • 非阻塞IO
    • IO多路复用
    • 信号驱动IO
    • 异步IO

    阻塞IO

    当进程以阻塞的方式打开设备文件时（默认方式），如果资源不可用，那么进程阻塞，也就是进程休眠。既然有休眠，就有对应的唤醒操作，否则进程将会一直休眠下去。驱动程序应该在资源可用时负责唤醒操作。相比于非阻塞IO，其最大的优点就是，资源不可用时，不占用CPU的时间，而非阻塞IO必须要定期尝试，看看资源是否可以获得，这对于键盘鼠标这类设备来说，其效率非常低。但是阻塞IO也有一个明显的缺点，那就是进程在休眠期间再也不能做其他事情。

    通过上面的描述，发现要实现阻塞操作最重要的数据结构就是等待队列。不了解等待队列的请参考（等待队列）。

    下面通过一个简单的驱动程序来实现阻塞IO模型。

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. struct devices {
    13.     char buffer[32];
    14.     int flag;
    15. };
    16.  
    17. struct devices qw_dev;
    18.  
    19. DECLARE_WAIT_QUEUE_HEAD(wqh);
    20.  
    21. int test_open(struct inode *inode, struct file *filp)
    22. {
    23.     filp->private_data = &qw_dev;
    24.  
    25.     printk("dev open!\n");
    26.  
    27.     return 0;
    28. }
    29.  
    30. ssize_t test_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
    31. {
    32.     struct devices *dev = (struct devices *)filp->private_data;
    33.  
    34.     wait_event_interruptible(wqh, dev->flag);
    35.  
    36.     if(copy_to_user(buf, dev->buffer, size)!=0) {
    37. 		printk("copy to user error\n");
    38. 		return -EFAULT;
    39.     }
    40. 	
    41.     return size;
    42. }
    43.  
    44. ssize_t test_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
    45. {
    46.     struct devices *dev = (struct devices *)filp->private_data;
    47.  
    48.     if(copy_from_user(dev->buffer, buf, size)) {
    49. 		printk("copy from user error\n");
    50.         return -EFAULT;
    51.     }
    52.  
    53.     dev->flag = 1;
    54.  
    55.     wake_up_interruptible(&wqh);
    56.     
    57.     printk("WRITE: %s\n", dev->buffer);
    58.  
    59.     return size;
    60.  
    61. }
    62.  
    63. int test_release(struct inode *inode, struct file *filp)
    64. {
    65. 	printk("dev close!\n");
    66.  
    67. 	return 0;
    68. }
    69.  
    70. //声明操作函数集合
    71. struct file_operations wq_fops = {
    72. 	.owner = THIS_MODULE,
    73. 	.open = test_open,
    74. 	.read = test_read,
    75.     .write = test_write,
    76. 	.release = test_release,
    77. };
    78.  
    79. //分配初始化miscdevice
    80. struct miscdevice misc_dev = {
    81. 	.minor = MISC_DYNAMIC_MINOR,//系统分配次设备号
    82. 	.name = "qw",//设备文件名
    83. 	.fops = &wq_fops,//操作函数集合
    84. };
    85.  
    86. //加载函数
    87. int test_init(void)
    88. {
    89. 	int ret;
    90.  
    91. 	//注册miscdevice
    92. 	ret = misc_register(&misc_dev);
    93. 	
    94. 	if (ret < 0) {
    95. 		misc_deregister(&misc_dev);
    96. 		return -1;
    97. 	}
    98.  
    99.     qw_dev.flag = 0;
    100.  
    101. 	return 0;
    102.  
    103. }
    104.  
    105. //卸载函数
    106. void test_exit(void)
    107. {
    108. 	//注销miscdevice	
    109. 	misc_deregister(&misc_dev);
    110. }
    111.  
    112. //声明为模块的入口和出口
    113. module_init(test_init);
    114. module_exit(test_exit);
    115.  
    116.  
    117. MODULE_LICENSE("GPL");//GPL模块许可证
    118. MODULE_AUTHOR("xin");//作者
    119. MODULE_VERSION("2.0");//版本
    120. MODULE_DESCRIPTION("WQ driver!");//描述信息

    向驱动写数据的应用程序。 

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. int main(int argc, char *argv[])
    9. {
    10.     int fd;
    11.     char buf2[32] = "hello world";
    12.     
    13.     fd = open("/dev/qw", O_RDWR);
    14.  
    15.     if (fd < 0) {
    16.         perror("open error");
    17.         return fd;
    18.     }
    19.  
    20.     write(fd, buf2, strlen(buf2));
    21.  
    22.     close(fd);
    23.  
    24.     return 0;
    25. }

    向驱动读数据的应用程序。 

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. int main(int argc, char *argv[])
    9. {
    10.     int fd;
    11.     char buf1[32] = {0};
    12.     
    13.     fd = open("/dev/qw", O_RDWR);
    14.  
    15.     if (fd < 0) {
    16.         perror("open error");
    17.         return fd;
    18.     }
    19.  
    20.     read(fd, buf1, 32);
    21.     
    22.     printf("READ:%s\n",buf1);
    23.  
    24.     close(fd);
    25.  
    26.     return 0;
    27. }

    将驱动模块加载到内核中后，先运行读程序，发现程序会阻塞。然后另开一个终端运行写程序，读程序才会打印写程序的数据。

    非阻塞IO

    设备不一定随时都能给用户提供服务，这就有了资源可用和不可用两种状态。如果应用程序以非阻塞的方法打开设备文件，当资源不可用时，驱动就应该立即返回，并用一个错误码EAGAIN来通知应用程序此时资源不可用，应用程序应该稍后再尝试。

    下面通过一个简单的驱动程序来实现阻塞IO模型。在阻塞IO模型上进行修改，当应用程序打开设备文件时，以非阻塞方式打开 。

    fd = open("/dev/qw", O_RDWR | O_NONBLOCK);

    驱动程序读函数中判断设备是否以非阻塞方式打开，并且资源是否准备好。struct file 结构体中的f_flags成员存储打开设备文件的标志。

    1. if (filp->f_flags & O_NONBLOCK) {
    2.     if (dev->flag != 1) {
    3.         return -EAGAIN;
    4.     }
    5. }

    驱动程序 

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. struct devices {
    13.     char buffer[32];
    14.     int flag;
    15. };
    16.  
    17. struct devices qw_dev;
    18.  
    19. DECLARE_WAIT_QUEUE_HEAD(wqh);
    20.  
    21. int test_open(struct inode *inode, struct file *filp)
    22. {
    23.     filp->private_data = &qw_dev;
    24.  
    25.     printk("dev open!\n");
    26.  
    27.     return 0;
    28. }
    29.  
    30. ssize_t test_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
    31. {
    32.     struct devices *dev = (struct devices *)filp->private_data;
    33.     
    34.     if (filp->f_flags & O_NONBLOCK) {
    35.     	if (dev->flag != 1) {
    36.     		return -EAGAIN;
    37.     	
    38.     	}
    39.     }
    40.  
    41.     wait_event_interruptible(wqh, dev->flag);
    42.  
    43.     if(copy_to_user(buf, dev->buffer, size)!=0) {
    44. 		printk("copy to user error\n");
    45. 		return -EFAULT;
    46.     }
    47. 	
    48.     return size;
    49. }
    50.  
    51. ssize_t test_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
    52. {
    53.     struct devices *dev = (struct devices *)filp->private_data;
    54.  
    55.     if(copy_from_user(dev->buffer, buf, size)) {
    56. 		printk("copy from user error\n");
    57.         return -EFAULT;
    58.     }
    59.  
    60.     dev->flag = 1;
    61.  
    62.     wake_up_interruptible(&wqh);
    63.     
    64.     printk("WRITE: %s\n", dev->buffer);
    65.  
    66.     return size;
    67.  
    68. }
    69.  
    70. int test_release(struct inode *inode, struct file *filp)
    71. {
    72. 	printk("dev close!\n");
    73.  
    74. 	return 0;
    75. }
    76.  
    77. //声明操作函数集合
    78. struct file_operations wq_fops = {
    79. 	.owner = THIS_MODULE,
    80. 	.open = test_open,
    81. 	.read = test_read,
    82.     .write = test_write,
    83. 	.release = test_release,
    84. };
    85.  
    86. //分配初始化miscdevice
    87. struct miscdevice misc_dev = {
    88. 	.minor = MISC_DYNAMIC_MINOR,//系统分配次设备号
    89. 	.name = "qw",//设备文件名
    90. 	.fops = &wq_fops,//操作函数集合
    91. };
    92.  
    93. //加载函数
    94. int test_init(void)
    95. {
    96. 	int ret;
    97.  
    98. 	//注册miscdevice
    99. 	ret = misc_register(&misc_dev);
    100. 	
    101. 	if (ret < 0) {
    102. 		misc_deregister(&misc_dev);
    103. 		return -1;
    104. 	}
    105.  
    106.     qw_dev.flag = 0;
    107.  
    108. 	return 0;
    109.  
    110. }
    111.  
    112. //卸载函数
    113. void test_exit(void)
    114. {
    115. 	//注销miscdevice	
    116. 	misc_deregister(&misc_dev);
    117. }
    118.  
    119. //声明为模块的入口和出口
    120. module_init(test_init);
    121. module_exit(test_exit);
    122.  
    123.  
    124. MODULE_LICENSE("GPL");//GPL模块许可证
    125. MODULE_AUTHOR("xin");//作者
    126. MODULE_VERSION("2.0");//版本
    127. MODULE_DESCRIPTION("WQ driver!");//描述信息

    读应用程序如下所示，写程序前面的一样就不展示出来。

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. int main(int argc, char *argv[])
    9. {
    10.     int fd;
    11.     char buf1[32] = {0};
    12.     
    13.     fd = open("/dev/qw", O_RDWR | O_NONBLOCK);
    14.  
    15.     if (fd < 0) {
    16.         perror("open error");
    17.         return fd;
    18.     }
    19.     
    20.     while(1) {
    21.     	read(fd, buf1, 32);
    22.     	printf("READ:%s\n",buf1);
    23.     	sleep(1);
    24.     }
    25.     
    26.     close(fd);
    27.  
    28.     return 0;
    29. }

    将驱动模块加载到内核中后，先运行读程序，发现程序不会阻塞，但是没有数据。然后另开一个终端运行写程序，读程序才会打印出写程序的数据。

    IO多路复用

    阻塞IO优点是在设备资源不可用时，进程主动放弃CPU，但是进程阻塞后不能做其他操作。非阻塞IO优点是资源不可用时不会阻塞，但是会不停地轮询，系统效率降低。当一个进程要同时对多个设备进程操作时以上两种方法显得非常不方便。这就需要使用到IO复用模型。

    它允许一个进程可以同时监视多个文件描述符，并且可以在其中任何一个文件描述符上等待数据可读或可写，从而实现并发IO操作。在应用程序中Linux提供了三种API函数：poll，select和epoll。在驱动程序中只需要实现poll函数。

    poll和select基本上是一样 ，都可以监听多个文件描述符，通过轮询多个文件描述符来获得已经准备好的文件描述符。epoll是将主动轮询变成了被动通知，当事件发生时，被动的接受通知。

    接下来以poll为例进行说明，应用程序中poll系统调用的原型及相关的数据类型如下。

    int poll (struct pollfd *fds, nfds_t nfds, int timeout);

    struct pollfd {

            int fd;

            short events;

            short revents;

    };

    POLLIN There is data to read.

    POLLOUT Writing now will not block.

    POLLRDNORM Equivalent to POLLIN.

    POLLWRNORM Equivalent to POLLOUT.

    poll的第一个参数是要监听的文件描述符集合，类型为指向struct pollfd的指针，struct pollfd有3个成员，fd是要监听文件描述符，events是监听的事件，revents是返回的事件。常见的事件有POLLIN、POLLOUT，分别表示设备可以无阻塞地读、写。POLLRDNORM和POLLWRNORM是在_XOPEN_SOURCE宏被定义时所引入的事件，POLLRDNORM通常和POLLIN等价，POLLWRNORM通常和POLLOUT等价。

    poll函数的第二个参数是要监听的文件描述符的个数，第三个参数的毫秒的超时值，负数表示一直监听，直到被监听的文件描述符集合中的任意一个设备发生了事件才会返回。函数返回值为-1表示失败，成功返回revents不为0的文件描述符个数。

    读应用程序如下所示，写程序前面的一样就不展示出来。

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. int main(int argc, char *argv[])
    10. {
    11.     int fd;
    12.     int ret;
    13.     char buf1[32] = {0};
    14.     struct pollfd fds[1];
    15.     
    16.     fd = open("/dev/qw", O_RDWR | O_NONBLOCK);
    17.  
    18.     if (fd < 0) {
    19.         perror("open error");
    20.         return fd;
    21.     }
    22.     
    23.     fds[0].fd = fd;
    24.     fds[0].events = POLLIN;
    25.     
    26.     while(1) {
    27.     	ret = poll(fds, 1, 5000);
    28.     	if (!ret) {
    29.     		printf("timeout\n");
    30.     	} else if (fds[0].revents == POLLIN) {
    31.     		read(fd, buf1, 32);
    32.     		printf("READ:%s\n",buf1);
    33.     		sleep(1);
    34.     	}
    35.     }
    36.     
    37.     close(fd);
    38.  
    39.     return 0;
    40. }

    驱动中poll函数需要完成两点：1. 对可能引起设备文件状态变化的等待队列调用poll_wait函数，将对应的等待队列头添加到poll_table。2. 返回表示是否能对设备进行无阻塞读写访问的掩码。

    1. static __poll_t test_poll(struct file *filp, struct poll_table_struct *p)
    2. {
    3. 	struct devices *dev = (struct devices *)filp->private_data;
    4. 	
    5. 	__poll_t mask = 0;
    6. 	
    7. 	poll_wait(filp, &wqh, p);
    8. 	
    9. 	if (dev->flag = 1) {
    10. 		mask |= POLLIN;
    11. 	}
    12. 	
    13. 	return mask;
    14. }

    注意：poll_wait函数不会阻塞。

    驱动程序

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. struct devices {
    14.     char buffer[32];
    15.     int flag;
    16. };
    17.  
    18. struct devices qw_dev;
    19.  
    20. DECLARE_WAIT_QUEUE_HEAD(wqh);
    21.  
    22. int test_open(struct inode *inode, struct file *filp)
    23. {
    24.     filp->private_data = &qw_dev;
    25.  
    26.     printk("dev open!\n");
    27.  
    28.     return 0;
    29. }
    30.  
    31. ssize_t test_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
    32. {
    33.     struct devices *dev = (struct devices *)filp->private_data;
    34.     
    35.     if (filp->f_flags & O_NONBLOCK) {
    36.     	if (dev->flag != 1) {
    37.     		return -EAGAIN;
    38.     	
    39.     	}
    40.     }
    41.  
    42.     wait_event_interruptible(wqh, dev->flag);
    43.  
    44.     if(copy_to_user(buf, dev->buffer, size)!=0) {
    45. 		printk("copy to user error\n");
    46. 		return -EFAULT;
    47.     }
    48. 	
    49.     return size;
    50. }
    51.  
    52. ssize_t test_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
    53. {
    54.     struct devices *dev = (struct devices *)filp->private_data;
    55.  
    56.     if(copy_from_user(dev->buffer, buf, size)) {
    57. 		printk("copy from user error\n");
    58.         return -EFAULT;
    59.     }
    60.  
    61.     dev->flag = 1;
    62.  
    63.     wake_up_interruptible(&wqh);
    64.     
    65.     printk("WRITE: %s\n", dev->buffer);
    66.  
    67.     return size;
    68.  
    69. }
    70.  
    71. static __poll_t test_poll(struct file *filp, struct poll_table_struct *p)
    72. {
    73. 	struct devices *dev = (struct devices *)filp->private_data;
    74. 	
    75. 	__poll_t mask = 0;
    76. 	
    77. 	poll_wait(filp, &wqh, p);
    78. 	
    79. 	if (dev->flag == 1) {
    80. 		mask |= POLLIN;
    81. 	}
    82. 	
    83. 	return mask;
    84. }
    85.  
    86. int test_release(struct inode *inode, struct file *filp)
    87. {
    88. 	printk("dev close!\n");
    89.  
    90. 	return 0;
    91. }
    92.  
    93. //声明操作函数集合
    94. struct file_operations wq_fops = {
    95. 	.owner = THIS_MODULE,
    96. 	.open = test_open,
    97. 	.read = test_read,
    98.     .write = test_write,
    99.     .poll = test_poll,
    100. 	.release = test_release,
    101. };
    102.  
    103. //分配初始化miscdevice
    104. struct miscdevice misc_dev = {
    105. 	.minor = MISC_DYNAMIC_MINOR,//系统分配次设备号
    106. 	.name = "qw",//设备文件名
    107. 	.fops = &wq_fops,//操作函数集合
    108. };
    109.  
    110. //加载函数
    111. int test_init(void)
    112. {
    113. 	int ret;
    114.  
    115. 	//注册miscdevice
    116. 	ret = misc_register(&misc_dev);
    117. 	
    118. 	if (ret < 0) {
    119. 		misc_deregister(&misc_dev);
    120. 		return -1;
    121. 	}
    122.  
    123.     qw_dev.flag = 0;
    124.  
    125. 	return 0;
    126.  
    127. }
    128.  
    129. //卸载函数
    130. void test_exit(void)
    131. {
    132. 	//注销miscdevice	
    133. 	misc_deregister(&misc_dev);
    134. }
    135.  
    136. //声明为模块的入口和出口
    137. module_init(test_init);
    138. module_exit(test_exit);
    139.  
    140.  
    141. MODULE_LICENSE("GPL");//GPL模块许可证
    142. MODULE_AUTHOR("xin");//作者
    143. MODULE_VERSION("2.0");//版本
    144. MODULE_DESCRIPTION("WQ driver!");//描述信息

    将驱动模块加载到内核中后，先运行读程序，发现程序不会阻塞，但是没有数据且每5s打印超时。然后另开一个终端运行写程序，读程序才会打印出写程序的数据。

    信号驱动IO

    在信号驱动IO中，进程使用系统调用 sigaction() 来注册一个信号处理函数，该函数会在IO事件就绪时被内核调用。当进程调用 sigaction() 注册一个信号处理函数时，它需要指定一个描述符和一个事件，内核在检测到该描述符上发生指定事件时，会向进程发送指定信号。进程可以通过捕获该信号并执行信号处理函数。

    与其他IO多路复用技术相比，信号驱动IO也避免了轮询机制的开销，从而减少了 CPU 的占用。但是，信号驱动IO也存在一些缺点。首先，它对信号的处理需要一定的时间，因此它不适合高速IO操作。其次，由于信号是不可靠的，因此在使用信号驱动IO时需要考虑到信号可能会丢失的情况。

    在应用程序使用信号驱动IO，需要完成以下几步：1. 注册信号处理函数，应用程序使用 sigaction()来注册一个信号处理函数。2. 设置能接受这个信号的进程。 3. 开启信号驱动IO，通常是使用fcntl函数的F_SETFL命令打开FASYNC标志。

    fcntl系统调用可以用来对已打开的文件描述符进行各种控制操作以改变已打开文件的的各种属性。

    函数原型：

    1. #include
    2. #include
    3. int fcntl(int fd, int cmd);
    4. int fcntl(int fd, int cmd, long arg);
    5. int fcntl(int fd, int cmd ,struct flock* lock);

    fcntl函数功能依据cmd的值的不同而不同。参数对应功能如下：

    读应用程序如下所示，写程序前面的一样就不展示出来。 

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. int fd;
    10. char buf1[32] = {0};
    11.  
    12. static void test_func(int signal)
    13. {
    14. 	read(fd, buf1, 32);
    15. 	printf("READ:%s\n",buf1);
    16. }
    17.  
    18. int main(int argc, char *argv[])
    19. {
    20. 	int flags;
    21.     
    22.     fd = open("/dev/qw", O_RDWR | O_NONBLOCK);
    23.  
    24.     if (fd < 0) {
    25.         perror("open error");
    26.         return fd;
    27.     }
    28.     
    29.     signal(SIGIO, test_func);            //注册信号处理函数test_func
    30.     
    31.     fcntl(fd, F_SETOWN, getpid());       //设置当前进程接收SIGIO信号
    32.     flags = fcntl(fd, F_GETFD);          //获得文件描述符标志
    33.     fcntl(fd, F_SETFL, flags | FASYNC);  //设置文件状态标志，在原来文件描述符标志上开启FASYNC标志
    34.  
    35.     while(1);
    36.     
    37.     close(fd);
    38.  
    39.     return 0;
    40. }

    当应用程序开启信号驱动IO时，会触发驱动程序中的fasync函数，而fasync函数会调用fasync_helper函数去初始化fasync_struct结构体。 当数据到达时调用kill_fasync函数用来通知应用程序，然后应用程序执行信号处理函数，它的参数是被传递的信号(常常是 SIGIO)和 band 。band：可读时设置成POLLIN，可写时设置成POLLOUT。 

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. struct devices {
    14.     char buffer[32];
    15.     int flag;
    16.     struct fasync_struct *fasync;
    17. };
    18.  
    19. struct devices qw_dev;
    20.  
    21. DECLARE_WAIT_QUEUE_HEAD(wqh);
    22.  
    23. int test_open(struct inode *inode, struct file *filp)
    24. {
    25.     filp->private_data = &qw_dev;
    26.  
    27.     printk("dev open!\n");
    28.  
    29.     return 0;
    30. }
    31.  
    32. ssize_t test_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
    33. {
    34.     struct devices *dev = (struct devices *)filp->private_data;
    35.     
    36.     if (filp->f_flags & O_NONBLOCK) {
    37.     	if (dev->flag != 1) {
    38.     		return -EAGAIN;
    39.     	
    40.     	}
    41.     }
    42.  
    43.     wait_event_interruptible(wqh, dev->flag);
    44.  
    45.     if(copy_to_user(buf, dev->buffer, size)!=0) {
    46. 		printk("copy to user error\n");
    47. 		return -EFAULT;
    48.     }
    49. 	
    50.     return size;
    51. }
    52.  
    53. ssize_t test_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
    54. {
    55.     struct devices *dev = (struct devices *)filp->private_data;
    56.  
    57.     if(copy_from_user(dev->buffer, buf, size)) {
    58. 		printk("copy from user error\n");
    59.         return -EFAULT;
    60.     }
    61.  
    62.     dev->flag = 1;
    63.  
    64.     wake_up_interruptible(&wqh);
    65.     
    66.     kill_fasync(&dev->fasync, SIGIO, POLLIN);
    67.     
    68.     printk("WRITE: %s\n", dev->buffer);
    69.  
    70.     return size;
    71.  
    72. }
    73.  
    74. static __poll_t test_poll(struct file *filp, struct poll_table_struct *p)
    75. {
    76. 	struct devices *dev = (struct devices *)filp->private_data;
    77. 	
    78. 	__poll_t mask = 0;
    79. 	
    80. 	poll_wait(filp, &wqh, p);
    81. 	
    82. 	if (dev->flag == 1) {
    83. 		mask |= POLLIN;
    84. 	}
    85. 	
    86. 	return mask;
    87. }
    88.  
    89. static int test_fasync(int fd, struct file *filp, int on)
    90. {
    91. 	struct devices *dev = (struct devices *)filp->private_data;
    92. 	
    93. 	return fasync_helper(fd, filp, on, &dev->fasync); //对fasync_struct结构体进行初始化
    94. }
    95.  
    96. int test_release(struct inode *inode, struct file *filp)
    97. {
    98. 	printk("dev close!\n");
    99.  
    100. 	return 0;
    101. }
    102.  
    103. //声明操作函数集合
    104. struct file_operations wq_fops = {
    105. 	.owner = THIS_MODULE,
    106. 	.open = test_open,
    107. 	.read = test_read,
    108.     .write = test_write,
    109.     .poll = test_poll,
    110.     .fasync = test_fasync,
    111. 	.release = test_release,
    112. };
    113.  
    114. //分配初始化miscdevice
    115. struct miscdevice misc_dev = {
    116. 	.minor = MISC_DYNAMIC_MINOR,//系统分配次设备号
    117. 	.name = "qw",//设备文件名
    118. 	.fops = &wq_fops,//操作函数集合
    119. };
    120.  
    121. //加载函数
    122. int test_init(void)
    123. {
    124. 	int ret;
    125.  
    126. 	//注册miscdevice
    127. 	ret = misc_register(&misc_dev);
    128. 	
    129. 	if (ret < 0) {
    130. 		misc_deregister(&misc_dev);
    131. 		return -1;
    132. 	}
    133.  
    134.     qw_dev.flag = 0;
    135.  
    136. 	return 0;
    137.  
    138. }
    139.  
    140. //卸载函数
    141. void test_exit(void)
    142. {
    143. 	//注销miscdevice	
    144. 	misc_deregister(&misc_dev);
    145. }
    146.  
    147. //声明为模块的入口和出口
    148. module_init(test_init);
    149. module_exit(test_exit);
    150.  
    151.  
    152. MODULE_LICENSE("GPL");//GPL模块许可证
    153. MODULE_AUTHOR("xin");//作者
    154. MODULE_VERSION("2.0");//版本
    155. MODULE_DESCRIPTION("WQ driver!");//描述信息

    将驱动模块加载到内核中后，先运行读程序，发现程序会阻塞，这是因为用while(1)来模拟程序继续处理其他事情。然后另开一个终端运行写程序，读程序才会打印出写程序的数据。

    异步IO

    相对于同步IO，异步IO不是顺序执行。用户进程进行aio_read系统调用之后，无论内核数据是否准备好，都会直接返回给用户进程，然后用户态进程可以去做别的事情。等到设备数据准备好了，内核直接复制数据给进程，然后从内核向进程发送通知。IO两个阶段，进程都是非阻塞的。异步IO可以在空户空间的glibc库实现，不依赖内核就不举实例了。

    总结 

    阻塞IO实现简单，但是性能不佳，非阻塞IO虽然不需要阻塞线程，但是他需要轮询操作低效。

    IO多路复用有三种实现，select和poll都是使用了轮询的方式，监听文件描述符不能太多。epoll的实现使用了红黑树，增删改文件描述符效率高，并且使用了事件触发机制，不需要进行轮询。

    信号驱动IO依赖于信号机制，它对信号的处理需要一定的时间，因此它不适合高速IO操作。

    异步IO模型的实现比同步IO模型更加复杂，需要使用操作系统提供的通知机制来处理IO完成的事件，同时也需要考虑到异步IO可能会引入的竞争条件和死锁问题。

    以上就将5种I/O模型原理介绍完了，并且还用程序模拟实现了，如果有什么疑问或者建议欢迎在评论区中提出来嗷~。

    参考文章：深入理解Linux的五种IO模型，linux五种IO模型。

  • 相关阅读:
    为何海量计算机系毕业生“负债”报IT培训班？高校IT教育该如何变革？
    Python 进阶语法：JSON
    VS+Qt+C++ GDAL读取tif图像数据显示
    如何利用三极管实现电平转换
    云原生之快速使用Nacos Spring Cloud
    代码审查问题思考
    “第五十天” 机组--数据的表示
    LeetCode高频题：戈壁滩种树，一排n棵树，至少有k棵树存活时，最终形成的风景线有多少不同的情况
    PyQt5_寻找顶(底)背离并可视化
    块编辑器和双链笔记如何选择Notion vs Roam Research?FlowUs vs Obsidian
  • 原文地址：https://blog.csdn.net/qq_53221728/article/details/133310797