Linux字符设备驱动模型（二）-蒲公英云

在上一节中讨论了字符设备的基本模型，本节在上一节的基础上继续完善，本节将增加file_operations中的read、write和llseek三个方法。

read和write

read和write方法完成的任务是相似的，即，拷贝数据到应用程序空间，或反过来从应用程序空间拷贝数据到内核空间，它们的原型也很相似，如下：

ssize_t read(struct file *filp, char __user *buffer, size_t count, loff_t *ppos);
ssize_t write(struct file *file, const char __user *buffer, size_t count, loff_t* ppos);

对于这两个方法的参数解读如下：

filep： 文件指针；
count： 请求传输的数据长度；
buffer： 指向用户空间的缓冲区，该地址是用户空间的地址，在内核不能直接使用，拷贝数据需要通过copy_from_user和copy_to_user两个函数来操作，其原型如下：

unsigned long copy_to_user(void user to, const void from, unsigned long count);
unsigned long copy_from_user(void* to, const void user* from, unsigned long count);

这两个函数在拷贝是会对地址做检查，返回实际拷贝的字节数。

ppos： 指明用户在文件中进行存取操作的位置。即，read和write都要在偏移*ppos的基础上对文件进行操作。需要注意的是在读取或者写入文件内容后需要更新*ppos，之后内核会将文件位置的改变传播回file结构。

llseek

llseek的作用就是重新定位文件访问（read或者write）的偏移，函数原型为：

loff_t char_driver_llseek(struct file *filp, loff_t offset, int whence);

filp： 文件指针；
offset： 需要偏移的距离，可以是正数，也可以是负数；
whence： 从何处开始偏移，一共有三种方式，分别是：
　　ａ．从文件头部偏移；
　　ｂ．从当前访问位置偏移；
　　ｃ．从文件末尾偏移。

至此，本节的内容差不多了，下面给出完整的代码：
char_driver.c

#include <linux/module.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>
#define MEM_SIZE 4096
struct mem_dev                                     
{
    char *buf;                      
    unsigned long buf_size;  
    //struct cdev cdev;      
};
struct mem_dev *mem_devp;
static int char_driver_open(struct inode *inode, struct file *filp)
{
    filp->private_data = mem_devp;        // 将全局变量mem_devp赋给filp->private_data，减少对全局变量的依赖
    printk("<0> open dev:%d\n", iminor(inode));
    return 0;
}
static ssize_t  char_driver_read(struct file *filp, char __user *buffer, size_t count, loff_t *ppos)
{
    int read_size;
    struct mem_dev *my_dev;
    my_dev = filp->private_data;
    if (count > my_dev->buf_size - *ppos) {
        read_size = my_dev->buf_size - *ppos;
    } else {
        read_size = count;
    }
    copy_to_user(buffer, my_dev->buf + *ppos, read_size);
    *ppos += read_size;
    //printk("<0> char_read to user:%s\n", buffer);
    return read_size;
}
static ssize_t  char_driver_write(struct file *filp, const char __user *buffer, size_t count, loff_t* ppos)
{
    struct mem_dev *my_dev;
    int write_size;
    my_dev = filp->private_data;
    if (count > my_dev->buf_size - *ppos) {
        write_size = my_dev->buf_size - *ppos;
    } else {
        write_size = count; 
    }
    copy_from_user(my_dev->buf + filp->f_pos, buffer, write_size);
    *ppos += count;
    //printk("<0> char_write from user:%s ppos:%d\n", (struct mem_dev*)(file->private_data)->buf, (int)*ppos);
    return write_size;
}
static loff_t char_driver_llseek(struct file *filp, loff_t offset, int whence)
{
    loff_t newpos;
    struct mem_dev *my_dev = filp->private_data;
    switch(whence) {
    case 0: /* SEEK_SET */
        newpos = offset;
        break;
    case 1: /* SEEK_CUR */
        newpos = filp->f_pos + offset;
        break;
    case 2: /* SEEK_END */
        newpos = my_dev->buf_size -1 + offset;
        break;
    default: /* can't happen */
        return -EINVAL;
    }
    if ((newpos < 0) || (newpos > MEM_SIZE)) {
        return -EINVAL;
    }
    filp->f_pos = newpos;
    return newpos;
}
static int  char_driver_release(struct inode *inode, struct file *filp)
{
    printk(KERN_EMERG"close dev:%d\n", MINOR(inode->i_rdev));
    return 0;
}
static struct file_operations char_driver_fops = {
    .owner =    THIS_MODULE,
    .open =        char_driver_open,
    .write =    char_driver_write,    
    .read =        char_driver_read,    
    .llseek =    char_driver_llseek,
    .release =    char_driver_release,
};
static struct miscdevice misc = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = "char_driver",
    .fops = &char_driver_fops,
};
static struct mem_dev* alloc_mem_dev(void)
{
    struct mem_dev* devp = kmalloc(sizeof(struct mem_dev), GFP_KERNEL);
    if (!devp) {
        /*申请失败*/
        return NULL;
    }   
    memset(devp, 0, sizeof(struct mem_dev));
    devp->buf = kmalloc(MEM_SIZE, GFP_KERNEL);
    if (NULL == devp->buf) {
        kfree(devp);
        return NULL;
    }
    devp->buf_size = MEM_SIZE;
    return devp; 
}
static void release_mem_dev(struct mem_dev** devp)
{
    if (NULL == devp) {
        return;
    }
    kfree((*devp)->buf);
    (*devp)->buf = NULL;
    kfree(*devp);
    *devp = NULL;
}
static int __init char_driver_init(void)
{
    int ret;
    mem_devp = alloc_mem_dev();
    if (!mem_devp)    /*申请失败*/
    {
        printk(KERN_EMERG"alloc mem_dev error!\n");
        return - ENOMEM;
    }
    ret = misc_register(&misc);
    printk(KERN_EMERG"hello driver dev_init!\n");
    return ret;
}
static void __exit char_driver_exit(void)
{
    release_mem_dev(&mem_devp);
    misc_deregister(&misc);
    printk(KERN_EMERG"hello driver dev_exit!\n");
}
MODULE_LICENSE("GPL");
module_init(char_driver_init);
module_exit(char_driver_exit);

app.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <stdlib.h> 
#include <string.h> 
int main(int argc, char *argv[])
{
    int fd;
    char buf[128] = {
    0};
    fd = open("/dev/char_driver", O_RDWR);
    if(0 > fd){
        perror("can not open 6410_led:");
    }
    write(fd, "hello driver!", 13);
    lseek(fd, SEEK_SET, 0);
    read(fd, buf, 5);
    printf("%s\n", buf);
    memset(buf, 0, sizeof(buf));
    read(fd, buf, 10);
    printf("%s\n", buf);
    close(fd);   
    return 0;
}

Makefile和上一节的一样，本节不再列出。

模块测试

编译加载模块的过程不再列出来了，分别为一下步骤：

#make
#insmod char_driver.ko

测试驱动功能
由于本驱动模拟的是一个文件的读写，那么接下来看看是否能实现功能：
在这里插入图片描述
从上图结果可知，首先我写入了“hello driver!”13个字符，分两次读取，读取结果和预期相同，至于第二次读取的内容打印出来后面有乱码，是由于我在驱动中没有记录实际写入的字节数，如果有兴趣的话可以自己尝试实现。