linux环形缓冲区kfifo实践4：异步通知fasync

news2024/11/24 4:51:28

基础知识 

异步通知在内核中使用struct fasync_struct数据结构来描述。

<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;
};

设备驱动的file_operations的操作方法集中有一个fasync的方法，我们需要实现它。

static const struct file_operations demodrv_fops = {
    .owner = THIS_MODULE,
    ….
    fasync = my_fasync,
};

static int my_fasync(int fd, struct file *file, int on){
    struct mydemo_private_data *data = file->private_data;
    struct mydemo_device *device = data->device;
    return fasync_helper(fd, file, on, &device->fasync);
}

 这里直接使用fasync_helper()函数来构造struct fasync_struct类型的节点，并添加到系统的链表中。

发送信号 kill_fasync

/* can be called from interrupts */
extern void kill_fasync(struct fasync_struct **, int, int);

 

sigaction

        struct sigaction {
               void     (*sa_handler)(int);
               void     (*sa_sigaction)(int, siginfo_t *, void *);
               sigset_t   sa_mask;
               int        sa_flags;
               void     (*sa_restorer)(void);
           };

        struct sigaction act,oldact;

    sigemptyset(&act.sa_mask);

    sigaddset(&act.sa_mask,SIGIO);//设置SIGIO信号

    act.sa_flags = SA_SIGINFO;//该选项可以使内核通过siginfo->si_band将POLL_IN和POLL_OUT上传到用户空间。便于在信号处理函数中区分读写信号。 

 驱动代码：

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <linux/miscdevice.h>
#include <linux/kfifo.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/mutex.h>

#define DEBUG_INFO(format, ...) printk("%s:%d -- "format"\n",\
__func__,__LINE__,##__VA_ARGS__)

struct ch5_kfifo_struct{
    struct miscdevice misc;
    struct file_operations fops;
    struct kfifo fifo;
    char buf[64];
    char name[64];
    wait_queue_head_t read_queue;
    wait_queue_head_t write_queue;
    struct fasync_struct *fasync;
};

static int ch5_open (struct inode *inode, struct file *file){
    struct ch5_kfifo_struct *p = (struct ch5_kfifo_struct *)container_of(file->f_op,struct ch5_kfifo_struct,fops);
    file->private_data = p;
    DEBUG_INFO("major = %d, minor = %d\n",MAJOR(inode->i_rdev),MINOR(inode->i_rdev));
    DEBUG_INFO("name = %s",p->misc.name);
    return 0;
}



static unsigned int ch5_poll(struct file *file, poll_table *wait){
    int mask = 0;
    struct ch5_kfifo_struct *p __attribute__((unused)) = (struct ch5_kfifo_struct *)file->private_data;
    DEBUG_INFO("begin wait:%s",p->name);
    poll_wait(file, &p->read_queue, wait);
    poll_wait(file, &p->write_queue, wait);
    DEBUG_INFO("poll:%s",p->name);
    if (!kfifo_is_empty(&p->fifo)){
        mask |= POLLIN | POLLRDNORM;
        DEBUG_INFO("POLLIN:%s",p->name);
    }
        
    if (!kfifo_is_full(&p->fifo)){
        mask |= POLLOUT | POLLWRNORM;
        DEBUG_INFO("POLLOUT:%s",p->name);
    }
        
    return mask;
}

static int ch5_fasync(int fd, struct file *file, int on){
    struct ch5_kfifo_struct *p = (struct ch5_kfifo_struct *)file->private_data;
    return fasync_helper(fd, file, on, &p->fasync);
}

