字符设备驱动第八课----异步通知（信号驱动IO）

2024-05-09 20:08
文章标签 驱动 异步 设备 信号 字符 io 通知 第八课

本文主要是介绍字符设备驱动第八课----异步通知（信号驱动IO），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

概述

类比运用程序中的kill-----signal，在运用程序中常常一个进程用kill(pid，sig)向另一
进程发信号，另一个进程用signal(sig,handler)绑定相应的处理函数，实现了异步通知。今天要讲的就是：运用程序要读，但它并不知道啥时候有东西可读，用read（）
阻塞去读显然效率不高，read()配合IO多路复用非阻塞一直在那里轮询的话效率也不好。
这里采用的办法是：驱动层有数据可读的时候kill一个SIGIO信号给运用层，
运用层收到SIGIO信号后调用预先绑定好的处理函数把数据读走。

若还迷糊概念，请看看这位大神的清晰讲解:
信号驱动IO与异步通知

<include/linux/fs.h>struct file_operations {int (*open) (struct inode *, struct file *);int (*flush) (struct file *, fl_owner_t id);int (*release) (struct inode *, struct file *);int (*fsync) (struct file *, loff_t, loff_t, int datasync);       //用于异步通知...
}
<include/linux/fs.h>struct fasync_struct {spinlock_t      fa_lock;int         magic;int         fa_fd;struct fasync_struct    *fa_next; /* singly linked list */struct file     *fa_file;struct rcu_head     fa_rcu;
};

/*
* 功能： 得到异步通知结构。根据mod,将异步通知结构体加入链表
* 运用程序端调用这些函数改变标志和owner时就调用了这个底层实现。
*    fcntl(STDIN_FILENO,F_SETOWN,getpid());
*    oflags = fcntl(STDIN_FILENO,F_GETFL);
*    fctcl(STDIN_FILENO,F_SETFL,oflags | FASYNC);
* 输入参数:  fd:             文件描述符
*          filp：          file结构体指针
* 输出参数：fapp：得到的异步通知结构体          
*/
int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)

/** 功能：通过异步通知结构发信号，此信号发出时运用端就会收到SGIO信号，就会回调预先绑定的处理函数。* 参数：struct fasync_struct **fp:  异步通知结构*      int signo:                  信号（SIGIO）*      int events:                 事件：POLLIN、POLLOUT*/
void kill_fasync(struct fasync_struct **fp, int sig, int band)

范例：

