字符设备驱动(8)-信号驱动，又名异步通知

已于 2024-08-28 19:57:17 修改
阅读量745 收藏 17
点赞数 24
分类专栏： linux驱动 文章标签： linux 驱动开发
于 2024-08-24 12:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40896451/article/details/141283047
版权

        在前面的I/O模型中，用户态程序都是主动获取设备的资源信息，而异步通知是当设备资源可用时，有驱动主动通知用户态程序，在由用户态程序发起读写操作。这种机制和中断非常相似，可以借用中断的思路来理解这一过程。

用户态程序

         如上图，用户态程序的一般步骤是：

        （1）注册信号处理函数

        （2）设置设备文件的属主。为啥要设置属主呢？因为我们知道linux系统中，进程有单独的用户态空间，但所有的进程共享内核态空间，若不设置属主，驱动就不知道向哪个进程发送信号，所以这一步的目的是是使驱动根据文件的file结构，找到对应的进程，从而向该进程发送信号。

        （3）设置当设备资源可用时设备驱动向进程发出的信号，这一步不是必须的，但如果要使用sigaction的高级特性，这步就需要。

        （4）设置信号驱动标记，即一步通过fcntl的F_SETFL完成，设置FASYNC标记，这才真正启用异步通知机制，相当于中断使能。

#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
 
#define FILE_NAME "/dev/mydev"
#define MAX_LEN   64
 
int fd;

void myhandler(int arg)
{
    int rlen;		
    char rbuf[MAX_LEN] = {0};

    rlen = read(fd, rbuf, 10);
    if (rlen < 0)
    {
    	perror("Read error");
    	return;
    }
    printf("Read buf is %s\n", rbuf);
}

int main(void)
{
    int ret,wlen,rlen,flag; 
    char wbuf[MAX_LEN] = "abcdefg";
    char rbuf[MAX_LEN] = {0};
    int i = 0;

    //注意以非阻塞方式打开文件
    fd = open(FILE_NAME, O_RDWR);
    if (0 > fd) 
    {   
        printf("Open failed.\n");
        return -1; 
    }   
     
    signal(SIGIO, myhandler);

    ret = fcntl(fd, F_SETOWN, getpid());
    if (0 > ret)
    {
        perror("Set owner");
		return ret;
	}
				
    flag = fcntl(fd, F_GETFL);
    if (0 > flag)
	{
		perror("Get flag");
		return ret;
	}

    ret = fcntl(fd, F_SETFL, flag | FASYNC);
    if (0 > ret)
	{
		perror("Set flag");
		return ret;
	}

    wlen = write(fd, wbuf, strlen(wbuf));
    if (wlen < 0)
    {
    	perror("Write error");
    	return wlen;
    }
    printf("Write buf is %s\n", wbuf);

    while (1) 
    {   
        
    }
    close(fd);
    return 0;
}

驱动程序

        进程设置异步通知标记时，要调用驱动的fasync方法，以便把这个变化通知驱动程序，使其能正确响应。文件被打开时，FASYNC标记默认是被清除的，我们要手动设置。

struct file_operations {
    int (*fasync) (int, struct file *, int);
}

        第一个参数是文件描述符。

        第二个参数是文件指针。

        第三个参数是添加或者删除标记。

        内核帮我们封装了一个函数fasync_helper函数，这个函数会构造fasync_struct节点，加入并假如到它的头中，函数原型如下：

int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)

        fasync的3个参数透传给fasync_helper函数，fasync_helper最后一个参数fasync_struct的二级指针，这里只需要传入fasync_struct的指针就行。

        当驱动准备好资源时，就执行kill_fasync函数通知用户态程序异步读取数据。

void kill_fasync(struct fasync_struct **fp, int sig, int band)

        第一个参数是和传入fasync_helper的同一个参数。

        第二个参数是信号ID，比如SIGIO。

        第三个参数是读出或者写入的标记，如POLL_IN、POLL_OUT。

        最后，当文件关闭时，需要显示调用驱动实现的fasync接口函数，将节点从链表中移除，这样进程就不会再收到信号。

