内核实验（八）：实现O-NONBLOCK非阻塞读写

最新推荐文章于 2024-09-12 21:29:10 发布
最新推荐文章于 2024-09-12 21:29:10 发布
阅读量814 收藏
点赞数
分类专栏： Linux内核学习 文章标签： linux 驱动开发 Qemu Linux内核调试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyzsyx/article/details/129649295
版权
该文介绍了一个在QEMU虚拟机中进行内核调试的实验，重点在于理解和实现非阻塞IO。通过修改驱动源码，当设备驱动的缓冲区无数据时，对于非阻塞IO，进程不再阻塞而是返回错误。实验涉及到了kfifo队列的使用，并提供了相应的驱动程序和应用程序代码示例，展示了如何在用户空间进行非阻塞的读写操作。
摘要由CSDN通过智能技术生成

一、篇头

继续使用qemu调试内核的实验。本章复习阻塞与非阻塞IO的概念和机制，然后对之前实验（七）的代码做少许修改，来实现非阻塞的IO读写。

二、系列文章

略……

三、实验环境

  • 编译服务器+NFS：ubuntu 22.04
  • Qemu 虚拟机：Linux version 5.15.102 + Buysbox 1.3.36 + ARM_32bit

Qemu 启动命令：qemu-system-arm -nographic -M vexpress-a9 -m 1024M -kernel arch/arm/boot/zImage -initrd …/busybox/rootfs.ext4.img.gz -dtb arch/arm/boot/dts/vexpress-v2p-ca9.dtb

四、源码

4.1 非阻塞IO与阻塞IO

非阻塞：进程发起I/O系统调用后，如果设备驱动的缓冲区没有数据，那么进程返回一个错误而不会被阻塞。如果驱动缓冲区中有数据，那么设备驱动把数据直接返回给用户进程。

阻塞：进程发起I/O系统调用后，如果设备的缓冲区没有数据，那么需要到硬件I/O中重新获取新数据，进程会被阻塞，也就是睡眠等待。直到数据准备好，进程才会被唤醒，并重新把数据返回给用户空间。

4.2 驱动源码

  • 文件名：linux-stable\my_kmodules\test_7.c
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/init.h>
#include <linux/miscdevice.h>
#include <linux/kfifo.h>


#define MY_DEV_NAME "my_dev"

DEFINE_KFIFO(my_kfifo, char, 128);

static int test_6_open(struct inode *inode, struct file *file)
{
	int major = MAJOR(inode->i_rdev);
	int minor = MINOR(inode->i_rdev);

	pr_info("%s: major=%d, minor=%d\n", __func__, major, minor);
	return 0;
}

static int test_6_release(struct inode *inode, struct file *file)
{
	pr_info("%s \n", __func__);

	return 0;
}

static ssize_t test_6_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
	int ret;
	unsigned int copied_count=0;
	pr_info("%s \n", __func__);

	
 	/*
 	* (1)add for O_NONBLOCK reading
 	*/
	if(kfifo_is_empty(&my_kfifo)){
		if(file->f_flags & O_NONBLOCK){
			return  -EAGAIN;
		}
	}
	
	ret = kfifo_to_user(&my_kfifo, buf,  count, &copied_count);
	if(ret != 0) {
		return -EFAULT;
	}
	//pr_info("%s ：%s, count=%d, copied_count=%d\n", __func__, my_kfifo.buf,  count, copied_count);
	
	return copied_count;
}

static ssize_t test_6_write(struct file *file, const char __user *buf, size_t count, loff_t *f_pos)
{
	int ret;
	unsigned int copied_count=0;
	pr_info("%s \n", __func__);

 	/*
 	* (1)add for O_NONBLOCK writing
 	*/
	if(kfifo_is_full(&my_kfifo)){
		if(file->f_flags & O_NONBLOCK){
			return  -EAGAIN;
		}
	}
	
	ret = kfifo_from_user(&my_kfifo, buf, count, &copied_count);
	if(ret != 0) {
		return -EFAULT;
	}
	
	//pr_info("%s , my_kfifo.buf=%s\n", __func__, my_kfifo.buf);	
	return copied_count;


}

static const struct file_operations test_fops = {
	.owner = THIS_MODULE,
	.open = test_6_open,
	.release = test_6_release,
	.read = test_6_read,
	.write = test_6_write
};

static struct miscdevice test_6_misc_device ={

	.minor = MISC_DYNAMIC_MINOR,
	.name = MY_DEV_NAME,
	.fops = &test_fops,
};