static ssize_t ch5_read (struct file *file, char __user *buf, size_t size, loff_t *pos){
    struct ch5_kfifo_struct *p __attribute__((unused)) = (struct ch5_kfifo_struct *)file->private_data;
    int ret;
    int actual_readed = 0;

    if(kfifo_is_empty(&p->fifo)){
        if(file->f_flags & O_NONBLOCK){
            DEBUG_INFO("kfifo is null");
            return -EAGAIN;
        }
        ret = wait_event_interruptible(p->read_queue,kfifo_is_empty(&p->fifo) == 0);
        if(ret){
            DEBUG_INFO("wait_event_interruptible error");
            return ret;
        }
        DEBUG_INFO("");
    }
    
    ret = kfifo_to_user(&p->fifo, buf, size, &actual_readed);
    if (ret){
        DEBUG_INFO("kfifo_to_user error");
		return -EIO;
    }
    
    DEBUG_INFO("size = %d,actual_readed = %d\n",size,actual_readed);

    if (!kfifo_is_full(&p->fifo)){
        wake_up_interruptible(&p->write_queue);
        if(p->fasync != NULL){
            kill_fasync(&p->fasync, SIGIO, POLL_OUT);
        }
    }

    memset(p->buf,0,sizeof(p->buf));
    ret = copy_from_user(p->buf, buf, actual_readed);
    if(ret != 0){
        DEBUG_INFO("copy_from_user error ret = %d\n",ret);
    }else{
        DEBUG_INFO("read p->buf = %s\n",p->buf);
    }
    *pos = *pos + actual_readed;
    return actual_readed;
}
static ssize_t ch5_write (struct file *file, const char __user *buf, size_t size, loff_t* pos){
    struct ch5_kfifo_struct *p = (struct ch5_kfifo_struct *)file->private_data;
    int actual_writed = 0;
    int ret;
    if(kfifo_is_full(&p->fifo)){
        if(file->f_flags & O_NONBLOCK){
            DEBUG_INFO("kfifo is full");
            return -EAGAIN;
        }
        ret = wait_event_interruptible(p->write_queue, kfifo_is_full(&p->fifo) == 0);
        if(ret){
            DEBUG_INFO("wait_event_interruptible error");
            return ret;
        }
        DEBUG_INFO("");
    }
    ret = kfifo_from_user(&p->fifo, buf, size, &actual_writed);
    if (ret){
        DEBUG_INFO("kfifo_from_user error");
		return -EIO;
    }
    
    DEBUG_INFO("actual_writed = %d\n",actual_writed);

    if (!kfifo_is_empty(&p->fifo)){
        wake_up_interruptible(&p->read_queue);
        if(p->fasync != NULL){
            kill_fasync(&p->fasync, SIGIO, POLL_IN);
        }
        
    }
    memset(p->buf,0,sizeof(p->buf));
    ret = copy_from_user(p->buf, buf, actual_writed);
    if(ret != 0){
        DEBUG_INFO("copy_from_user error ret = %d\n",ret);
    }else{
        DEBUG_INFO("write:p->buf = %s\n",p->buf);
    }
    *pos = *pos + actual_writed;
    return actual_writed;
}

static int ch5_release (struct inode *inode, struct file *file){
    struct ch5_kfifo_struct *p = (struct ch5_kfifo_struct *)container_of(file->f_op,struct ch5_kfifo_struct,fops);
    ch5_fasync(-1, file, 0);
    p->fasync = NULL;
    DEBUG_INFO("close");
    return 0;
}
struct ch5_kfifo_struct ch5_kfifo[1];
//  = {
//     .misc = { 
//         .name = "ch5-04-block",
//         .minor = MISC_DYNAMIC_MINOR,
//     },
//     .fops = {
//         .owner = THIS_MODULE,
//         .read = ch5_read,
//         .write = ch5_write,
//         .open = ch5_open,
//         .release = ch5_release,
//     },
// };

static int __init ch5_init(void){
    int ret = 0;
    int i = 0;
    struct ch5_kfifo_struct *p;

    DEBUG_INFO("start init\n");
    for(i = 0;i < sizeof(ch5_kfifo)/sizeof(ch5_kfifo[0]);i++){
        p = &ch5_kfifo[i];
        p->fasync = NULL;
        snprintf(p->name,sizeof(p->name),"ch5-06-fasync-%d",i);
        p->misc.name = p->name;
        p->misc.minor = MISC_DYNAMIC_MINOR;

        p->fops.owner = THIS_MODULE;
        p->fops.read = ch5_read;
        p->fops.write = ch5_write;
        p->fops.open = ch5_open;
        p->fops.release = ch5_release;
        p->fops.poll = ch5_poll;
        p->fops.fasync = ch5_fasync;

        p->misc.fops = &p->fops;
        ret = kfifo_alloc(&p->fifo,
                    8,
                    GFP_KERNEL);
        if (ret) {
            DEBUG_INFO("kfifo_alloc error: %d\n", ret);
            ret = -ENOMEM;
            return ret;
        }
        DEBUG_INFO("kfifo_alloc size = %d",kfifo_avail(&p->fifo));

        init_waitqueue_head(&p->read_queue);
        init_waitqueue_head(&p->write_queue);

        ret = misc_register(&p->misc);
        if(ret < 0){
            DEBUG_INFO("misc_register error: %d\n", ret);
            return ret;
        }
    }
    
    DEBUG_INFO("misc_register ok");
    return 0;
}