1.驱动端：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/errno.h>#include <asm/current.h>
#include <linux/sched.h>#include <linux/uaccess.h>
#include <linux/poll.h>#include <asm/atomic.h>
#include <linux/mutex.h>#include <linux/wait.h>#include <linux/device.h>
static struct class *cls = NULL;static int major = 0;
static int minor = 0;
const  int count = 6;#define DEVNAME "demo"static struct cdev *demop = NULL;
static atomic_t tv;
static wait_queue_head_t wq;static struct fasync_struct *fasync = NULL;//定义异步通知结构体#define KMAX 1024
static char kbuf[KMAX];
static int counter = 0;//打开设备
static int demo_open(struct inode *inode, struct file *filp)
{//get major and minor from inodeprintk(KERN_INFO "(major=%d, minor=%d), %s : %s : %d\n",imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);if(!atomic_dec_and_test(&tv)){atomic_inc(&tv);return -EBUSY;}memset(kbuf, 0, KMAX);counter = 0;return 0;
}//关闭设备
static int demo_release(struct inode *inode, struct file *filp)
{//get major and minor from inodeprintk(KERN_INFO "(major=%d, minor=%d), %s : %s : %d\n",imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);atomic_inc(&tv);return 0;
}//读设备
//ssize_t read(int fd, void *buf, size_t count)
static ssize_t demo_read(struct file *filp, char __user *buf, size_t size, loff_t *offset)
{int err = 0;struct inode *inode = filp->f_path.dentry->d_inode;  //获取文件的inod号//get major and minor from inodeprintk(KERN_INFO "(major=%d, minor=%d), %s : %s : %d\n",imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);if(!counter){if(filp->f_flags & O_NONBLOCK){return -EAGAIN;}err = wait_event_interruptible(wq, (0 != counter));//睡在条件上的等待队列if(err){                                            //没东西可读，睡return err;}}if(counter < size){size = counter;}if(copy_to_user(buf, kbuf, size)){return -EAGAIN;}counter = 0;return size;
}//写设备
static ssize_t demo_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{struct inode *inode = filp->f_path.dentry->d_inode;//get major and minor from inodeprintk(KERN_INFO "(major=%d, minor=%d), %s : %s : %d\n",imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);if(size > KMAX){return -ENOMEM;}if(copy_from_user(kbuf, buf, size)){return -EAGAIN;}counter = size;wake_up_interruptible(&wq);//广播唤醒等待队列kill_fasync(&fasync, SIGIO, POLLIN);//向fasync结构体发信号,//与fasync关联的进程(通过fcntl(...,pid)系列函数关联)就会收到SIGIO信号return size;
}/* IO多路复用支持*/
static unsigned int demo_poll(struct file *filp, struct poll_table_struct *pts)
{unsigned int mask = 0;struct inode *inode = filp->f_path.dentry->d_inode;//get major and minor from inodeprintk(KERN_INFO "(major=%d, minor=%d), %s : %s : %d\n",imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);poll_wait(filp, &wq, pts);//io多路复用支持,只有等待队列中有就绪的事件才会往下走，否则阻塞if(counter){mask = (POLLIN | POLLRDNORM);//返回，告诉运用层的poll函数：就绪事件是输入事件}return mask;
}/*异步通知接口函数，应用层调fcntl()时调到此函数*/
static int demo_fasync(int fd, struct file *filp, int mode)
{struct inode *inode = filp->f_path.dentry->d_inode;//get major and minor from inodeprintk(KERN_INFO "(major=%d, minor=%d), %s : %s : %d\n",imajor(inode), iminor(inode), __FILE__, __func__, __LINE__);return fasync_helper(fd, filp, mode, &fasync);//根据mod,将异步通知结构体加入链表//或者从链表中移除。得到信息并填充到fasync结构体中
}static struct file_operations fops = {.owner  = THIS_MODULE,.open   = demo_open,.release= demo_release,.read   = demo_read,.write  = demo_write,.poll   = demo_poll,.fasync = demo_fasync,
};static int __init demo_init(void)
{dev_t devnum;int ret, i;struct device *devp = NULL;//get command and pidprintk(KERN_INFO "(%s:pid=%d), %s : %s : %d\n",current->comm, current->pid, __FILE__, __func__, __LINE__);//1. alloc cdev objdemop = cdev_alloc();if(NULL == demop){return -ENOMEM;}//2. init cdev objcdev_init(demop, &fops);ret = alloc_chrdev_region(&devnum, minor, count, DEVNAME);if(ret){goto ERR_STEP;}major = MAJOR(devnum);//3. register cdev objret = cdev_add(demop, devnum, count);if(ret){goto ERR_STEP1;}cls = class_create(THIS_MODULE, DEVNAME);if(IS_ERR(cls)){ret = PTR_ERR(cls);goto ERR_STEP1;}for(i = minor; i < (count+minor); i++){devp = device_create(cls, NULL, MKDEV(major, i), NULL, "%s%d", DEVNAME, i);if(IS_ERR(devp)){ret = PTR_ERR(devp);goto ERR_STEP2;}}// init atomic_tatomic_set(&tv, 1);init_waitqueue_head(&wq);//初始化等待队列//get command and pidprintk(KERN_INFO "(%s:pid=%d), %s : %s : %d - ok.\n",current->comm, current->pid, __FILE__, __func__, __LINE__);return 0;ERR_STEP2:for(--i; i >= minor; i--){device_destroy(cls, MKDEV(major, i));}class_destroy(cls);ERR_STEP1:unregister_chrdev_region(devnum, count);ERR_STEP:cdev_del(demop);//get command and pidprintk(KERN_INFO "(%s:pid=%d), %s : %s : %d - fail.\n",current->comm, current->pid, __FILE__, __func__, __LINE__);return ret;
}static void __exit demo_exit(void)
{int i;//get command and pidprintk(KERN_INFO "(%s:pid=%d), %s : %s : %d - leave.\n",current->comm, current->pid, __FILE__, __func__, __LINE__);for(i=minor; i < (count+minor); i++){device_destroy(cls, MKDEV(major, i));}class_destroy(cls);unregister_chrdev_region(MKDEV(major, minor), count);cdev_del(demop);
}module_init(demo_init);
module_exit(demo_exit);MODULE_LICENSE("GPL");
MODULE_AUTHOR("Farsight");
MODULE_DESCRIPTION("Demo for kernel module");

2.运用程序端：

#include <stdio.h>
#include <string.h>#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>#include <poll.h>
#include <signal.h>#include <errno.h>int fd = -1;void handler(int sig)//信号处理函数，与signal绑定的
{struct pollfd pfd = {.fd = fd,.events = POLLIN,};int ret = poll(&pfd, 1, ~0);//监控pfd，最大文件描述符1，永不超时if(0 >= ret){               //没一个就绪则阻塞，只要其中有任意一个就绪就往下走perror("poll");return;}#define MAX 1024char buf[MAX];memset(buf, 0, MAX); if(0 > read(fd, buf, MAX)){perror("read");}else{printf("RD: %s\n", buf);}
}int main(int num, char *argv[])
{if(2 != num){printf("Usage: %s /dev/devfile\n", argv[0]);return -1;}fd = open(argv[1], O_RDWR|O_NONBLOCK);if(0 > fd){printf("pid = %d, %s\n", getpid(), (char *)strerror(errno));return -1;}signal(SIGIO, handler);//绑定信号处理函数fcntl(fd, F_SETOWN, getpid());//关联收发，设置对应文件的拥有者是本进程，这样接下来才能进行信号的收发int flag = fcntl(fd, F_GETFL);//读取对应文件描述符上的flg信息flag  |= O_ASYNC;fcntl(fd, F_SETFL, flag);     //设置对应文件描述符上的flg信息,使其支持异步通知//这个函数实质上最终调用的是操作方法集中的.fasync标准接口，对应到驱动层中的相应函数while(1){printf("---------w: 1----------\n");#define MAX 1024char buf[MAX];fgets(buf, MAX, stdin);         write(fd, buf, strlen(buf));}close(fd);return 0;
}