static int __init test_6_init(void)
{
	int ret;

	pr_info("test_6_init\n");

	ret = misc_register(&test_6_misc_device);
	if (ret != 0 ) {
		pr_err("failed to misc_register");
		return ret;
	}

	pr_err("Minor number = %d\n", test_6_misc_device.minor);

	return 0;
}

static void __exit test_6_exit(void)
{
	pr_info("test_6_exit\n");
    misc_deregister(&test_6_misc_device);
}

module_init(test_6_init);
module_exit(test_6_exit);

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("szhou <66176468@qq.com>");
MODULE_DESCRIPTION("test_7, 使用misc、KFIFO开发设备驱动非阻塞设备驱动。");

4.3 APP源码

  • 文件名：linux-stable\my_kmodules\app_test_7.c
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h> //消除 warning: implicit declaration of function ‘malloc’ [-Wimplicit-function-declaration]
#include <string.h> //消除 warning: implicit declaration of function ‘memset’ [-Wimplicit-function-declaration]

#define MY_DEV_NAME "/dev/my_dev"

int main(int argc, void * argv[])
{

	int fd;
	int ret;
	size_t len;
	char message[80] = "To test reading and writing FIFO device with O_NONBLOCK.";
	char *read_buffer;

	len = sizeof(message);
	
	read_buffer = (char *)malloc((size_t)2*len);
	memset((void *)read_buffer, 0, 2*len);

	fd = open(MY_DEV_NAME, O_RDWR | O_NONBLOCK);
	if (fd < 0) {
		printf("open device %s failded\n", MY_DEV_NAME);
		return -1;
	}

	/*1: 先读一次，但这个时候KFIFO为空，所以会直接返回 */
	ret = read(fd, read_buffer, (size_t)2*len);
	printf("read %d bytes\n", ret);
	printf("read buffer=%s\n", read_buffer);

	/*2. 写一次数据 */
	ret = write(fd, message, len);
	if (ret != len)
		printf("have write %d bytes\n", ret);


	/*3. 再写一次数据 */
	ret = write(fd, message, len);
	if (ret != len)
		printf("have write %d bytes\n", ret);

	/*4. 读取数据，这次因为KFIFO非空，所以可以获得数据 */
	ret = read(fd, read_buffer, 2*len);
	printf("read %d bytes\n", ret);
	printf("read buffer=%s\n", read_buffer);

	close(fd);
}

4.4 Makefile

  • 文件名：linux-stable\my_kmodules\Makefile
  • 如下，继续追加 test_7.o 即可编译出test_7.ko
KDIR := /home/szhou/works/qemu_linux/linux-stable

obj-m := test_1.o test_2.o test_3.o test_4.o  test_5.o test_6.o test_7.o
all :
	$(MAKE) -C $(KDIR) M=$(PWD) modules
clean:
	$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) clean
	rm -f *.ko

五、编译及部署

（1）执行驱动KO编译
szhou@bc01:~/works/qemu_linux/linux-stable/my_kmodules$ make
make -C /home/szhou/works/qemu_linux/linux-stable M=/home/szhou/works/qemu_linux/linux-stable/my_kmodules modules
make[1]: Entering directory '/home/szhou/works/qemu_linux/linux-stable'
  CC [M]  /home/szhou/works/qemu_linux/linux-stable/my_kmodules/test_7.o
  MODPOST /home/szhou/works/qemu_linux/linux-stable/my_kmodules/Module.symvers
  CC [M]  /home/szhou/works/qemu_linux/linux-stable/my_kmodules/test_7.mod.o
  LD [M]  /home/szhou/works/qemu_linux/linux-stable/my_kmodules/test_7.ko
make[1]: Leaving directory '/home/szhou/works/qemu_linux/linux-stable'

（2）执行app编译
szhou@bc01:~/works/qemu_linux/linux-stable/my_kmodules$ arm-linux-gnueabi-gcc app_test_7.c -o app_test_7 --static

（3）将KO和APP存放到NFS共享目录
szhou@bc01:~/works/qemu_linux/linux-stable/my_kmodules$ cp test_7.ko app_test_7  ~/works/nfs_share/
szhou@bc01:~/works/qemu_linux/linux-stable/my_kmodules$

六、运行及测试

（1）启动之前编译组建的QEMU虚拟机
----------------------------------------
Welcome to szhou's tiny Linux
----------------------------------------

Please press Enter to activate this console. 

（2）挂载NFS共享目录
~ #  mount -t nfs -o nolock 192.168.3.67:/home/szhou/works/nfs_share /mnt