static void __exit ch5_exit(void){
    int i = 0;
    struct ch5_kfifo_struct *p;
    for(i = 0;i < sizeof(ch5_kfifo)/sizeof(ch5_kfifo[0]);i++){
        p = &ch5_kfifo[i];
        misc_deregister(&p->misc);
        kfifo_free(&p->fifo);
    }

    DEBUG_INFO("exit\n");
}

module_init(ch5_init);
module_exit(ch5_exit);

MODULE_LICENSE("GPL");

应用代码：

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <errno.h>
#include <poll.h>
#include <linux/input.h>
#include <unistd.h>
#include <signal.h>
#include <sys/ioctl.h>

#define DEBUG_INFO(format, ...) printf("%s:%d -- "format"\n",\
    __func__,__LINE__,##__VA_ARGS__)

int fd = 0;

void signal_handler(int signum,siginfo_t *siginfo,void *act){
    int ret = 0;
    char buf[1024] = {0};
    if(signum == SIGIO){
        if(siginfo->si_band & POLLIN){
            DEBUG_INFO("kfifo is not empty");
            if((ret = read(fd,buf,sizeof(buf))) == -1){
                buf[ret] = '\0';
            }
            DEBUG_INFO("buf = %s",buf);
        }
        if(siginfo->si_band & POLLOUT){
            DEBUG_INFO("kfifo is not full");
        }
    }
}

int main(int argc, char**argv){
    struct sigaction act,oldact;
    int flag;
    char *filename = "/dev/ch5-06-fasync-0";
    int ret = 0;
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask,SIGIO);

    act.sa_flags = SA_SIGINFO;
    act.sa_sigaction = signal_handler;

    if(sigaction(SIGIO, &act,&oldact) == -1){
        DEBUG_INFO("sigaction failed");
        return -1;
    }
    fd = open(filename,O_RDWR);
    if(fd < 0){
        perror("open");
        DEBUG_INFO("open %s failed",filename);
        return -1;
    }
    DEBUG_INFO("open %s ok",filename);

    ret = fcntl(fd, F_SETOWN, getpid());
    if(ret < 0){
        DEBUG_INFO("fcntl F_SETOWN  %s failed",filename);
        return -1;
    }
    ret = fcntl(fd, F_SETSIG, SIGIO);
    if(ret < 0){
        DEBUG_INFO("fcntl F_SETSIG  %s failed",filename);
        return -1;
    }
    flag = fcntl(fd, F_GETFL);
    ret = fcntl(fd, F_SETFL, flag | FASYNC);
    if(ret < 0){
        DEBUG_INFO("fcntl F_SETFL  %s failed",filename);
        return -1;
    }
    while(1){
        sleep(1);
    }              
    return 0;
}

测试结果：

 小结 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/859963.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

CTF竞赛密码学之 LFSR

CTF竞赛密码学之 LFSR

概述: 线性反馈移位寄存器&#xff08;LFSR&#xff09;归属于移位寄存器&#xff08;FSR&#xff09;,除此之外还有非线性移位寄存器&#xff08;NFSR&#xff09;。移位寄存器是流密码产生密钥流的一个主要组成部分。 G F ( 2 ) GF(2) GF(2)上一个n级反馈移位寄存器由n个二元…
阅读更多...
matlab使用教程(12)—随机数种子和随机数流

matlab使用教程(12)—随机数种子和随机数流