这篇关于字符设备驱动第八课----异步通知（信号驱动IO）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


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

相关文章

Linux_kernel驱动开发11

Linux_kernel驱动开发11

一、改回nfs方式挂载根文件系统         在产品将要上线之前，需要制作不同类型格式的根文件系统         在产品研发阶段，我们还是需要使用nfs的方式挂载根文件系统         优点：可以直接在上位机中修改文件系统内容，延长EMMC的寿命         【1】重启上位机nfs服务         sudo service nfs-kernel-server resta
阅读更多...
如何编写Linux PCIe设备驱动器 之二

如何编写Linux PCIe设备驱动器 之二

如何编写Linux PCIe设备驱动器 之二 功能(capability)集功能(capability)APIs通过pci_bus_read_config完成功能存取功能APIs参数pos常量值PCI功能结构 PCI功能IDMSI功能电源功率管理功能 功能(capability)集 功能(capability)APIs int pcie_capability_read_wo
阅读更多...
js异步提交form表单的解决方案

js异步提交form表单的解决方案

1.定义异步提交表单的方法 （通用方法） /*** 异步提交form表单* @param options {form:form表单元素,success:执行成功后处理函数}* <span style="color:#ff0000;"><strong>@注意 后台接收参数要解码否则中文会导致乱码 如：URLDecoder.decode(param,"UTF-8")</strong></span>
阅读更多...
Java IO 操作——个人理解

Java IO 操作——个人理解

之前一直Java的IO操作一知半解。今天看到一个便文章觉得很有道理（ 原文章），记录一下。 首先，理解Java的IO操作到底操作的什么内容，过程又是怎么样子。          数据来源的操作： 来源有文件，网络数据。使用File类和Sockets等。这里操作的是数据本身，1,0结构。    File file = new File("path");   字
阅读更多...
springboot体会BIO（阻塞式IO）

springboot体会BIO（阻塞式IO）

使用springboot体会阻塞式IO 大致的思路为： 创建一个socket服务端，监听socket通道，并打印出socket通道中的内容。 创建两个socket客户端，向socket服务端写入消息。 1.创建服务端 public class RedisServer {public static void main(String[] args) throws IOException {
阅读更多...
Java基础回顾系列-第七天-高级编程之IO

Java基础回顾系列-第七天-高级编程之IO

Java基础回顾系列-第七天-高级编程之IO 文件操作字节流与字符流OutputStream字节输出流FileOutputStream InputStream字节输入流FileInputStream Writer字符输出流FileWriter Reader字符输入流字节流与字符流的区别转换流InputStreamReaderOutputStreamWriter 文件复制 字符编码内存操作流(
阅读更多...
string字符会调用new分配堆内存吗

string字符会调用new分配堆内存吗

gcc的string默认大小是32个字节，字符串小于等于15直接保存在栈上，超过之后才会使用new分配。
阅读更多...
如何将一个文件里不包含某个字符的行输出到另一个文件？

如何将一个文件里不包含某个字符的行输出到另一个文件？

第一种： grep -v 'string' filename > newfilenamegrep -v 'string' filename >> newfilename 第二种： sed -n '/string/!'p filename > newfilenamesed -n '/string/!'p filename >> newfilename
阅读更多...
列举你能想到的UNIX信号，并说明信号用途

列举你能想到的UNIX信号，并说明信号用途

信号是一种软中断，是一种处理异步事件的方法。一般来说，操作系统都支持许多信号。尤其是UNIX，比较重要应用程序一般都会处理信号。 UNIX定义了许多信号，比如SIGINT表示中断字符信号，也就是Ctrl+C的信号，SIGBUS表示硬件故障的信号；SIGCHLD表示子进程状态改变信号；SIGKILL表示终止程序运行的信号，等等。信号量编程是UNIX下非常重要的一种技术。 Unix信号量也可以
阅读更多...
android java.io.IOException: open failed: ENOENT (No such file or directory)-api23+权限受权

android java.io.IOException: open failed: ENOENT (No such file or directory)-api23+权限受权

问题描述 在安卓上，清单明明已经受权了读写文件权限，但偏偏就是创建不了目录和文件 调用mkdirs()总是返回false. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/><uses-permission android:name="android.permission.READ_E
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2