Linux下非阻塞IO实验二

2024-03-12 09:04
文章标签 linux 实验 阻塞 io 下非

本文主要是介绍Linux下非阻塞IO实验二，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一.  简介

前面一篇文章编写Linux驱动代码（轮询函数的实现），来处理 Linux下应用程序以非阻塞方式访问设备。文章地址：

Linux下非阻塞IO实验一-CSDN博客

本文编写另外一种驱动代码实现方式，与上面实现的区别主要是阻塞代码处理部分的不同。

二.   Linux下非阻塞IO实验二

1.  驱动代码实现

本实验在 14_block_io实验的基础上进行的更改。打开 14_block_io工程代码，key_irq.c文件更改后如下：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/timer.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/types.h>
#include <asm/atomic.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <asm/current.h>
#include <linux/poll.h>#define   IRQ_NAME          "key_irq"
#define   IRQ_CNT           1
#define   KEY_NUM           1 
#define   KEY0_VALUE        0x01  //key0按键值
#define   INVAL_KEY_VALUE   0xFF  //无效的按键值static int irq_dev_open(struct inode *inode, struct file *filp);
ssize_t irq_dev_read(struct file * filp, char __user * buf, size_t count, loff_t * ppos);
static unsigned int irq_dev_poll(struct file *file, poll_table * wait);
int irq_dev_close(struct inode * inode, struct file * filp);static const struct file_operations irq_fops = {.open = irq_dev_open,.owner = THIS_MODULE,.read = irq_dev_read,.poll = irq_dev_poll,.release = irq_dev_close, 
};/*key按键结构体 */
struct key_dev{int gpio_number;        //IO编号int interrupt_number;   //中断号unsigned char value;    //键值unsigned char name[50]; //按键名字irqreturn_t (*handler)(int, void*); //中断处理函数
};/*imx6ull_irq设备结构体 */
struct irq_dev{dev_t devid;  //主设备号+次设备号int major; //主设备号int minor; //次设备号struct cdev cdev;struct class* class;struct device* device;struct device_node * dev_node;//设备节点struct key_dev key[KEY_NUM];struct timer_list timer; //定时器atomic_t key_value;      //按键值atomic_t key_release;    //按键释放标志wait_queue_head_t wait_queue_head; //等待队列头
};struct irq_dev irq;/* 打开设备函数*/
static int irq_dev_open(struct inode *inode, struct file *filp)
{filp->private_data = &irq;return 0;
}/*读取数据函数（这里读取按键值） */
ssize_t irq_dev_read(struct file * filp, char __user * buf, size_t count, loff_t * ppos)
{int ret = 0;struct irq_dev* dev = filp->private_data;unsigned char key_release = 0;unsigned char key_value = 0;DECLARE_WAITQUEUE(wait, current); //定义并初始化一个等待队列项//判断是否为非阻塞访问if(filp->f_flags & O_NONBLOCK) //非阻塞访问{if(atomic_read(&dev->key_release) == 0) {return -EAGAIN;}}else //阻塞访问{  /*加入等待队列，使进程进入休眠，等待被唤醒（当按键按下一次即可唤醒）*/add_wait_queue(&dev->wait_queue_head, &wait); //将等待队列项添加到等待队列头set_current_state(TASK_INTERRUPTIBLE); //当前进程设置为可被信号打断状态schedule();  //切换进程状态（进程进入休眠状态）//唤醒以后从这里开始执行if(signal_pending(current)) //判断是否是被信号打断的{ret = -EINVAL;goto signal_break;}set_current_state(TASK_RUNNING); //将进程设置为运行状态remove_wait_queue(&dev->wait_queue_head, &wait); //将队列项从等待队列头移除}key_release = atomic_read(&dev->key_release);key_value = atomic_read(&dev->key_value);if(key_release) //判断按键是否释放{if(key_value&0x80){key_value &= ~(0x80); //去掉标志位ret = copy_to_user(buf, &key_value, sizeof(key_value));if(ret != 0){printk("copy_to_user failed!\n");goto data_error;}}key_release = 0;atomic_set(&dev->key_release, 0);}else{goto data_error;}return ret;signal_break:set_current_state(TASK_RUNNING); //将进程设置为运行状态remove_wait_queue(&dev->wait_queue_head, &wait); //将队列项从等待队列头移除
data_error:return -EINVAL;
}static unsigned int irq_dev_poll(struct file *file, poll_table * wait)
{int mask = 0;struct irq_dev* dev = file->private_data;poll_wait(file, &dev->wait_queue_head, wait);//判断是否可读if(atomic_read(&dev->key_release)){mask = POLLIN | POLLRDNORM;}return mask;
}/* 关闭设备函数 */
int irq_dev_close(struct inode * inode, struct file * filp)
{return 0;
}/*定时器处理函数：对按键进行消抖处理 */
void timer_handler(unsigned long data)
{int value = 0;struct irq_dev* dev = (struct irq_dev*)data;//读取按键值value = gpio_get_value(dev->key[0].gpio_number);if(value == 0) //按键按下{// printk("KEY0 Press!\n");atomic_set(&dev->key_value, dev->key[0].value);}else if(value == 1) //按键释放{// printk("KEY0 Release!\n");//按键值最高位置1，打上标志atomic_set(&dev->key_value, (0x80|dev->key[0].value));atomic_set(&dev->key_release, 1); //一次完整的按键标志}/*按键有效时，唤醒进入休眠状态的进程 */ if(atomic_read(&dev->key_release)) //完成一次按键过程{wake_up(&dev->wait_queue_head);} 
}/* 中断处理函数 */
static irqreturn_t key0_irq_handler(int irq, void *param)
{struct irq_dev* dev = param;dev->timer.data = (volatile unsigned long)param;//设置定时器超时时间，开启定时器mod_timer(&dev->timer, jiffies + msecs_to_jiffies(20)); //按键按下后延时20msreturn IRQ_HANDLED;
}/*按键初始化 */
static int key_io_init(struct irq_dev* dev)
{int ret = 0;int i = 0;int n = 0;/*1.获取设备节点 */dev->dev_node = of_find_node_by_path("/key");if(NULL == dev->dev_node){printk("find dev_node failed!\n");goto find_dev_node;}/*2.获取IO编号 */for(i=0; i< KEY_NUM; i++){   dev->key[i].gpio_number = of_get_named_gpio(dev->dev_node, "key-gpio", i);if(dev->key[i].gpio_number < 0){printk("get gpio number failed!\n");goto get_gpio_number;}}/*3.申请IO */for(i = 0; i< KEY_NUM; i++){memset(dev->key[i].name, 0, sizeof(dev->key[i].name));sprintf(dev->key[i].name, "KEY%d", i);ret = gpio_request(dev->key[i].gpio_number, dev->key[i].name);if(ret != 0){printk("gpio request fail!\n");goto gpio_request;}/* 将GPIO设置为输入*/gpio_direction_input(dev->key[i].gpio_number);/* 获取中断号*/dev->key[i].interrupt_number = gpio_to_irq(dev->key[i].gpio_number);if(!dev->key[i].interrupt_number){printk("irq_of_parse_and_map fail!\n");goto get_irq_number;}}dev->key[0].handler = key0_irq_handler;dev->key[0].value = KEY0_VALUE;/*申请中断 */for(i=0; i<KEY_NUM; i++){ret = request_irq(dev->key[i].interrupt_number, dev->key[i].handler, (IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING), dev->key[i].name, dev);  printk("request_irq ret: %d\n", ret);if(ret != 0){printk("%d request interrupt fail!\n", i);goto irq_request;}                     }/*定时器初始化 */init_timer(&dev->timer);dev->timer.function = timer_handler;return 0;irq_request:
get_irq_number:for(i=0; i<KEY_NUM; i++){gpio_free(dev->key[i].gpio_number);}
gpio_request:for(n = 0; n<i; n++){gpio_free(dev->key[n].gpio_number);}
get_gpio_number:
find_dev_node:return ret;
}/*驱动入口函数 */
static int __init imx6ull_irq_init(void)
{int ret = 0;/*1. 注册/申请设备号 */irq.major = 0;  if(irq.major) //如果给出主设备号，则注册设备号{irq.devid = MKDEV(irq.major, 0);ret = register_chrdev_region(irq.devid, IRQ_CNT, IRQ_NAME);	}else //否则申请设备号{ret = alloc_chrdev_region(&irq.devid, 0, IRQ_CNT, IRQ_NAME);irq.major = MAJOR(irq.devid);irq.minor = MINOR(irq.devid);}if(ret < 0){printk("devid apply failed!\n");goto devid_failed;}printk("dev: major: %d minor: %d\n", irq.major,irq.minor);/*2. 设备初始化，添加设备*/irq.cdev.owner = THIS_MODULE;cdev_init(&irq.cdev, &irq_fops);ret = cdev_add(&irq.cdev, irq.devid, IRQ_CNT);if(ret < 0){printk("cdev_add failed!\n");goto cdev_init_failed;}/*3. 自动创建设备节点 */irq.class = class_create(THIS_MODULE, IRQ_NAME);if(IS_ERR(irq.class)){printk(KERN_ERR "class_create failed!\n");ret = PTR_ERR(irq.class);goto class_create_failed;}irq.device = device_create(irq.class, NULL, irq.devid, NULL, IRQ_NAME);if (IS_ERR(irq.device)) {printk(KERN_ERR "device_create failed!\n");ret = PTR_ERR(irq.device);goto device_create_failed;}/*4. 按键初始化*/ret = key_io_init(&irq);if(ret != 0){printk("key_io_init failed!\n");goto key_io_init_failed;}/*初始原子变量*/atomic_set(&irq.key_value, INVAL_KEY_VALUE);atomic_set(&irq.key_release, 0); /*初始化等待队列头 */init_waitqueue_head(&irq.wait_queue_head);return 0;key_io_init_failed:device_destroy(irq.class, irq.devid);
device_create_failed:class_destroy(irq.class);
class_create_failed:cdev_del(&irq.cdev);
cdev_init_failed: unregister_chrdev_region(irq.devid, IRQ_CNT);
devid_failed:return ret;
}/*驱动出口函数 */
static void __exit imx6ull_irq_exit(void)
{int i = 0;/*删除定时器 */del_timer(&irq.timer);/*释放中断 */for(i=0; i < KEY_NUM; i++){free_irq(irq.key[i].interrupt_number, &irq);}/*释放GPIO编号 */for(i=0; i < KEY_NUM; i++){gpio_free(irq.key[i].gpio_number);}/*2. 删除设备 */cdev_del(&irq.cdev);/*3. 注销设备号*/unregister_chrdev_region(irq.devid, IRQ_CNT);/*4. 销毁设备 & 类*/device_destroy(irq.class, irq.devid);class_destroy(irq.class);
}/*驱动入口与出口函数 */
module_init(imx6ull_irq_init);
module_exit(imx6ull_irq_exit);
MODULE_LICENSE("GPL"); //驱动 License
MODULE_AUTHOR("WeiYing"); //作者