关键程序如下：

//异步结构定义
struct fasync_struct *my_fapp;

static int my_fasync(int fd, struct file *flip, int mode);

static int my_close(struct inode *pnode, struct file *pfile)
{
    printk("Close cdev.\n");
    my_fasync(-1, pfile, 0);
    return 0;
}

//异步初始化
static int my_fasync(int fd, struct file *flip, int mode)
{
    return fasync_helper(fd, flip, mode, &my_fapp);
}

ssize_t my_read(struct file *pf, char __user *ubuf, size_t len, loff_t *pl)
{
	int ret = -1;
    if (MAX_LEN < len)
    {
        printk("len is large than %d.\n", MAX_LEN);
		return -1;
	}
	
    //判断设备缓存是否为空
    if (0 == kbuf_len)
	{
        //如果是非阻塞操作,返回-EAGAIN,用户态轮询
		if (pf->f_flags& O_NONBLOCK)
			return -EAGAIN;
        else
        {
            //如果是阻塞操作，等待
            if (wait_event_interruptible(my_read_queue, 0!= kbuf_len))
                return -ERESTARTSYS; //信号唤醒，通知文件系统层做相应处理
        }
	}
 
	ret =  copy_to_user(ubuf, kbuf, len);
    if (0 != ret)
    {   
        printk("Copy to user failed.\n");
        return -1;
    }
    
    //读出后，把对应的设备数据清空，保留未读出数据
    memcpy(kbuf, kbuf + len, MAX_LEN - len);
    memset(kbuf + MAX_LEN - len, 0, len);
 
    //计算设备缓存长度
    if (kbuf_len > len)
    	kbuf_len -= len;
    else
        kbuf_len = 0; 
    
    //当缓存长度不满时，唤醒写队列
    if (MAX_LEN != kbuf_len)
    {
        wake_up_interruptible(&my_write_queue);
        //发送可写通知
        kill_fasync(&my_fapp, SIGIO, POLL_OUT);
    }
	return len;
}
 
ssize_t my_write(struct file *pf, const char __user *ubuf, size_t len, loff_t *pl)
{
	int ret = -1;
 
    //判断是否会写超过
    if (MAX_LEN < len + kbuf_len)
	{
        printk("len is large than %d.\n", MAX_LEN);
		return -1;
	}
	
	if (MAX_LEN == kbuf_len)
	{
        //如果是非阻塞操作,返回-EAGAIN,用户态轮询
		if (pf->f_flags& O_NONBLOCK)
			return -EAGAIN;
        else
        {
            //如果是阻塞操作，等待
            if (wait_event_interruptible(my_write_queue, MAX_LEN != kbuf_len))
                return -ERESTARTSYS; //信号唤醒，通知文件系统层做相应处理
        }
	}
    
    ret = copy_from_user(kbuf + kbuf_len, ubuf, len);
    if (0 != ret)
    {   
        printk("Copy from user failed.\n");
        return -1;
    }
    kbuf_len += len;
    
    //当缓存长度不为空时，唤醒读队列
    if (0 != kbuf_len)
    {
        wake_up_interruptible(&my_read_queue);
        //发送可读通知
        kill_fasync(&my_fapp, SIGIO, POLL_IN);
    }
    return len;
}

struct file_operations cdev_ops = {
    .open    = my_open,
    .release = my_close,
    .read    = my_read,
    .write   = my_write,
    .poll    = my_poll,
    .fasync  = my_fasync,
};

完整驱动程序

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/string.h>
#include <linux/wait.h>
#include <linux/poll.h>

#define MAJOR_CHAR 100
#define MINOR_CHAR 0
#define MAX_LEN    64 


//异步结构定义
struct fasync_struct *my_fapp;
static int my_fasync(int fd, struct file *flip, int mode);
 
static int my_open(struct inode *pnode, struct file *pfile)
{
    printk("Open cdev.\n");
    return 0;
}
 
