linux 阻塞、非阻塞、异步通知
同步通知：包含阻塞和非阻塞
阻塞
当应用程序调用了read\write…系统接口到内核空间后，运行了驱动中的函数再返回处理结果时，驱动中的函数使用了等待队列
非阻塞（轮询select poll,epoll）
当应用程序调用了select/poll/epoll 对应都是内核空间中，驱动程序的poll函数。
在进行对设备的读写之前，查询当前设备的状态（是否可读/是否可写）
异步通知
这种方式是让设备主动告知应用程序，当前设备的状态（是否可读/是否可写）
应用层三步走：
1.将打开的设备文件描述符的拥有者改成当前的应用程序，这样驱动发送的信号才能被本程序捕获
fcntl(fd , F_SETOWN,getpid()); //设置设备文件的拥有者为本程序
2…将打开的设备文件添加fasync属性，使之支持异步通知
oflags = fcntl(fd , F_GETFL);
fcntl(fd, F_SETFL,oflags|FASYNC);//设置设备文件支持FASYNC(异步通知模式)
3.设置信号的处理函数
signal(SIGIO,singalio_hander);//将信号和信号处理函数连接，该信号和驱动中发送的信号保持一致
驱动层三步走：
1.对应的应用层第一步，该步已由内核完成
2.对应的应用层第二步，当应用层添加了fasync属性后，会在驱动层调用fasync函数
所以驱动中需要实现fasync函数
.fasync = globalfifo_fasync,
3.对应的应用层第三步，发送相应的信号量
kill_fasync(&dev->globalfifo_fasync,SIGIO,POLL_IN); //发送可读信号，这里的SIGIO需要与应用层对应
异步通知的完整代码（globalfifo_aio）
应用层
#include <stdio.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <poll.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <signal.h>
#define BUFFER_LEN 20
#define GLOBALFIFO_MAGIC 'f'
#define FIFO_CLEAR _IO(GLOBALFIFO_MAGIC,0)
#define DEVICE "/dev/globalfifo_aio"
void singalio_hander(int signum)
{
printf("receive a signal from globalfifo_aio,signalnum : %d\n",signum);
}
void main(void)
{
int fd ,oflags ;
fd = open(DEVICE,O_RDWR | S_IRUSR | S_IWUSR);
if (fd != -1)
{
signal(SIGIO,singalio_hander);//将信号和信号处理函数连接
fcntl(fd , F_SETOWN,getpid()); //设置设备文件的拥有者为本程序
oflags = fcntl(fd , F_GETFL);
fcntl(fd, F_SETFL,oflags|FASYNC);//设置设备文件支持FASYNC(异步通知模式)
while(1)
sleep(100);
}
else {
printf("Device open failure\n");
}
}
驱动模块
/*
* 验证阻塞与非阻塞操作
*此版本添加了互斥体
*进程间互斥访问共享资源（globalfifo）
*
*此版本添加了阻塞非阻塞
*文件中，读fifo将唤醒写filo的进程（如果之前fifo正好是满的）
* 写fifo将唤醒读fifo的进程（如果之前fifo正好是空的）
*
*此版本添加了异步通知操作globalfifo_fasync
* 使用设备主动通知的方式来告诉应用程序
*/
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/poll.h>
#define GLOBALFIFO_SIZE 0x1000
//#define MEM_CLEAR 0x1
#define GLOBALFIFO_MAGIC 'f'
#define MEM_CLEAR _IO(GLOBALFIFO_MAGIC,0)
#define GLOBALFIFO_MAJOR 233
#define DEVICE_NUM 1 //同主设备号，不同次设备号有1个
static int globalfifo_major = GLOBALFIFO_MAJOR;
module_param(globalfifo_major,int ,S_IRUGO);
struct globalfifo_dev
{
struct cdev cdev;
unsigned int current_len; //表示目前的FIFO中的有效长度，如果为0,表示FIFO为空，如果是GLOBALFIFO_SIZE，表示FIFO满了
unsigned char mem[GLOBALFIFO_SIZE];
struct mutex globalfifo_mutex;
wait_queue_head_t r_wait;
wait_queue_head_t w_wait;
struct fasync_struct *globalfifo_fasync;
};
struct globalfifo_dev * globalfifo_devp;
static loff_t globalfifo_llseek(struct file *filp,loff_t offset, int orig)
{
loff_t ret = 0;
switch (orig)
{
case 0://从文件开头位置seek
if (offset < 0 || (unsigned int)offset > GLOBALFIFO_SIZE)
{
ret = -EINVAL;
break;
}
filp->f_pos = (unsigned int)offset;
ret = filp->f_pos;
break;
case 1://从文件当前位置seek
if ((filp->f_pos + offset) < 0 || (filp->f_pos + offset) > GLOBALFIFO_SIZE)
{
ret = -EINVAL;
break;
}
filp->f_pos = (unsigned int)offset;
ret = filp->f_pos;
break;
default:
ret = -EINVAL;
break;
}
return ret;
}
ssize_t globalfifo_write(struct file *filp, const char __user *buf,
size_t size, loff_t *pos)
{
unsigned int count = size;
int ret = 0;
struct globalfifo_dev *dev = filp->private_data;
// if (p > GLOBALFIFO_SIZE)
// return 0;
// if (count > GLOBALFIFO_SIZE - p)
// count = GLOBALFIFO_SIZE - p;
DECLARE_WAITQUEUE(wait,current);
mutex_lock(&dev->globalfifo_mutex);
add_wait_queue(&dev->w_wait,&wait);
while (dev->current_len == GLOBALFIFO_SIZE)//如果当前的fifo为满，则进程阻塞
{
if(filp->f_flags & O_NONBLOCK)//判断是否以非阻塞打开的设备文件（/dev/globalfifo）
{
//非阻塞就直接返回了
ret = -EAGAIN;
goto out;
}
//阻塞就让本函数休眠
__set_current_state(TASK_INTERRUPTIBLE);
mutex_unlock(&dev->globalfifo_mutex);
schedule();
if(signal_pending(current))//判断是否是信号唤醒的
{
//是信号唤醒的
ret = -ERESTARTSYS;
goto out2;
}
//不是信号唤醒的，可以操作了 ，此时再上锁dev->current_len != GLOBALFIFO_SIZE
mutex_lock(&dev->globalfifo_mutex);
}
if (dev->current_len + count > GLOBALFIFO_SIZE)
count = GLOBALFIFO_SIZE - dev->current_len;
if (copy_from_user(&dev->mem[dev->current_len],buf,count))
{
ret = -EFAULT;
goto out;
} else {
dev->current_len += count;
printk(KERN_INFO "written %u bytes(s) from %u \n",count,dev->current_len-count);
wake_up_interruptible(&dev->r_wait); //写入后再唤醒读（如果有读进程堵塞）
if(dev->globalfifo_fasync)
{
kill_fasync(&dev->globalfifo_fasync,SIGIO,POLL_IN); //发送可读信号
printk(KERN_DEBUG "%s kill SIGIO\n",__func__);
}
ret = count;
}
out:
mutex_unlock(&dev->globalfifo_mutex);
out2:
remove_wait_queue(&dev->w_wait,&wait);
set_current_state(TASK_RUNNING);
return ret;
}
ssize_t globalfifo_read(struct file *filp, char __user *buf,
size_t size, loff_t *pos)
{
unsigned int count = size;
int ret = 0;
struct globalfifo_dev *dev = filp->private_data;
DECLARE_WAITQUEUE(wait,current);
mutex_lock(&dev->globalfifo_mutex);
add_wait_queue(&dev->r_wait,&wait);
while (dev->current_len == 0)//如果当前的fifo为空，则进程阻塞
{
if(filp->f_flags & O_NONBLOCK)//判断是否以非阻塞打开的设备文件（/dev/globalfifo）
{
//非阻塞就直接返回了
ret = -EAGAIN;
goto out;
}
//阻塞就让本函数休眠
__set_current_state(TASK_INTERRUPTIBLE);
mutex_unlock(&dev->globalfifo_mutex);
schedule();
if(signal_pending(current))//判断是否是信号唤醒的
{
//是信号唤醒的
ret = -ERESTARTSYS;
goto out2;
}
//不是信号唤醒的，可以操作了 ，此时再上锁dev->current_len != 0
mutex_lock(&dev->globalfifo_mutex);
}
if (count > dev->current_len)
count = dev->current_len;
if (copy_to_user(buf, dev->mem,count))
{
ret = -EFAULT;
goto out;
} else {
memcpy(dev->mem , dev->mem +count , dev->current_len - count);//将剩下的内容拷贝到前面去
dev->current_len -= count;
printk(KERN_INFO "read %u bytes(s) from %u \n",count,dev->current_len);
wake_up_interruptible(&dev->w_wait);//读出后后再唤醒写（如果有写进程堵塞）
ret = count;
}
out:
mutex_unlock(&dev->globalfifo_mutex);
out2:
remove_wait_queue(&dev->w_wait,&wait);
set_current_state(TASK_RUNNING);
return ret;
}
int globalfifo_fasync(int fd, struct file *filp, int mode)
{
struct globalfifo_dev * dev = filp->private_data;
return fasync_helper(fd,filp,mode,&dev->globalfifo_fasync);
}
int globalfifo_open(struct inode *inode, struct file *filp)
{
//filp->private_data = globalfifo_devp;
//如果有多个设备，主设备号相同，只是次设备号不同，驱动这样写
//从inode->i_cdev中找到类型为struct globalfifo_dev的成员
struct globalfifo_dev * dev = container_of(inode->i_cdev,struct globalfifo_dev,cdev); //container_of(ptr,type,member)
filp->private_data = dev;
return 0;
}
int globalfifo_release(struct inode *inode, struct file *filp)
{
globalfifo_fasync(-1,filp,0);//将文件从异步通知列表中删除
return 0;
}
long globalfifo_ioctl (struct file *filp, unsigned int cmd, unsigned long arg)
{
struct globalfifo_dev *dev = filp->private_data;
switch (cmd)
{
case MEM_CLEAR:
mutex_lock(&dev->globalfifo_mutex);
memset(dev->mem , 0 ,GLOBALFIFO_SIZE);
mutex_unlock(&dev->globalfifo_mutex);
printk(KERN_INFO "globalfifo is set to zero \n");
break;
default:
return -EINVAL;
}
return 0;
}
unsigned int globalfifo_poll(struct file *filp, struct poll_table_struct *poll_table)
{
unsigned int mask = 0;
struct globalfifo_dev * dev = filp->private_data;
mutex_lock(&dev->globalfifo_mutex);
poll_wait(filp ,&dev->r_wait,poll_table);//将读等待队列加入poll链表，这将意味着因select而阻塞的进程可以被r_wait
poll_wait(filp ,&dev->w_wait,poll_table);//将写等待队列加入poll链表，这将意味着因select而阻塞的进程可以被w_wait
if (dev->current_len != 0)
mask |= POLLIN | POLLRDNORM; //返回可读
if(dev->current_len != GLOBALFIFO_SIZE)
mask |= POLLOUT | POLLWRNORM; //返回可写
mutex_unlock(&dev->globalfifo_mutex);
return mask;
}
static const struct file_operations globalfifo_fops = {
.owner = THIS_MODULE,
.llseek = globalfifo_llseek,
.read = globalfifo_read,
.write = globalfifo_write,
.unlocked_ioctl = globalfifo_ioctl,
.open = globalfifo_open,
.release = globalfifo_release,
//.poll = globalfifo_poll,
.fasync = globalfifo_fasync,
};
static void globalfifo_setup_cdev(struct globalfifo_dev *dev,int index)
{
int err,devno = MKDEV(globalfifo_major,index);
printk(KERN_INFO "index is %d\n",index); //添加打印代码是不想编译时这个代码被优化掉，导致次设备号的设备打不开
cdev_init(&dev->cdev ,&globalfifo_fops);
printk(KERN_INFO "dev->cdev is %p\n",&dev->cdev);
dev->cdev.owner = THIS_MODULE;
err = cdev_add(&dev->cdev ,devno, 1);
if(err)
printk(KERN_NOTICE "Error %d adding globalfifo%d",err,index);
}
static int __init globalfifo_init(void)
{
int ret,i;
dev_t devno = MKDEV(globalfifo_major,0);
if (globalfifo_major)
ret = register_chrdev_region(devno,DEVICE_NUM,"globalfifo");
else{
ret = alloc_chrdev_region(&devno,0,DEVICE_NUM,"globalfifo");
globalfifo_major = MAJOR(devno);
}
if (ret < 0)
return ret;
globalfifo_devp = kzalloc(sizeof(struct globalfifo_dev) * DEVICE_NUM,GFP_KERNEL);
if (!globalfifo_devp)
{
ret = -ENOMEM;
goto fail_malloc;
}
for (i = 0;i < DEVICE_NUM;i++)
{
mutex_init(&(globalfifo_devp+i)->globalfifo_mutex);
init_waitqueue_head(&(globalfifo_devp+i)->r_wait);
init_waitqueue_head(&(globalfifo_devp+i)->w_wait);
globalfifo_setup_cdev(globalfifo_devp + i,i);
}
return 0;
fail_malloc:
unregister_chrdev_region(devno,DEVICE_NUM);
return ret;
}
module_init(globalfifo_init);
static void __exit globalfifo_exit(void)
{
int i = 0;
for (i = 0;i < DEVICE_NUM;i++)
cdev_del(&(globalfifo_devp+i)->cdev);
kfree(globalfifo_devp);
unregister_chrdev_region(MKDEV(globalfifo_major,0),DEVICE_NUM);
}
module_exit(globalfifo_exit);
MODULE_AUTHOR("good man");
MODULE_LICENSE("GPL v2");
595
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