（3） 加载ko
~ # cd /mnt/
/mnt # insmod test_7.ko 
test_7: loading out-of-tree module taints kernel.
test_6_init
Minor number = 125
/mnt # mdev  -s

（4） 运行app测试
/mnt # ./app_test_7 
test_6_open: major=10, minor=125
test_6_read 
read -1 bytes
read buffer=
test_6_write 
test_6_write 
have write 48 bytes
test_6_read 
read 128 bytes
read buffer=To test reading and writing FIFO device with O_NONBLOCK.
test_6_release 
/mnt #

操作画面如下图：

在这里插入图片描述

阿迷创客
关注
专栏目录
linux—FIFO的使用与非阻塞标志(O_NONBLOCK)的影响
erlian_beijing的博客
06-30 1万+
FIFO文 #include #include int mkfifo( const char*pathname, mode_t mode); 参数： pathname：FIFO的路径名+文件名。 mode：mode_t类型的权限描述符，同open的参数。 返回值： 成功：返回0 失败：如果文件已经存在，则会出错且返回-1。   操作FIFO文件时的特点： 系统调用的I/
Linux 阻塞和非阻塞I/O
Wu_Being 的CSDN 博客
05-25 812
阻塞操作是指在执行设备操作时，若不能获得资源，则挂起进程直到满足可操作的条件后再进行操作。被挂起的进程进人睡眠状态，被从调度器的运荷队列移走，直到等待的条件被满足。 非阻塞操作的进程在不能进行设备操作时，并不挂起，它要么放弃，要么不停地查询，直至可以进行操作为止。 在阻塞访问时，不能获取资源的进程将进人休眠，它将 CPU 资源“礼让”给其他进程。因为阻塞的进程会进入休眠状态，所以必须确保有个地方能够唤醒休眠的进程，否则，进程就真的“寿终正寝”了。 唤醒进程的地方最大可能发生在中断里面，因为在硬件资源获得的同
Linux 设备驱动--- 阻塞型字符设备驱动 --- O_NONBLOCK --- 非阻塞标志
测试0901-1
12-11 1463
阻塞： 在设计简单字符驱动程序时，要注意一个重要问题. 当一个设备无法立刻满足用户的读写请求时应当如何处理? 例如：调用 read 时没有数据可读，但以后可能会有； 或者一个进程试图向设备写入数据，但是设备暂...
【在Linux世界中追寻伟大的One Piece】五种IO模型和阻塞IO
最新发布
weixin_74809706的博客
09-12 1762
高级IO涉及到文件的IO操作，它包括多种技术，如非阻塞IO、记录锁、IO多路转接、异步IO和存储映射等。这些技术通常依赖于文件描述符(fd)和fcntl函数的支持，用于提高文件IO操作的效率和灵活性。
非阻塞（O_NONBLOCK）
热门推荐
zhulinfeiba的专栏
12-15 2万+
非阻塞I/O使我们的操作要么成功，要么立即返回错误，不被阻塞。 对于一个给定的描述符两种方法对其指定非阻塞I/O: (1)调用open获得描述符，并指定O_NONBLOCK标志 (2)对已经打开的文件描述符，调用fcntl，打开O_NONBLOCK文件状态标志。flags = fcntl( s, F_GETFL, 0 ) )fcntl( s, F_SETFL, flags | O_NONBLO
C语言中的非阻塞（O_NONBLOCK）
lj19990824的博客
09-06 3586
非阻塞I/O使我们的操作要么成功，要么立即返回错误，不被阻塞。 对于一个给定的描述符两种方法对其指定非阻塞I/O: (1)调用open获得描述符，并指定O_NONBLOCK标志 (2)对已经打开的文件描述符，调用fcntl，打开O_NONBLOCK文件状态标志。 flags = fcntl( s, F_GETFL, 0 ) ) fcntl( s, F_SETFL, flags | O_NONBLOCK ) ...
44 设备树 & led
engineer0的博客
03-16 205
驱动源码 dtsled.c #include<linux/module.h> #include<linux/kernel.h> #include<linux/init.h> #include <linux/fs.h> #include<linux/slab.h> #include<linux/io.h> #include<linux/uaccess.h> #include<linux/cdev.h> #inc
TCP服务器IO模型之非阻塞轮询.zip
09-20
非阻塞轮询是实现非阻塞I/O的一种方式，它通过不断地检查连接套接字的就绪状态来确定是否可以进行读写操作。轮询过程中，服务器会遍历所有连接，对于每个连接，检查其是否有数据可读或可写，只有当连接准备就绪时，...
计算机网络------fcntl实现非阻塞IO，dup2实现重定向
sandmm112的博客
06-20 541
        在五种IO模型中有提到在Linux中，默认所有的套接字都是阻塞的。所以要实现非阻塞的套接字，就要执行特定的系统调用来实现。fcntl        函数原型：#include &lt;unistd.h&gt; #include &lt;fcntl.h&gt; int fcntl(int fd, int cmd, ... /* arg */ );         参数说明：fd：表示...