static int my_close(struct inode *pnode, struct file *pfile)
{
    printk("Close cdev.\n");
    my_fasync(-1, pfile, 0);
    return 0;
}

static char kbuf[MAX_LEN] = {0};
static int kbuf_len = 0;
DECLARE_WAIT_QUEUE_HEAD(my_read_queue);
DECLARE_WAIT_QUEUE_HEAD(my_write_queue);
 
ssize_t my_read(struct file *pf, char __user *ubuf, size_t len, loff_t *pl)
{
	int ret = -1;
    if (MAX_LEN < len)
    {
        printk("len is large than %d.\n", MAX_LEN);
		return -1;
	}
	
    //判断设备缓存是否为空
    if (0 == kbuf_len)
	{
        //如果是非阻塞操作,返回-EAGAIN,用户态轮询
		if (pf->f_flags& O_NONBLOCK)
			return -EAGAIN;
        else
        {
            //如果是阻塞操作，等待
            if (wait_event_interruptible(my_read_queue, 0!= kbuf_len))
                return -ERESTARTSYS; //信号唤醒，通知文件系统层做相应处理
        }
	}
 
	ret =  copy_to_user(ubuf, kbuf, len);
    if (0 != ret)
    {   
        printk("Copy to user failed.\n");
        return -1;
    }
    
    //读出后，把对应的设备数据清空，保留未读出数据
    memcpy(kbuf, kbuf + len, MAX_LEN - len);
    memset(kbuf + MAX_LEN - len, 0, len);
 
    //计算设备缓存长度
    if (kbuf_len > len)
    	kbuf_len -= len;
    else
        kbuf_len = 0; 
    
    //当缓存长度不满时，唤醒写队列
    if (MAX_LEN != kbuf_len)
    {
        wake_up_interruptible(&my_write_queue);
        //发送可写通知
        kill_fasync(&my_fapp, SIGIO, POLL_OUT);
    }
	return len;
}
 
ssize_t my_write(struct file *pf, const char __user *ubuf, size_t len, loff_t *pl)
{
	int ret = -1;
 
    //判断是否会写超过
    if (MAX_LEN < len + kbuf_len)
	{
        printk("len is large than %d.\n", MAX_LEN);
		return -1;
	}
	
	if (MAX_LEN == kbuf_len)
	{
        //如果是非阻塞操作,返回-EAGAIN,用户态轮询
		if (pf->f_flags& O_NONBLOCK)
			return -EAGAIN;
        else
        {
            //如果是阻塞操作，等待
            if (wait_event_interruptible(my_write_queue, MAX_LEN != kbuf_len))
                return -ERESTARTSYS; //信号唤醒，通知文件系统层做相应处理
        }
	}
    
    ret = copy_from_user(kbuf + kbuf_len, ubuf, len);
    if (0 != ret)
    {   
        printk("Copy from user failed.\n");
        return -1;
    }
    kbuf_len += len;
    
    //当缓存长度不为空时，唤醒读队列
    if (0 != kbuf_len)
    {
        wake_up_interruptible(&my_read_queue);
        //发送可读通知
        kill_fasync(&my_fapp, SIGIO, POLL_IN);
    }
    return len;
}

static unsigned int my_poll(struct file *filp, struct poll_table_struct *wait)
{
    unsigned int mask = 0;
    
    poll_wait(filp, &my_write_queue, wait);//加写等待队列头
    poll_wait(filp, &my_read_queue, wait);//加读等待队列头

    if (0 != kbuf_len)//可读
    {   
            mask |= POLLIN | POLLRDNORM; /*标示数据可获得*/
    }   
    
    if (MAX_LEN != kbuf_len)//可写
    {   
            mask |= POLLOUT | POLLWRNORM; /*标示数据可写入*/
    }   

    return mask;
}


//异步初始化
static int my_fasync(int fd, struct file *flip, int mode)
{
    return fasync_helper(fd, flip, mode, &my_fapp);
}
 
struct cdev cdevice;
 
