lv14 多路复用及信号驱动 8

1 多路复用

描述符：

  • 文件描述符：设备文件、管道文件

  • socket描述符

1.1 应用层：三套接口select、poll、epoll

select：位运算实现 监控的描述符数量有限（32位机1024,64位机2048,监控对象有限） 效率差

poll：链表实现，监控的描述符数量不限 效率差

epoll：效率最高，监控的描述符数量不限

select

int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
/*  功能：监听多个描述符，阻塞等待有一个或者多个文件描述符，准备就绪。
        内核将没有准备就绪的文件描述符，从集合中清掉了。
    参数：  nfds           最大文件描述符数 ，加1
            readfds     读文件描述符集合
            writefds        写文件描述符集合
            exceptfds       其他异常的文件描述符集合
            timeout     超时时间（NULL）
    返回值：当timeout为NULL时返回0，成功:准备好的文件描述的个数  出错:-1 
           当timeout不为NULL时，如超时设置为0，则select为非阻塞，超时设置 > 0，则无描述符可被操作的情况下阻塞指定长度的时间 
*/
void FD_CLR(int fd, fd_set *set);
//功能：将fd 从集合中清除掉
​
int  FD_ISSET(int fd, fd_set *set);
//功能：判断fd 是否存在于集合中
 
void FD_SET(int fd, fd_set *set);
//功能：将fd 添加到集合中
​
void FD_ZERO(fd_set *set);
//功能：将集合清零
​
//使用模型:
​
while(1)
{
    /*得到最大的描述符maxfd*/
    /*FD_ZERO清空描述符集合*/
    /*将被监控描述符加到相应集合rfds里  FD_SET*/
    /*设置超时*/
    ret = select(maxfd+1,&rfds,&wfds,NULL,NULL);
    if(ret < 0)
    {
        if(errno == EINTR)//错误时信号引起的
        {
            continue;   
        }
        else
        {
            break;
        }
    }
    else if(ret == 0)
    {//超时
        //.....
    }
    else
    { //> 0 ret为可被操作的描述符个数
        if(FD_ISSET(fd1,&rfds))
        {//读数据
            //....
        }
        if(FD_ISSET(fd2,&rfds))
        {//读数据
            //....
        }
        ///.....
        if(FD_ISSET(fd1,&wfds))
        {//写数据
            //....
        }
    }
}

1.2 驱动层：实现poll函数

驱动函数XXX_POLL，其实也是帮我进行监控的

我们需要告诉设备什么情况是数据可读，什么情况是有可写入数据

void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)；
/*功能：将等待队列头添加至poll_table表中
  参数：struct file :设备文件
  Wait_queue_head_t :等待队列头
  Poll_table :poll_table表
*/
​
/*该函数与select、poll、epoll_wait函数相对应，协助这些多路监控函数判断本设备是否有数据可读写*/
unsigned int xxx_poll(struct file *filp, poll_table *wait) //函数名初始化给struct file_operations的成员.poll
{
    unsigned int mask = 0;
    /*
        1. 将所有等待队列头加入poll_table表中
        2. 判断是否可读，如可读则mask |= POLLIN | POLLRDNORM;
        3. 判断是否可写，如可写则mask |= POLLOUT | POLLWRNORM;
    */
    
    return mask;
}

1.3 驱动示例：

mychar.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>

#include "mychar.h"

#define BUF_LEN 100

#define MYCHAR_DEV_CNT 3

int major = 11;
int minor = 0;
int mychar_num  = MYCHAR_DEV_CNT;

//新建结构体类型
struct mychar_dev
{
	struct cdev mydev;
	char mydef_buf[BUF_LEN];  //相当于结构体的私有变量
	int curlen;          //相当于结构体的私有变量
	wait_queue_head_t rq; //等待读队列
	wait_queue_head_t wq; //等待写队列

};

struct mychar_dev gmydev;

int mychar_open(struct inode *pnode, struct file *pfile)
{
	//利用private_data私有变量来指向全局变量结构体地址
	pfile->private_data = (void*)(container_of(pnode->i_cdev,struct mychar_dev,mydev));
    printk("mychar_open is called\n");
    return 0;
}

int mychar_close(struct inode *pnode, struct file *pfile)
{
    printk("mychar_close is called\n");
    return 0;
}


