阻塞io与非阻塞io模型

一.概念

        阻塞io：当应用层有程序访问驱动设备时，阻塞io会等待读到数据才返回

        非阻塞io：不论应用层read函数有没有读到数据，都立即返回

那么在内核层是如何实现的呢？

当然要通过代码啦！！！

请看原理图：

二.搭建模型

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include "led.h"
#define CNAME "myled"
unsigned int major=0;
int minor=0;
struct class *cls;
//指向字符设备号
struct device *dev;
const int count=3;
char kbuf[128] = "";
//指向字符设备驱动结构体
struct cdev *cdev;
//定义阻塞队列头
wait_queue_head_t wq;
int condition=0;
int mycdev_open(struct inode *inode,struct file *file)
{

    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
ssize_t mycdev_read(struct file*file,char __user *ubuf,size_t size,loff_t *loffs)
{
    int ret;
    //file判断是否阻塞方式打开
    if(file->f_flags & O_NONBLOCK)
    {
        return -EINVAL;
    }else{//阻塞方式
    //方式1：可中断处理函数
       // ret=wait_event_interruptible(wq,condition);

        if(ret)
        {
            printk("reveive signal....\n");
            return ret;
        }
        //方式2：不可中断处理函数(无返回值)---对应不可中断的唤醒
        wait_event(wq,condition);
    }
    if(size>sizeof(kbuf)) size=sizeof(kbuf);
    //将内核空间数据拷贝到用户空间
    ret=copy_to_user(ubuf,kbuf,size);
    if(ret)
    {
        printk("copy to user is error\n");
        return -EIO;
    }
    //进入休眠态
    condition=0;
    
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return size;

}
//ssize_t mycdev_write(struct file *file,char __user *ubuf,size_t size,loff_t *loff)错误写法
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    //校验传输数据大小，如果用户空间传输数据的大小大于内核空间，需要更正传输数据大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    ret = copy_from_user(kbuf,ubuf,size);
    if(ret)
    {
        printk("copy from user is error\n");
        return -EIO;
    }
    //唤醒休眠进程
    condition = 1;
   // wake_up_interruptible(&wq);
    wake_up(&wq);//不可中断的唤醒
    //返回copy_from_user 从用户空间读到的大小，如果没读到，会一直等待
    return size;
}
int mycdev_close(struct inode* inode,struct file *file)
{
    
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
const struct file_operations fops={
    .open=mycdev_open,
    .read=mycdev_read,
    .write=mycdev_write,
    .release=mycdev_close,
};
static int __init mycdev_init(void)
{   
    int ret;
    dev_t devno;
    int i;
    //1.分步注册字符设备驱动
    //1）分配dev结构体
    cdev=cdev_alloc();
    if(NULL==cdev)
    {
        printk("cdev alloc is failed\n");
        return -EIO;
    }
    //2）初始化cdev结构体
    cdev_init(cdev,&fops);
    //3)动态申请设备号,成功返回0，失败返回错误码
    ret=alloc_chrdev_region(&devno,0,count,CNAME);
    if(ret)
    {
        printk("alloc_chrdev_region is failed\n");
        return -ENOMEM;
    }
    //成功申请到设备号，调函数获取主次设备号(12+20)
    major=MAJOR(devno);
    minor=MINOR(devno);
    //3)驱动注册
    ret=cdev_add(cdev,MKDEV(major,minor),count);
    if(ret)
    {
        printk("dev add is failed\n");
        return -EIO;
    }
//2.自动创建设备节点   
    //1）向上层提交目录信息
    cls=class_create(THIS_MODULE,CNAME);
    if(IS_ERR(cls))
    {
        return PTR_ERR(cls);
    }
    //2.向上层提交设备节点
    for(i=0;i<count;i++)
    {
        dev=device_create(cls,NULL,MKDEV(major,i),NULL,"myled%d",i);
        if(IS_ERR(dev))
        {
            return PTR_ERR(dev);
        }
    }
    //初始化队列头
    init_waitqueue_head(&wq);

    return 0;
    
}
static void __exit mycdev_exit(void)
{
    int i;
    //销毁节点
    for(i=0;i<count;i++)
    {
        device_destroy(cls,MKDEV(major,i));
    }
    
    //销毁目录信息
    class_destroy(cls);
    //驱动注销
    cdev_del(cdev);
    //注销设备号
    unregister_chrdev_region(MKDEV(major,minor),count);
    //5.释放dev结构体
    kfree(cdev);

}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

 应用层代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h> 
#include <stdlib.h> 
#include <string.h>   
char buf[128] = "";
char ubuf[128] = {0};
int main(int argc, char const *argv[])
{
    int fd = -1;
    pid_t pid;
    int count=5; //打印5次
    fd = open("/dev/myled0",O_RDWR);
    if(-1 == fd)
    {
        perror("open is error");
        exit(1);
    }
    pid = fork();
    if(pid==-1)
    {
        perror("fork is error");
        exit(1);
    }else if(pid==0)
    {
        while(count--)
        {
            memset(buf,0,sizeof(buf));
            read(fd,buf,sizeof(buf));
            printf("buf=%s\n",buf);
        }
    }else{
            strcpy(buf,"test block.");
            while(count--)
            {
                sleep(3);
                write(fd,buf,sizeof(buf));
            }
        }
    close(fd);
    return 0;
}

三.展示效果