1.生成可重复的随机数 1.1指定种子 本示例显示如何通过首先指定种子来重复生成随机数数组。每次使用相同种子初始化生成器时&#xff0c;始终都可以获得相同的结果。首先&#xff0c;初始化随机数生成器&#xff0c;以使本示例中的结果具备可重复性。 rng( default ); 现在…
阅读更多...
django实现登录和登录的鉴权

django实现登录和登录的鉴权

1、创建数据库的管理员表 在models.py 中定义admin表&#xff0c;为了简单&#xff0c;表里只有用户名和密码还有默认加的id 三个字段 from django.db import models# Create your models here.class Admin(models.Model):username models.CharField(verbose_name"用户…
阅读更多...
新利好带动 POSE 持续上扬，月内几近翻倍

新利好带动 POSE 持续上扬，月内几近翻倍

PoseiSwap 是 Nautilus Chain 上的首个 DEX&#xff0c;得益于 Nautilus Chain 的模块化 Layer3 构架&#xff0c;PoseiSwap 正在基于 zk-Rollup 方案构建全新的应用层&#xff0c;并基于此构建隐私、合规等全新的特性&#xff0c;为未来其布局 RWA 领域推动 Web2、Web3 世界的…
阅读更多...
布谷鸟配音：一站式配音软件

布谷鸟配音：一站式配音软件

这是一款智能语音合成软件&#xff0c;可以快速将文字转换成语音&#xff0c;拥有多种真人模拟发音&#xff0c;可以选择不同男声、女声、童声&#xff0c;以及四川话、粤语等中文方言和外语配音&#xff0c;并且可对语速、语调、节奏、数字读法、多音字、背景音等进行全方位设…
阅读更多...
【gridsample】地平线如何支持gridsample算子

【gridsample】地平线如何支持gridsample算子

文章目录 1. grid_sample算子功能解析1.1 理论介绍1.2 代码分析1.2.1 x,y取值范围[-1,1]1.2.2 x,y取值范围超出[-1,1] 2. 使用grid_sample算子构建一个网络3. 走PTQ进行模型转换与编译 实操以J5 OE1.1.60对应的docker为例 1. grid_sample算子功能解析 该段主要参考&#xff1a;…
阅读更多...
最大子数组和——力扣53

最大子数组和——力扣53

文章目录 题目描述解法一 动态规划题目描述 解法一 动态规划 int maxSubArray(vector<int>& nums){int pre=0, res=nums
阅读更多...
spring boot策略模式实用: 告警模块为例

spring boot策略模式实用: 告警模块为例

spring boot策略模式实用: 告警模块 0 涉及知识点 策略模式, 模板方法, 代理, 多态, 反射 1 需求概括 场景: 每隔一段时间, 会获取设备运行数据, 如通过温湿度计获取到当前环境温湿度;需求: 对获取回来的进行分析, 超过配置的阈值需要产生对应的告警 2 方案设计 告警的类…
阅读更多...
详解双端队列单调队列

详解双端队列单调队列

1. 双端队列 双端队列&#xff08;Double-ended Queue&#xff09;&#xff0c;简称Deque&#xff0c;是一种具有特殊功能的线性数据结构。它支持从两端进行元素的插入和删除操作&#xff0c;因此可以在队列和栈之间灵活地切换操作。双端队列在编程中经常用于需要在队列和栈之间…
阅读更多...
MySQL多表连接查询2

MySQL多表连接查询2

目录 1 所有有门派的人员信息 2 列出所有用户&#xff0c;并显示其机构信息 3 列出不入派的人员 4 所有没人入的门派 5 列出所有人员和门派的对照关系 6 列出所有没入派的人员和没人入的门派 7 求各个门派对应的掌门人名称: ​8 求所有当上掌门人的平均年龄: 9 求所…
阅读更多...
6.4 (通俗易懂)可视化详解多通道 多通道输入输出卷积代码实现

6.4 (通俗易懂)可视化详解多通道 多通道输入输出卷积代码实现

以前对多通道和多通道输入输出的卷积操作不理解&#xff0c;今天自己在草稿纸上画图推理了一遍&#xff0c;终于弄懂了。希望能帮助到大家。 多通道可视化 一通道的2x2矩阵 torch.Size([2,2]) 相当于 torch.Size([1,2,2])&#xff0c;是一通道的2x2矩阵 二通道的 2x2矩阵 …
阅读更多...
go-zero 是如何实现令牌桶限流的？

go-zero 是如何实现令牌桶限流的？

原文链接&#xff1a; 上一篇文章介绍了 如何实现计数器限流&#xff1f;主要有两种实现方式&#xff0c;分别是固定窗口和滑动窗口&#xff0c;并且分析了 go-zero 采用固定窗口方式实现的源码。 但是采用固定窗口实现的限流器会有两个问题&#xff1a; 会出现请求量超出限…
阅读更多...
断续模式（DCM）与连续模式（CCM)