ssize_t mychar_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos)
{
	int ret = 0;
	int size = 0;
	//获取全家变量结构体地址
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	if(pmydev->curlen <= 0)
	{
		if(filp->f_flags & O_NONBLOCK)
		{//非阻塞
			printk("O_NONBLOCK No Data Read\n");
			return -1;
		}
		else
		{//阻塞
			ret = wait_event_interruptible(pmydev->rq,pmydev->curlen > 0);
			if(ret)
			{
				printk("Wake up by signal\n");
				return -ERESTARTSYS;
			}
		}
	}

 	if(count > pmydev->curlen)
	{
		size = pmydev->curlen;
	}
	else
	{
		size = count;
	}

	//将内核空间中的数据复制到用户空间
	ret = copy_to_user(pbuf,pmydev->mydef_buf,size);
	if(ret)
	{
	
		printk("copy_to_user failed\n");
		return -1;
	}
	//读完之后把后面的内容再拷贝过来，同时更新curlen
	memcpy(pmydev->mydef_buf,pmydev->mydef_buf+size,pmydev->curlen - size);
	pmydev->curlen = pmydev->curlen - size;

	wake_up_interruptible(&pmydev->wq);

	return size;

}

ssize_t mychar_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos)
{

	int size = 0;
	int ret  = 0;
	//获取全家变量结构体地址
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	if(pmydev->curlen >= BUF_LEN)
	{
		if(filp->f_flags & O_NONBLOCK)
		{
			printk("O_NONBLOCK Can not write data\n");
			return -1;
		}
		else
		{
			ret = wait_event_interruptible(pmydev->wq,pmydev->curlen < BUF_LEN);
			if(ret)
			{
				printk("wake up by signal\n");
				return -ERESTARTSYS;
			}
		}
	}

	if(count > BUF_LEN - pmydev->curlen)
	{
		size = BUF_LEN - pmydev->curlen;
	}
	else
	{
		size = count;
	}

	//将用户空间中的数据复制到内核空间中
	ret = copy_from_user(pmydev->mydef_buf + pmydev->curlen, pbuf, size);
	if(ret)
	{
		printk("copy_from_user failed\n");
		return -1;
	}
    //更新curlen
	pmydev->curlen = pmydev->curlen + size;

	wake_up_interruptible(&pmydev->rq);

	return size;
}

long mychar_ioctl(struct file *filp, unsigned int cmd,unsigned long arg)
{
    int __user *pret = (int *)arg;
	int maxlen = BUF_LEN;
	int ret = 0;
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;


	switch(cmd)
	{
		case MYCHAR_IOCTL_GET_MAXLEN:
			ret = copy_to_user(pret,&maxlen,sizeof(int));
			if(ret)
			{
				printk("copy_to_user MAXLEN failed\n");
				return -1;
			}
			break;
		case MYCHAR_IOCTL_GET_CURLEN:
			ret = copy_to_user(pret,&pmydev->curlen,sizeof(int));
			if(ret)
			{
				printk("copy_to_user CURLEN failed\n");
				return -1;
			}
			break;
		default:
			printk("The cmd is unknow\n");
			return -1;
	}
	return 0;
}

/*该函数与select、poll、epoll_wait函数相对应，协助这些多路监控函数判断本设备是否有数据可读写*/
unsigned int mychar_poll(struct file *filp, poll_table *ptb)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;
	unsigned int mask = 0;

	//将等待队列头添加至poll_table表中
	poll_wait(filp, &pmydev->rq,ptb);
	poll_wait(filp, &pmydev->wq,ptb);
	
	//mutex_lock(&pmydev->lock);
	if(pmydev->curlen > 0) //有数据可读
	{
		mask |= POLLIN | POLLRDNORM;
	}
	if(pmydev->curlen < BUF_LEN) //有空间可写
	{
		mask |= POLLOUT | POLLWRNORM;
	}
	//mutex_unlock(&pmydev->lock);

	return mask;
	
	
}


//结构体初始化:部分变量赋值初始化
struct file_operations myops = {
    .owner = THIS_MODULE,
    .open = mychar_open,
    .release = mychar_close,
	.read = mychar_read,
	.write = mychar_write,
	.unlocked_ioctl = mychar_ioctl,
	.poll = mychar_poll,
};