2.  驱动编译

对以上驱动代码进行模块编译：

wangtian@wangtian-virtual-machine:~/zhengdian_Linux/Linux_Drivers/14_non_block_io$ make 
make -C /home/wangtian/zhengdian_Linux/linux/kernel/linux-imx-rel_imx_4.1.15_2.1.0_ga M=/home/wangtian/zhengdian_Linux/Linux_Drivers/14_non_block_io modules
make[1]: 进入目录“/home/wangtian/zhengdian_Linux/linux/kernel/linux-imx-rel_imx_4.1.15_2.1.0_ga”CC [M]  /home/wangtian/zhengdian_Linux/Linux_Drivers/14_non_block_io/key_irq.oBuilding modules, stage 2.MODPOST 1 modulesCC      /home/wangtian/zhengdian_Linux/Linux_Drivers/14_non_block_io/key_irq.mod.oLD [M]  /home/wangtian/zhengdian_Linux/Linux_Drivers/14_non_block_io/key_irq.ko
make[1]: 离开目录“/home/wangtian/zhengdian_Linux/linux/kernel/linux-imx-rel_imx_4.1.15_2.1.0_ga”
wangtian@wangtian-virtual-machine:~/zhengdian_Linux/Linux_Drivers/14_non_block_io$

可以看出，驱动模块可以正常编译。