struct file_operations cdev_ops = {
    .open    = my_open,
    .release = my_close,
    .read    = my_read,
    .write   = my_write,
    .poll    = my_poll,
    .fasync  = my_fasync,
};
 
//加载
static int hello_init(void)
{ 
    dev_t devno = MKDEV(MAJOR_CHAR,MINOR_CHAR);
    int ret = -1;
	printk(KERN_ALERT "Hello World.\n");
    //up kernel
        //1、注册设备号
        ret = register_chrdev_region(devno, 1, "hello");
        if (0 != ret)
        {
            printk("Register char device failed.\n");
            return ret;
        }
    
        //2、初始化字符设备结构体
        cdev_init(&cdevice, &cdev_ops);
    
        cdevice.owner = THIS_MODULE;
	
        //3、添加字符设备结构体给内核
        ret = cdev_add(&cdevice,devno , 1);
        if (0 != ret)
        {   
            //注意释放设备号
            unregister_chrdev_region(devno,1);
            printk("Unregister char device.\n");
            return ret;
        }
 
        printk("Register char device success.\n");
    //down hardware
 
    return 0;
} 
 
//卸载函数（必须）
static void hello_exit(void)//返回值是void类型，函数名自定义，参数是void
{
    dev_t devno = MKDEV(MAJOR_CHAR, MINOR_CHAR);
 
    printk(KERN_ALERT "Goodbye World.\n");
    // down hardware
 
    // up kernel
        //1、从内核中删除字符设备结构体
        cdev_del(&cdevice);
 
        //2、注销设备号
        unregister_chrdev_region(devno, 1);
}
 
//注册（必须）
module_init(hello_init);
module_exit(hello_exit);
 
//license（必须）
MODULE_LICENSE("GPL");
 
//作者与描述(可选)
MODULE_AUTHOR("Ono Zhang");
MODULE_DESCRIPTION("A simple Hello World Module");

运行结果

$ sudo mknod /dev/mydev c 100 0
$ sudo insmod cdev.ko
$ sudo ./a.out
Write buf is abcdefg
Read buf is abcdefg

tobecontinue

​ 每周三、周六更新