int mychar_init(void)
{
    int ret = 0;
    dev_t devno = MKDEV(major, minor);

    /* 申请设备号 */
    ret = register_chrdev_region(devno, mychar_num, "mychar");
    if (ret) {
        ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
        if (ret) {
            printk("get devno failed\n");
            return -1;
        }
		major = MAJOR(devno); // 容易遗漏，注意
    }

    /* 给struct cdev对象指定操作函数集 */
    cdev_init(&gmydev.mydev, &myops);

    /* 将 struct cdev对象添加到内核对应的数据结构里 */
    gmydev.mydev.owner = THIS_MODULE;
    cdev_add(&gmydev.mydev, devno, 1);

	//初始化队列
	init_waitqueue_head(&(gmydev.rq));
	init_waitqueue_head(&(gmydev.wq));

    return 0;
}

void __exit mychar_exit(void)
{
    dev_t devno = MKDEV(major, minor);

    cdev_del(&gmydev.mydev);

    unregister_chrdev_region(devno, mychar_num);
}

//表示支持GPL的开源协议
MODULE_LICENSE("GPL");

module_init(mychar_init);
module_exit(mychar_exit);

主要实现以下部分功能: 

编译报错，缺的头文件可以通过grep搜索

 grep poll_table /home/linux/Linux_4412/kernel/linux-3.14/include/ -r -n

 mychar.h

#ifndef MY_CHAR_H
#define MY_CHAR_H

#include <asm/ioctl.h>

#define MY_CHAR_MAGIC 'k'

#define MYCHAR_IOCTL_GET_MAXLEN _IOR(MY_CHAR_MAGIC,1,int*)
#define MYCHAR_IOCTL_GET_CURLEN _IOR(MY_CHAR_MAGIC,2,int*)


#endif

testmychar_select.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/select.h>
#include <errno.h>

#include "mychar.h"
#include <stdio.h>


int main(int argc,char *argv[])
{
	int fd = -1;
	char buf[8] = "";
	int ret = 0;
	fd_set rfds;


	if(argc < 2)
	{
		printf("The argument is too few\n");
		return 1;
	}

	fd = open(argv[1],O_RDWR);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 2;
	}

	while(1)
	{	
		//使用FD_ZERO宏初始化一个文件描述符集rfds，并使用FD_SET宏将文件描述符fd添加到rfds集合中。
		FD_ZERO(&rfds);
		FD_SET(fd,&rfds);
		//调用select函数对文件描述符进行监控，如果文件描述符可读，则返回一个大于0的数值，表示有文件描述符就绪；如果出错，则返回-1
		ret = select(fd + 1,&rfds,NULL,NULL,NULL);
		if(ret < 0)
		{
			//如果select返回值小于0，并且错误码为EINTR，表示select被中断，可以继续循环等待；否则，打印错误信息并退出循环。
			if(errno == EINTR)
			{
				continue;
			}
			else
			{
				printf("select error\n");
				break;
			}
		}
		//如果文件描述符fd在rfds集合中可读，调用read函数从fd中读取8字节的数据，并将其存储在缓冲区buf中
		if(FD_ISSET(fd,&rfds))
		{
			read(fd,buf,8);
			printf("buf=%s\n",buf);
		}
	}


	close(fd);
	fd = -1;
	return 0;
}

Makefile

ifeq ($(KERNELRELEASE),)

ifeq ($(ARCH),arm)
KERNELDIR ?= /home/linux/Linux_4412/kernel/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)


modules:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules

modules_install:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_install

clean:
	rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versions

else
CONFIG_MODULE_SIG=n
obj-m += mychar.o
obj-m += mychar_poll.o

endif

命令lsmod | grep char用于列出当前加载的内核模块

命令cat /proc/devices | grep char用于查看系统中已注册的设备类型。

执行效果

2 信号驱动

2.1 应用层：信号注册+fcntl

signal(SIGIO, input_handler); //注册信号处理函数

fcntl(fd, F_SETOWN, getpid());//将描述符设置给对应进程，好由描述符获知PID

oflags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, oflags | FASYNC);//将该设备的IO模式设置成信号驱动模式

void input_handler(int signum)//应用自己实现的信号处理函数，在此函数中完成读写
{
    //读数据
}

应用层模板代码 