三.  驱动模块加载测试

这里可以测试两种访问功能，阻塞访问与非阻塞访问设备。

1.  阻塞访问测试

阻塞访问测试时，这里所使用的应用程序为 前面阻塞实验使用的应用程序。应用程序如下：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>/*
*测试按键是否按下
* 运行命令： ./irqpp /dev/key_irq
*/int main(int argc, char* argv[])
{int ret = 0;int fd = 0;char * device_name = NULL;int key_value = 0;if(argc != 2){printf("main's param number error!\n");return -1;}device_name = argv[1];fd = open(device_name, O_RDWR);if(fd < 0){printf("open led device failed!\n");return -1;}while(1){ret = read(fd, &key_value, sizeof(key_value));if(ret >= 0){if(key_value){printf("Key0 Press!\n");}}}return 0;
}

测试方法可以参考如下：

Linux下阻塞IO驱动实验三的测试-CSDN博客

2. 非阻塞访问测试

非阻塞访问测试时，这里所使用的应用程序为 前面非阻塞实验使用的应用程序。

#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>/*
*测试按键是否按下
* 运行命令： ./irqpp /dev/key_irq
*/int main(int argc, char* argv[])
{int ret = 0;int fd = 0;char * device_name = NULL;int key_value = 0;fd_set readfds; /*读操作文件描述符集 */struct timeval timeout;if(argc != 2){printf("main's param number error!\n");return -1;}device_name = argv[1];fd = open(device_name, O_RDWR | O_NONBLOCK); //非阻塞式访问if(fd < 0){printf("open led device failed!\n");return -1;}while(1){FD_ZERO(&readfds);    //清 readfds读操作文件描述符集FD_SET(fd, &readfds); //将 fd添加到 readfds中timeout.tv_sec = 1; //设置超时为 1stimeout.tv_usec = 0;ret = select((fd+1), &readfds, NULL, NULL, &timeout);switch (ret){case 0:  //超时printf("select time_out!\n");break;case -1:  //出错printf("select error!\n");break;default: //有可变的操作符if(FD_ISSET(fd, &readfds)) //判断是否是 fd可读{ret = read(fd, &key_value, sizeof(key_value));if(ret >= 0){if(key_value){printf("Key0 Press!\n");}}}break;}}return 0;
}