linux非阻塞延时,Linux非阻塞IO（六）使用poll实现非阻塞的服务器端
weixin_35067976的博客
05-15 614
关于poll模型监听的事件以及返回事件，我们定义宏如下：#define kReadEvent (POLLIN | POLLPRI)#define kWriteEvent (POLLOUT | POLLWRBAND)#define kReadREvent (POLLIN | POLLPRI | POLLRDHUP)#define kWriteREvent (POLLOUT)前面我们说明了，为什么非阻...
【pty模块网络编程指南】：构建客户端-服务器交互新境界
!...# 1. pty模块概述 在这篇文章中，我们将深入探讨Python中的`pty`模块。`pty`模块提供了一种创建和操作伪终端的方法，它可以用于各种系统编程任务，特别是在需要模拟终端行为的场景中。通过这个模块，程序员可以...
设置O_NONBLOCK
yongqingjiao的博客
12-08 6837
int evutil_make_socket_nonblocking(evutil_socket_t fd) { #ifdef _WIN32     {         unsigned long nonblocking = 1;         if (ioctlsocket(fd, FIONBIO, &nonblocking) == SOCKET_ERROR) {       
socket编程中的读写函数与非阻塞连接
fengruoying93的专栏
07-28 1168
参考文章:https://blog.csdn.net/A493203176/article/details/65438182https://www.cnblogs.com/eeexu123/p/5275783.html https://blog.csdn.net/nphyez/article/details/10268723 //非阻塞连接 https://www.cnblogs.co...
O_NONBLOCK、O_NDELAY和TCP_NODELAY
weixin_43856737的博客
07-12 1274
O_NONBLOCK和O_NDELAY所产生的结果都是使I/O变成非搁置模式(non-blocking)，在读取不到数据或是写入缓冲区已满会马上return，而不会搁置程序动作，直到有数据或写入完成。 它们的差别在于设立O_NDELAY会使I/O函式马上回传0，但是又衍生出一个问题，因为读取到档案结尾时所回传的也是0，这样无法得知是哪中情况；因此，O_NONBLOCK就产生出来，它在读取不到数据时会回传-1，并且设置errno为EAGAIN。 不过需要注意的是，在GNU C中O_NDELAY只是为了与BSD
非阻塞IO之O_NONBLOCK标志
Wangchaochao0320的博客
08-16 761
转载于:https://www.cnblogs.com/jest549/p/11364983.html
linux中open函数的非阻塞用法
weixin_63546333的博客
07-26 4881
open函数的定义和参数原型如下open函数参数，非阻塞打开文件O_NONBLOCK，open函数详解
使用O_NONBLOCK方式打开设备文件
Decisiveness的专栏
12-28 4877
open函数 #include int open(const char *pathname, int oflag, ... /* mode_t mode */); open函数用来打开或创建一个文件，若成功返回文件描述符，否则返回-1。 pathname是要打开或创建文件的名字。 oflag参数是下列一个或多个常量执行按位或运算的结果杀 O_RDONLY　　只读打开O_WRONLY
linux c fifo阻塞写和非阻塞写,linux—FIFO的使用与非阻塞标志(O_NONBLOCK)的影响
weixin_30410473的博客
05-15 1134
FIFO文#include #include int mkfifo( const char*pathname, mode_t mode);参数：pathname：FIFO的路径名+文件名。mode：mode_t类型的权限描述符，同open的参数。返回值：成功：返回0失败：如果文件已经存在，则会出错且返回-1。操作FIFO文件时的特点：系统调用的I/O函数都可以作用于FIFO，如open、close...
[文件I/O]非阻塞 I/O | O_NONBLOCK
hardworkba的专栏
08-22 2274
[文件I/O]非阻塞 I/O | O_NONBLOCK 转自：http://www.groad.net/bbs/read.php?tid-950.html 系统也可以分为： 低速系统 和 其他。 低速系统调用是可能会使进程永远阻塞的一类系统调用： 如果数据并不存在，则读文件可能会使调用者永远阻塞( 例如读管道，终端设备，网络设备 )如果数据不能被立即接受，则写这些文件同样也会
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿迷创客

感谢！您的支持是我写作的动力~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值