//应用模板
int main()
{
	int fd = open("/dev/xxxx",O_RDONLY);

	fcntl(fd, F_SETOWN, getpid());

	oflags = fcntl(fd, F_GETFL);
	fcntl(fd, F_SETFL, oflags | FASYNC);

	signal(SIGIO,xxxx_handler);

	//......
}
    
void xxxx_handle(int signo)
{//读写数据
    
}

2.2 驱动层：实现fasync函数

实现模板

/*设备结构中添加如下成员*/
struct fasync_struct *pasync_obj;

/*应用调用fcntl设置FASYNC时调用该函数产生异步通知结构对象，并将其地址设置到设备结构成员中*/
static int hello_fasync(int fd, struct file *filp, int mode) //函数名初始化给struct file_operations的成员.fasync
{
	struct hello_device *dev = filp->private_data; 
	return fasync_helper(fd, filp, mode, &dev->pasync_obj);
}

/*写函数中有数据可读时向应用层发信号*/
if (dev->pasync_obj)
       kill_fasync(&dev->pasync_obj, SIGIO, POLL_IN);   //POLL_IN代表读信号 POLL_OUT代表写信号
       
/*release函数中释放异步通知结构对象*/
if (dev->pasync_obj) 
	fasync_helper(-1, filp, 0, &dev->pasync_obj);








int fasync_helper(int fd, struct file *filp, int mode, struct fasync_struct **pp);
/*
	功能：产生或释放异步通知结构对象
	参数：
	返回值：成功为>=0,失败负数
*/

void kill_fasync(struct fasync_struct **, int, int);
/*	
	功能：发信号
	参数：
		struct fasync_struct ** 指向保存异步通知结构地址的指针
		int 	信号 SIGIO/SIGKILL/SIGCHLD/SIGCONT/SIGSTOP
		int 	读写信息POLLIN、POLLOUT
*/

2.3 驱动示例

mychar.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>


#include "mychar.h"

#define BUF_LEN 100

#define MYCHAR_DEV_CNT 3

int major = 11;
int minor = 0;
int mychar_num  = MYCHAR_DEV_CNT;

//新建结构体类型
struct mychar_dev
{
	struct cdev mydev;
	char mydef_buf[BUF_LEN];  //相当于结构体的私有变量
	int curlen;          //相当于结构体的私有变量

	wait_queue_head_t rq; //等待读队列
	wait_queue_head_t wq; //等待写队列

	struct fasync_struct *pasync_obj;  //实现异步通知机制的数据结构

};

struct mychar_dev gmydev;

int mychar_open(struct inode *pnode, struct file *pfile)
{
	//利用private_data私有变量来指向全局变量结构体地址
	pfile->private_data = (void*)(container_of(pnode->i_cdev,struct mychar_dev,mydev));
    printk("mychar_open is called\n");
    return 0;
}

int mychar_close(struct inode *pnode, struct file *pfile)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;

    printk("mychar_close is called\n");
	if(pmydev->pasync_obj != NULL)
	{
		fasync_helper(-1,pfile,0,&pmydev->pasync_obj);  //则调用fasync_helper函数来取消异步通知
	}
    return 0;
}


ssize_t mychar_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos)
{
	int ret = 0;
	int size = 0;
	//获取全家变量结构体地址
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	if(pmydev->curlen <= 0)
	{
		if(filp->f_flags & O_NONBLOCK)
		{//非阻塞
			printk("O_NONBLOCK No Data Read\n");
			return -1;
		}
		else
		{//阻塞
			ret = wait_event_interruptible(pmydev->rq,pmydev->curlen > 0);
			if(ret)
			{
				printk("Wake up by signal\n");
				return -ERESTARTSYS;
			}
		}
	}

 	if(count > pmydev->curlen)
	{
		size = pmydev->curlen;
	}
	else
	{
		size = count;
	}

	//将内核空间中的数据复制到用户空间
	ret = copy_to_user(pbuf,pmydev->mydef_buf,size);
	if(ret)
	{
		printk("copy_to_user failed\n");
		return -1;
	}
	//读完之后把后面的内容再拷贝过来，同时更新curlen
	memcpy(pmydev->mydef_buf,pmydev->mydef_buf+size,pmydev->curlen - size);
	pmydev->curlen = pmydev->curlen - size;

	wake_up_interruptible(&pmydev->wq);

	return size;

}