断续模式（DCM）与连续模式（CCM)

断续模式&#xff08;DCM&#xff09;与连续模式&#xff08;CCM)是开关电源最常用的两种工作模式。当初级开关管导通前&#xff0c;初级绕组还存在能量&#xff0c;不完全传递到次级&#xff0c;这种情况就叫连续模式。若初级绕组能量完全传递到次级&#xff0c;则为断续模式。…
阅读更多...
Linux与安卓安全对抗

Linux与安卓安全对抗

导读大家都知道安卓是基于Linux内核&#xff0c;而且大家也知道Linux的安全性是公认的&#xff0c;那为什么和Linux有着类似嫡系关系的安卓却一直被人诟病不安全呢&#xff1f;要想说清楚这个问题&#xff0c;我们需要了解一下安卓和Linux到底是什么关系&#xff0c;而且这两个…
阅读更多...
中国信通院高质量数字化转型产品及服务全景图发布，合合信息多项AI产品入选

中国信通院高质量数字化转型产品及服务全景图发布，合合信息多项AI产品入选

随着5G、人工智能、大数据等新一代技术的发展&#xff0c;企业在商业竞争中正面临更多不确定性。中国信通院高度关注企业数字化转型中遇到的痛点&#xff0c;发起“铸基计划-高质量数字化转型行动”&#xff0c;链接企业数字化转型供、需两侧的发展需求&#xff0c;以期推动国家…
阅读更多...
MySQL—缓存

MySQL—缓存

目录标题 为什么要有Buffer Poolbuffer pool有多大buffer pool缓存什么 如何管理Buffer Pool如何管理空闲页如何管理脏页如何提高缓存命中率预读失效buffer pool污染 脏页什么时候会被刷入到磁盘 为什么要有Buffer Pool 虽然说MySQL的数据是存储在磁盘中&#xff0c;但是也不能…
阅读更多...
C++——缺省参数

C++——缺省参数

缺省参数的定义 缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数的时候&#xff0c;如果没有指定实参&#xff0c;则采用该形参的缺省值&#xff0c;否则使用指定的实参。 void Func(int a 0) {cout << a << endl; } int main() { Func()…
阅读更多...
【C++学习手札】new和delete看这一篇就够了！

【C++学习手札】new和delete看这一篇就够了！

​ 食用指南&#xff1a;本文在有C基础的情况下食用更佳 &#x1f340;本文前置知识&#xff1a; C类 ♈️今日夜电波&#xff1a; Prover—milet 1:21 ━━━━━━️&#x1f49f;──────── 4:01 …
阅读更多...
OI易问卷协助企业服务好员工，收集员工反馈与信息

OI易问卷协助企业服务好员工，收集员工反馈与信息

OI易问卷——企业问卷调查工具 OI易问卷&#xff0c;是群硕专为企业打造&#xff0c;对内服务员工的调查问卷。 集成于办公联合创新平台&#xff0c;并进一步帮助客户实现与微信或企业微信等其他平台的对接。 可以有效促进员工服务数字化&#xff0c;提高各部门工作效率&…
阅读更多...
mysql的相关指令

mysql的相关指令

mysql的相关指令 DML 数据操作语言DQL数据查询 mysql -uroot -p //启动数据库 show databases; //查看有哪些数据库 use 数据库名; //使用某个数据库 show tables; //查看数据库内有哪些表 exit; //退出mysql的命令环境 create database 数据库名称 charset utf8; //创建数据…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023