测试方法可以参考如下：

Linux下非阻塞IO实验一：测试-CSDN博客

总结：

这里驱动实现上，阻塞部分的处理上，与前面一篇 "非阻塞IO实验一" 的代码相比，这里使用了等待队列项，所以，比较繁琐。不过也是一种实现方式。

这篇关于Linux下非阻塞IO实验二的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/800760。

相关文章

Linux使用nload监控网络流量的方法

Linux使用nload监控网络流量的方法

《Linux使用nload监控网络流量的方法》Linux中的nload命令是一个用于实时监控网络流量的工具,它提供了传入和传出流量的可视化表示,帮助用户一目了然地了解网络活动,本文给大家介绍了Linu... 目录简介安装示例用法基础用法指定网络接口限制显示特定流量类型指定刷新率设置流量速率的显示单位监控多个
阅读更多...
ElasticSearch+Kibana通过Docker部署到Linux服务器中操作方法

ElasticSearch+Kibana通过Docker部署到Linux服务器中操作方法

《ElasticSearch+Kibana通过Docker部署到Linux服务器中操作方法》本文介绍了Elasticsearch的基本概念,包括文档和字段、索引和映射,还详细描述了如何通过Docker... 目录1、ElasticSearch概念2、ElasticSearch、Kibana和IK分词器部署
阅读更多...
Linux流媒体服务器部署流程