ssize_t mychar_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos)
{

	int size = 0;
	int ret  = 0;
	//获取全家变量结构体地址
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	if(pmydev->curlen >= BUF_LEN)
	{
		if(filp->f_flags & O_NONBLOCK)
		{
			printk("O_NONBLOCK Can not write data\n");
			return -1;
		}
		else
		{
			ret = wait_event_interruptible(pmydev->wq,pmydev->curlen < BUF_LEN);
			if(ret)
			{
				printk("wake up by signal\n");
				return -ERESTARTSYS;
			}
		}
	}

	if(count > BUF_LEN - pmydev->curlen)
	{
		size = BUF_LEN - pmydev->curlen;
	}
	else
	{
		size = count;
	}

	//将用户空间中的数据复制到内核空间中
	ret = copy_from_user(pmydev->mydef_buf + pmydev->curlen, pbuf, size);
	if(ret)
	{
		printk("copy_from_user failed\n");
		return -1;
	}
    //更新curlen
	pmydev->curlen = pmydev->curlen + size;

	wake_up_interruptible(&pmydev->rq);

	//数据写成功发送可读信号（同样读函数也可以实现）
	if(pmydev->pasync_obj != NULL)
	{
		kill_fasync(&pmydev->pasync_obj,SIGIO,POLL_IN);
	}
	return size;
}

long mychar_ioctl(struct file *filp, unsigned int cmd,unsigned long arg)
{
    int __user *pret = (int *)arg;
	int maxlen = BUF_LEN;
	int ret = 0;
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;


	switch(cmd)
	{
		case MYCHAR_IOCTL_GET_MAXLEN:
			ret = copy_to_user(pret,&maxlen,sizeof(int));
			if(ret)
			{
				printk("copy_to_user MAXLEN failed\n");
				return -1;
			}
			break;
		case MYCHAR_IOCTL_GET_CURLEN:
			ret = copy_to_user(pret,&pmydev->curlen,sizeof(int));
			if(ret)
			{
				printk("copy_to_user CURLEN failed\n");
				return -1;
			}
			break;
		default:
			printk("The cmd is unknow\n");
			return -1;
	}
	return 0;
}

/*该函数与select、poll、epoll_wait函数相对应，协助这些多路监控函数判断本设备是否有数据可读写*/
unsigned int mychar_poll(struct file *filp, poll_table *ptb)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;
	unsigned int mask = 0;

	//将等待队列头添加至poll_table表中
	poll_wait(filp, &pmydev->rq,ptb);
	poll_wait(filp, &pmydev->wq,ptb);
	
	if(pmydev->curlen > 0) //有数据可读
	{
		mask |= POLLIN | POLLRDNORM;
	}
	if(pmydev->curlen < BUF_LEN) //有空间可写
	{
		mask |= POLLOUT | POLLWRNORM;
	}

	return mask;
	
	
}

//使用pmydev->pasync_obj作为异步通知对象进行注册
int mychar_fasync(int fd,struct file *filp,int mode)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)filp->private_data;

	return fasync_helper(fd,filp,mode,&pmydev->pasync_obj);
}

//结构体初始化:部分变量赋值初始化
struct file_operations myops = {
    .owner = THIS_MODULE,
    .open = mychar_open,
    .release = mychar_close,
	.read = mychar_read,
	.write = mychar_write,
	.unlocked_ioctl = mychar_ioctl,
	.poll = mychar_poll,
	.fasync = mychar_fasync,
};

int mychar_init(void)
{
    int ret = 0;
    dev_t devno = MKDEV(major, minor);

    /* 申请设备号 */
    ret = register_chrdev_region(devno, mychar_num, "mychar");
    if (ret) {
        ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
        if (ret) {
            printk("get devno failed\n");
            return -1;
        }
		major = MAJOR(devno); // 容易遗漏，注意
    }

    /* 给struct cdev对象指定操作函数集 */
    cdev_init(&gmydev.mydev, &myops);

    /* 将 struct cdev对象添加到内核对应的数据结构里 */
    gmydev.mydev.owner = THIS_MODULE;
    cdev_add(&gmydev.mydev, devno, 1);

	//初始化队列
	init_waitqueue_head(&(gmydev.rq));
	init_waitqueue_head(&(gmydev.wq));

    return 0;
}