小野嵌入式
关注
专栏目录
linux内核中异步通知机制--信号处理机制
鱼思故渊的专栏
04-08 6912
什么是异步通知：很简单，一旦设备准备好，就主动通知应用程序，这种情况下应用程序就不需要查询设备状态， 特像硬件上常提的“中断的概念”。 比较准确的说法其实应该叫做“信号驱动的异步I/O”,信号是在软件层次上对中断机制的一种模拟。阻塞I/O意味着一直等待设备可访问再访问，非阻塞I/O意味着使用poll()来查询是否可访问，而异步通知则意味着设备通知应用程序自身可访问。（希望用这么一句话能表达我的意思
Linux内核态与用户态通信的常用方法
瑞风轻拂
05-04 2万+
前言 最近做的事情很多地方用到Linux驱动层与应用层的通信，在此总结下常见的并且在我工作中用到的通信方法。 总结 由于每种方法都可以找到大量的示例代码，同时还有详细的函数手册，我就不贴代码了。只列下相关的方法和一个链接。 procfs netlink syscall syscall的范围就广了，通过注册字符设备可以使用mmap和ioctl等来进行操作，要注意
【嵌入式环境下linux内核及驱动学习笔记-（3-字符设备驱动详解）】
weixin_45499326的博客
04-10 2081
项目说明语法功能将主设备号和次设备号转换成dev_t类型头文件参数major为主设备号，minor为次设备号宏定义返回值成功执行返回dev_t类型的设备编号变量用途说明设备号，标识设备的身份标号，可以解析出主设备号与次设备号创建于驱动加载之时，也存于cdev结构体内表示设备的结构体，将设备号与操作函数结构体file_operations关联起来创建于驱动加载之时，加载到内核的cdev链表中驱动实际操作的函数入口，是具体的设备驱动函数集合的入口。
Linux设备驱动——第三章字符驱动
qq_33933799的博客
11-20 1519
本章的目的是编写一个完整的字符设备驱动。我们开发一个字符驱动是因为这一类适合大部分简单的硬件设备。字符驱动也比块驱动易于理解。本章的最终目的是编写一个模块化的字符驱动，但是我们不会在本章讨论模块化的事情。贯穿本章，我们展示从一个真实设备驱动提取的代码片段：scull（Simple Character Utility for Loading Localities）。scull是一个字符驱动，操作一块内存区域好像它是一个设备。
嵌入式linux驱动开发-字符设备驱动
平平酱的博客
10-20 1889
驱动字符设备驱动简介字符设备驱动开发步骤驱动模块的加载和卸载 之前在嵌入式系统移植停留了一段时间，枯燥地看uboot、kernel和跟文件系统的源码感觉没有成就感，在这之前已经对嵌入式linux的启动流程有了大体的了解，因此先跳到驱动开发，体验学习一下子哈！！。 Linux 中的三大类驱动：字符设备驱动、块设备驱动和网络设备驱动。 字符设备驱动：IO口的驱动，比如点灯、 I2C、 SPI、音频等。 块设备驱动：存储器设备的驱动，比如 EMMC、 NAND、 SD 卡和 U 盘等存储设备 网络设备驱动：网络驱
虚拟字符设备驱动开发步骤
zhuguanlin121的博客
11-06 1949
目录字符设备驱动简介内核驱动操作函数集合字符设备驱动开发步骤驱动模块的加载和卸载字符设备注册与注销实现设备的具体操作函数添加LICENSE 和作者信息Linux 设备号设备号的组成设备号的分配chrdevbase 字符设备驱动开发实验实验程序编写编写测试APP编译驱动程序和测试APP运行测试 Linux 中的三大类驱动：字符设备驱动、块设备驱动和网络设备驱动。 字符设备驱动是占用篇幅最大的一类驱动，因为字符设备最多，从最简单的点灯到I2C、SPI、音频等都属于字符设备驱动的类型。 块设备和网络设备驱动要比字
Linux驱动开发01：字符设备、互斥锁、等待队列、定时器和异步通知
Egean的博客
06-29 1423
介绍 这里是linux驱动最基础部分，我会用一个不使用任何驱动框架、不包含任何硬件操作的程序来实现一个字符设备驱动，其中会包含互斥锁、等待队列、定时和异步通知的使用，最后分析它们在内核中到底是如何运作的。 代码和验证 这是一个用内存模拟的字符设备驱动，在初始化时会分配一页的内存给fifo_dev.mem_entry，在写入函数中，向这段内存的添加内容，在读取函数中从这段内存头部读取内容，然后...
驱动开发--汇总
MaGuangming001的博客
09-14 1738
不同于应用程序，驱动是加载到内核空间中的，所以需要按照内核模块的编程框架编写驱动代码。
字符设备驱动
浩海拾贝
01-28 1871
一、设备驱动概述 linux内核的驱动模型为编写驱动提供了抽象，将驱动公共的部分提取了出去简化了驱动的编写工作，但是那并不是实际的驱动，如果要实现真正的驱动，还要给予驱动模型做一些其它的工作。根据外设和内核交互数据的方式，内核将驱动分成了几种类别。基本上设备可以分为两类，一类适合于面向字符的交换，一类适合于处理包含固定数目字节的数据块，这两类分别称为字符设备和块设备（网络设备是一种特殊的设备，它
最全Linux驱动开发全流程详细解析（持续更新）
热门推荐
拉依达不拉跨的博客
02-19 5万+
Linux驱动开发详细解析
常用字符设备驱动函数总结 ----- 记录总结tool
zmjames2000 Just record
03-03 546
打印等级: #define KERN_EMERG "&lt;0&gt;" /* system is unusable */ #define KERN_ALERT "&lt;1&gt;" /* action must be taken immediately */ #define KERN_CRIT "&...
Linux嵌入式学习小结(1)——初识字符设备驱动开发
secretboys的博客
10-22 381
Linux嵌入式学习小结(1)——初始字符设备驱动开发 前言 笔者前段时间自学了有关LinuxARM开发，但由于有关知识过于繁多，所以在此写下相关小结以作梳理。 1.所使用学习资源 1.开发板：正点原子阿尔法开发板：IMX6ULL 2.编程环境：ubuntu16.4 3.ARM版所用Linux系统内核：linux-imx-rel_imx_4.1.15_2.1.0_ga 注：相关资料大家可自行前往正点原子官网下载 2.相关理论知识 1.关于LInux驱动开发 所谓Linux驱动开发，个人理解其实就是编写相关代
《Linux操作系统 - 驱动开发》第2章 字符设备驱动结构
不问归期的博客
08-28 532
2.1 cdev 结构体、设备号相关知识解析 2.1.1字符设备基础知识 1、设备驱动分类 linux系统将设备分为3类：字符设备、块设备、网络设备。 图1 字符设备：是指只能一个字节一个字节读写的设备，不能随机读取设备内存中的某一数据，读取数据需要按照先后数据。字符设备是面向流的设备，常见的字符设备有鼠标、键盘、串口、控制台和LED设备等。 块设备：是指可以从设备的任意位置读取一定长度数据的设...
Linux驱动开发: USB驱动开发
08-24 7386
一、USB简介 1.1 什么是USB? USB是连接计算机系统与外部设备的一种串口总线标准，也是一种输入输出接口的技术规范，被广泛地应用于个人电脑和移动设备等信息通讯产品，USB就是简写，中文叫通用串行总线。最早出现在1995年，伴随着奔腾机发展而来。自微软在Windows 98中加入对USB接口的支持后，USB接口才推广开来，USB设备也日渐增多，如数码相机、摄像头、扫描仪、游戏杆、打印机、键盘、鼠标等等，其中应用最广的就是摄像头和U盘了。 USB包括老旧的USB 1.1标准...
嵌入式Linux设备驱动面试题汇总
chbgoon的博客
02-15 5388
大家平时在写驱动的时候，驱动相关的知识都会用到，但真到面试的时候，很难快速流畅的回答面试提出的问题，特意从网上收集整理网友遇到的问题 驱动大概的分为三部分：基础部分，同步相关，还有中断部分。中断，同步相关基本都是必问的。 基础部分 驱动中操作物理绝对地址为什么要先ioremap? 因为在内核中操作的都是虚拟地址，内核访问不到物理地址，只能通过ioremap映射为虚拟地址 内核才能访问此内存空间 设备驱动模型三个重要成员是？platform总线的匹配规则是？在具体应用上要不要先注册驱动再注册设备？有
linux 网络序
CodeHouse的博客
09-30 361
在将ip字符串转网络序存储时。根据整形二进制显示判断。
Linux 再入门整理：详解 /etc/fstab 文件
最新发布
一只奋斗的猪
10-01 681
`/etc/fstab` 文件是 Linux 系统中用于定义和管理文件系统的挂载信息的配置文件。它的作用是告诉系统在启动时，应该如何自动挂载各种文件系统。挂载是 Linux 操作系统中一种将存储设备与目录树关联的操作。通过挂载，存储设备中的文件可以通过目录访问。
在 Kali Linux 中安装 Impacket
weixin_44023460的博客
09-30 187
在安装 Impacket 之前，你需要确保安装了 Python 和一些必要的依赖。通常，Kali 已经预装了 Python。步骤 3：克隆 Impacket 仓库。步骤 4：进入 Impacket 目录。如果你看到帮助信息，说明安装成功。步骤 5：安装 Impacket。
Linux字符设备驱动实践：从memdev代码到设备节点创建
该资源提供了一个简单的Linux字符设备驱动程序的实例，用于教学目的，包含驱动程序memdev.c和memdev.h，以及一个应用程序app-mem.c和Makefile。通过这个实验，学习者可以理解如何在Linux系统中注册、管理和操作字符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值