Linux流媒体服务器部署流程

《Linux流媒体服务器部署流程》文章详细介绍了流媒体服务器的部署步骤,包括更新系统、安装依赖组件、编译安装Nginx和RTMP模块、配置Nginx和FFmpeg,以及测试流媒体服务器的搭建... 目录流媒体服务器部署部署安装1.更新系统2.安装依赖组件3.解压4.编译安装（添加RTMP和openssl模块
阅读更多...
linux下多个硬盘划分到同一挂载点问题

linux下多个硬盘划分到同一挂载点问题

《linux下多个硬盘划分到同一挂载点问题》在Linux系统中,将多个硬盘划分到同一挂载点需要通过逻辑卷管理（LVM）来实现,首先,需要将物理存储设备（如硬盘分区）创建为物理卷,然后,将这些物理卷组成... 目录linux下多个硬盘划分到同一挂载点需要明确的几个概念硬盘插上默认的是非lvm总结Linux下多
阅读更多...
linux进程D状态的解决思路分享

linux进程D状态的解决思路分享

《linux进程D状态的解决思路分享》在Linux系统中,进程在内核模式下等待I/O完成时会进入不间断睡眠状态（D状态）,这种状态下,进程无法通过普通方式被杀死,本文通过实验模拟了这种状态,并分析了如... 目录1. 问题描述2. 问题分析3. 实验模拟3.1 使用losetup创建一个卷作为pv的磁盘3.
阅读更多...
Linux环境变量&&进程地址空间详解

Linux环境变量&&进程地址空间详解

《Linux环境变量&&进程地址空间详解》本文介绍了Linux环境变量、命令行参数、进程地址空间以及Linux内核进程调度队列的相关知识,环境变量是系统运行环境的参数,命令行参数用于传递给程序的参数,... 目录一、初步认识环境变量1.1常见的环境变量1.2环境变量的基本概念二、命令行参数2.1通过命令编程
阅读更多...
Linux之进程状态&&进程优先级详解

Linux之进程状态&&进程优先级详解

《Linux之进程状态&&进程优先级详解》文章介绍了操作系统中进程的状态,包括运行状态、阻塞状态和挂起状态,并详细解释了Linux下进程的具体状态及其管理,此外,文章还讨论了进程的优先级、查看和修改进... 目录一、操作系统的进程状态1.1运行状态1.2阻塞状态1.3挂起二、linux下具体的状态三、进程的
阅读更多...
Linux编译器--gcc/g++使用方式

Linux编译器--gcc/g++使用方式

《Linux编译器--gcc/g++使用方式》文章主要介绍了C/C++程序的编译过程,包括预编译、编译、汇编和链接四个阶段,并详细解释了每个阶段的作用和具体操作,同时,还介绍了调试和发布版本的概念... 目录一、预编译指令1.1预处理功能1.2指令1.3问题扩展二、编译（生成汇编）三、汇编（生成二进制机器语
阅读更多...
Rsnapshot怎么用? 基于Rsync的强大Linux备份工具使用指南

Rsnapshot怎么用? 基于Rsync的强大Linux备份工具使用指南

《Rsnapshot怎么用?基于Rsync的强大Linux备份工具使用指南》Rsnapshot不仅可以备份本地文件，还能通过SSH备份远程文件，接下来详细介绍如何安装、配置和使用Rsnaps... Rsnapshot 是一款开源的文件系统快照工具。它结合了 Rsync 和 SSH 的能力，可以帮助你在 li
阅读更多...
解读Redis秒杀优化方案(阻塞队列+基于Stream流的消息队列)

解读Redis秒杀优化方案(阻塞队列+基于Stream流的消息队列)

《解读Redis秒杀优化方案(阻塞队列+基于Stream流的消息队列)》该文章介绍了使用Redis的阻塞队列和Stream流的消息队列来优化秒杀系统的方案,通过将秒杀流程拆分为两条流水线,使用Redi... 目录Redis秒杀优化方案(阻塞队列+Stream流的消息队列)什么是消息队列？消费者组的工作方式每
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2