void __exit mychar_exit(void)
{
    dev_t devno = MKDEV(major, minor);

    cdev_del(&gmydev.mydev);

    unregister_chrdev_region(devno, mychar_num);
	

}

//表示支持GPL的开源协议
MODULE_LICENSE("GPL");

module_init(mychar_init);
module_exit(mychar_exit);

mychar.c代码实现步骤

1 添加异步通知数据结构体 

2 注册异步通知对象的模板函数

3 关闭释放异步通知处理对象

 4 写函数中发送信号

mychar.h

#ifndef MY_CHAR_H
#define MY_CHAR_H

#include <asm/ioctl.h>

#define MY_CHAR_MAGIC 'k'

#define MYCHAR_IOCTL_GET_MAXLEN _IOR(MY_CHAR_MAGIC,1,int*)
#define MYCHAR_IOCTL_GET_CURLEN _IOR(MY_CHAR_MAGIC,2,int*)


#endif

 Makefile

ifeq ($(KERNELRELEASE),)

ifeq ($(ARCH),arm)
KERNELDIR ?= /home/linux/Linux_4412/kernel/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)


modules:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules

modules_install:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_install

clean:
	rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versions

else
CONFIG_MODULE_SIG=n
obj-m += mychar.o
obj-m += mychar_poll.o

endif

 testmychar_signal.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/select.h>
#include <errno.h>
#include <signal.h>

#include "mychar.h"
#include <stdio.h>

int fd = -1;

void sigio_handler(int signo);

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

	int flg = 0;

	if(argc < 2)
	{
		printf("The argument is too few\n");
		return 1;
	}

	signal(SIGIO,sigio_handler);

	fd = open(argv[1],O_RDWR);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 2;
	}
		
	//将文件描述符fd设置为异步通知模式，并将当前进程的PID设置为接收异步通知的进程
	fcntl(fd,F_SETOWN,getpid());  //数将当前进程的PID设置为fd的拥有者
	flg = fcntl(fd,F_GETFL);      //取fd的标志位
	flg |= FASYNC;                //然后使用按位或运算符将FASYNC标志位添加到标志中
	fcntl(fd,F_SETFL,flg);        //将flg（即带有FASYNC标志位的标志）设置为fd的标志位，从而使fd进入异步通知模式

	while(1)
	{	
		
	}


	close(fd);
	fd = -1;
	return 0;
}


void sigio_handler(int signo)
{
	char buf[8] = "";
	read(fd,buf,8);
	printf("buf=%s\n",buf);
}

编译后插入内核模块：

 

 

2.4 补充

小于32的信号是常规信号，在同时多个信号联系触发时，只会保留第一个。

在 Linux 中，的确有一些关于信号驱动编程的限制和不可靠性。其中一个问题是，当多个相同类型的信号连续到达时，内核只会保留一个信号，而其他的信号会被丢弃。这被称为信号的信号合并（Signal Merging）。

这种行为是为了避免信号过载和提高系统性能。如果内核为每个到达的信号都生成一个进程或线程，将会增加系统开销并降低整体效率。因此，内核决定只接收一个信号，并在处理完当前信号后向进程发送一个信号。

对于需要处理多个连续到达的信号的情况，可以使用一些技术来解决信号合并的问题。例如，在信号处理函数中，可以使用特定的系统调用（如sigaction）来重新设置信号的处理方式，以确保每个信号都得到正确处理，而不会丢失。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【MATLAB】VMD_LSTM神经网络时序预测算法

【MATLAB】VMD_LSTM神经网络时序预测算法

有意向获取代码&#xff0c;请转文末观看代码获取方式~也可转原文链接获取~ 1 基本定义 变分模态分解&#xff08;Variational Mode Decomposition&#xff0c;VMD&#xff09;和LSTM&#xff08;Long Short-Term Memory&#xff09;神经网络结合的算法是一种用于处理时间序列…
阅读更多...
国家注册信息安全专业人员十五类CISP证书

国家注册信息安全专业人员十五类CISP证书

国家注册信息安全专业人员&#xff08;Certified Information Security Professiona&#xff0c;简称CISP&#xff09;&#xff0c;是面向党政机关、关键信息基础设施运营单位、各类企事业单位和社会组织以及网络与信息安全企业、测评和咨询服务机构等工作的信息安全人员颁发的…
阅读更多...
ELK之Filebeat安装配置及日志抓取

ELK之Filebeat安装配置及日志抓取

一、Filebeat是什么 轻量型日志采集器 无论您是从安全设备、云、容器、主机还是 OT 进行数据收集，Filebeat 都将为您提供一种轻量型方法，用于转发和汇总日志与文件，让简单的事情不再繁杂。 Filebeat 随附可观测性和安全数据源模块，这些模块简化了常见格式的日志的收集、解…
阅读更多...
MyBatis的配置及简单使用

MyBatis的配置及简单使用

1.配置myBatis 1.myBatis的作用 MyBatis 是一个开源的持久层框架&#xff0c;它的主要作用是简化数据库操作&#xff0c;使得开发者能够更方便地与数据库进行交互。 MyBatis 允许开发者使用简单的 XML 或注解配置 SQL 映射&#xff0c;从而实现数据库操作&#xff0c;而不需要…
阅读更多...
MATLAB Deep learning

MATLAB Deep learning

文章目录 Chapter 1: Machine Learning存在的问题过拟合Overfitting解决过拟合 regularization and validationregularization 正则化validation 验证 机器学习的类型有监督学习分类Classification回归Regression 无监督学习聚类 强化学习 Chapter 2: Neural NetworkChapter 3:…
阅读更多...
Danswer部署指南

Danswer部署指南

Quickstart How to deploy Danswer on your local machine ​ Requirements gitdocker with compose (docker version > 1.13.0) ​ Setup This quickstart guide covers setting up Danswer for local execution Clone the Danswer repo: git clone https://github.com…
阅读更多...
高效学习新编程语言的实践指南

高效学习新编程语言的实践指南

学习一门新的编程语言或框架对于新手和有经验的程序员来说都是一个挑战。然而&#xff0c;通过采用一些有效的策略和方法&#xff0c;我们可以快速入门并掌握新的编程工具。本文将从新手和有编程经验两个不同的角度&#xff0c;分享一些实用的建议和技巧&#xff0c;帮助读者在…
阅读更多...
【GitHub项目推荐--开源的坦克大战】【转载】

【GitHub项目推荐--开源的坦克大战】【转载】

坦克大战当年红遍大江南北&#xff0c;很多和我一样的九零后应该都有着对这个游戏的记忆。现在显示器分辨率越来越高&#xff0c;使用矢量图来实现像素风格游戏&#xff0c;可以获得非常高的展现质量。 这个项目是作者肥超花了很长时间折腾的复刻版本&#xff0c;所有元素都使…
阅读更多...
长亭科技-雷池WAF的安装与使用

长亭科技-雷池WAF的安装与使用

目录 1、安装雷池 2、登录雷池 3、简单配置 4、防护测试 5、其他补充 1、安装雷池 在Linux系统上执行如下命令 &#xff08;需要docker环境&#xff0c;提前把docker、docker-compose 装好&#xff09; bash -c "$(curl -fsSLk https://waf-ce.chaitin.cn/release…
阅读更多...
vue3+threejs可视化项目——搭建vue3+ts+antd路由布局（第一步）

vue3+threejs可视化项目——搭建vue3+ts+antd路由布局（第一步）

文章目录 ⭐前言&#x1f496;vue3系列相关文章 ⭐搭建vue3项目过程&#x1f496; 初始化项目&#x1f496; 添加antd和router依赖&#x1f496; vite配置项映射目录和代理&#x1f496; antd国际化&#x1f496; layout布局封装&#x1f496; vite读取modules目录文件作为路由…
阅读更多...
前缀和模板题 P8218 【深进1.例1】求区间和

前缀和模板题 P8218 【深进1.例1】求区间和

一道前缀和的模板题 #include<bits/stdc.h> using namespace std; using ll long long; const int N 1e5 10; ll a[N],prefix[N]; int main(){ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);int n,m;cin >> n;for(int i 1; i < n; i) cin >> a[i]…
阅读更多...
YOLOv8 Ultralytics：使用Ultralytics框架进行SAM图像分割

YOLOv8 Ultralytics：使用Ultralytics框架进行SAM图像分割

YOLOv8 Ultralytics&#xff1a;使用Ultralytics框架进行SAM图像分割 前言相关介绍前提条件实验环境安装环境项目地址LinuxWindows 使用Ultralytics框架进行SAM图像分割参考文献 前言 由于本人水平有限&#xff0c;难免出现错漏&#xff0c;敬请批评改正。更多精彩内容&#xf…
阅读更多...
PyGWalker，一款超级强大的数据分析和数据可视化的工具库

PyGWalker，一款超级强大的数据分析和数据可视化的工具库

PyGWalker可以有效简化Jupyter笔记本的数据分析和数据可视化工作流程&#xff0c;方法是将panda数据帧转换为Tableau风格的用户界面进行可视化探索。 PyGWalker被命名为“Graphic Walker的Python绑定”的缩写。它集成了Jupyter笔记本&#xff08;或其他基于Jupyter的笔记本&am…
阅读更多...
蓝桥杯AcWing学习笔记 8-2数论的学习（下）

蓝桥杯AcWing学习笔记 8-2数论的学习（下）

蓝桥杯 我的AcWing 题目及图片来自蓝桥杯C AB组辅导课 数论&#xff08;下&#xff09; 蓝桥杯省赛中考的数论不是很多&#xff0c;这里讲几个蓝桥杯常考的知识点。 约数个数定理 我们如何去求一个数的约数个数呢&#xff1f; N N N分解质因数的结果&#xff1a; N P 1 α…
阅读更多...
Sublime Text4 crack时替换的汇编指令

Sublime Text4 crack时替换的汇编指令

Sublime Text4 crack时替换的汇编指令 首先请支持正版&#xff0c;这里研究破解的步骤&#xff0c;仅做汇编代码学习。 破解步骤很简单&#xff1a; 打开二进制文件&#xff0c; 搜索 80 78 05 00 0F 94 C1&#xff0c; 替换为 C6 40 05 01 48 85 C9. (源: https://gist.git…
阅读更多...
CH341 SPI方式烧录BK7231U

CH341 SPI方式烧录BK7231U

CH341是一个USB总线的转接芯片&#xff0c;通过USB总线提供异步串口、打印口、并口以及常用的2线和4线等同步串行接口。 BK7231U Wi-Fi SOC芯片&#xff0c;内嵌处理器。1. 符合802.11b/g/n 1x1协议 2. 17dBm 输出功率3. 支持20/40 MHz带宽和STBC 4. 支持Wi-Fi STA、AP、…
阅读更多...
美颜技术详解：美颜SDK与直播平台集成

美颜技术详解：美颜SDK与直播平台集成

如今&#xff0c;美颜技术成为了吸引用户的一项重要功能。本篇文章&#xff0c;小编将深入讲解美颜技术&#xff0c;重点关注美颜SDK的原理以及如何将其无缝集成到直播平台中&#xff0c;为用户提供更加优质的视觉体验。 一、美颜技术概述 美颜技术的应用范围广泛&#xff0c…
阅读更多...
星河璀璨：飞桨星河文心SDK与Gurdance珠联璧合让大模型更像人！

星河璀璨：飞桨星河文心SDK与Gurdance珠联璧合让大模型更像人！

星河璀璨&#xff1a;飞桨星河文心SDK与Gurdance珠联璧合让大模型更像人&#xff01; 本项目效果惊艳&#xff0c;可以在AIStudio星河社区一键运行 只需要在cpu基础版下运行&#xff0c;妈妈再也不怕我的算力不够了&#xff01; 1、引言 2023年8月22日&#xff0c;百度董事…
阅读更多...
阿里云c8i服务器CPU性能、架构及费用测评

阿里云c8i服务器CPU性能、架构及费用测评

阿里云第八代云服务器ECS计算型c8i实例&#xff0c;CPU采用Intel Xeon Emerald Rapids或者Intel Xeon Sapphire Rapids&#xff0c;主频不低于2.7 GHz&#xff0c;全核睿频3.2&#xff0c;阿里云百科aliyunbaike.com分享阿里云c8i服务器CPU处理器型号、存储、网络、安全、使用场…
阅读更多...
uniCloud 云数据库（1）

uniCloud 云数据库（1）

目录 1&#xff1a;云数据库入门,基本概念了解 1.1 云数据库是关系型还是Nosql? 1.2 uniCloud 云数据库和关系型数据库的对比 1.3 官方文档传送门 2: 基本操作表 创建 在uniCloud web控制台 进行创建 数据表的3个组成部分 通过传统方式操作数据库 获取集合的引用 集…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站