五、字符设备驱动

5.1 Linux 字符设备驱动结构

5.1.1 cdev 结构体

　　在 Linux 内核中，使用 cdev 结构体描述一个字符设备。

　　

 　　使用宏可以从 dev_t 中获取主设备号和次设备号，同时也可以通过主设备号和次设备号生成 dev_t

　　

 　　cdev 的初始化：

　　

　　

 　　cdev_alloc：

　　

 　　cdev_add:

　　

 　　cdev_del：

　　

5.1.2 分配和释放设备号

　　在使用 cdev_add 函数向系统注册字符设备之前，应先调用函数来向系统申请设备号，完成此功能函数有两个：

　　

 　　

 　　在调用 cdev_del 之前，需要完成设备号的注销，注销函数如下：

　　

5.1.3 file_operations 结构体

　　此结构体是字符设备驱动程序设计的主体内容，此结构体的成员函数都对应着系统调用中 open，close 等函数。

　　

5.1.4 字符设备驱动的组成

•  字符设备驱动由以下几个部分组成：
  1. 字符设备驱动模块加载和卸载函数
     • 加载函数中实现设备号的申请和 cdev 的注册
     • 卸载函数中实现设备号的释放和 cdev 的注销
  2. 字符设备驱动的 file_operations 结构体的成员函数
     • 此结构中的成员函数是字符设备驱动和内核虚拟文件系统的接口，是用户空间对 Linux 进行系统调用的最终落实者。
     • copy_from_user() 函数完成用户空间缓冲区到内核空间的复制
     • copy_to_user() 函数完成内核空间到用户空间缓冲区的复制
     • 上面两个函数均返回不能被复制的字节数，若完成复制成功，返回0，复制失败，返回负值
     • 若复制的内存是简单类型，如 char，long，int 等，可使用简单的 put_user 和 get_user 函数
     • 内核空间虽然可以访问用户空间的缓冲区，但是在访问之前，一般需要先检查其合法性，通过 access_ok(type, addr, size) 进行判断，以确定缓冲区的确属于用户空间。

　　字符设备驱动的结构、字符设备驱动与字符设备以及字符设备驱动与用户空间访问该设备的程序之间的关系图如下：

　　

 5.2 globalmem 程序

　　实现 globalmem 全局内存字符设备驱动。

　　globalmem.c

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>


#define GLOBALMEM_SIZE      0x1000
//#define MEM_CLEAR           0X1
#define GLOBALMEM_MAGIC     'g'
#define MEM_CLEAR           _IO(GLOBALMEM_MAGIC, 0)
#define GLOBALMEM_MAJOR     230
#define DEVICE_NUMBER       10

static int globalmem_major = GLOBALMEM_MAJOR;
module_param(globalmem_major, int, S_IRUGO);

struct globalmem_dev {
    struct cdev cdev;
    unsigned char mem[GLOBALMEM_SIZE];
};

struct globalmem_dev *globalmem_devp;

/** 
 * 这里涉及到私有数据的定义，大多数遵循将文件私有数据 pirvate_data 指向设备结构体，
 * 再用 read write llseek ioctl 等函数通过 private_data 访问设备结构体。
 * 对于此驱动而言，私有数据的设置是在 open 函数中完成的
 */
static int globalmem_open(struct inode *inode, struct file *filp)
{
    /**
     *  NOTA: 
     *      container_of 的作用是通过结构体成员的指针找到对应结构体的指针。
     *      第一个参数是结构体成员的指针
     *      第二个参数是整个结构体的类型
     *      第三个参数为传入的第一个参数(即结构体成员)的类型
     *      container_of 返回值为整个结构体指针
     */ 
    struct globalmem_dev *dev = container_of(inode->i_cdev, struct globalmem_dev, cdev);
    filp->private_data = dev;
    return 0;
}

static int globalmem_release(struct inode *inode, struct file *filp)
{
    return 0;
}

static long globalmem_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    struct globalmem_dev *dev = filp->private_data;

    switch(cmd){
    case MEM_CLEAR:
        memset(dev->mem, 0, GLOBALMEM_SIZE);
        printk(KERN_INFO "globalmem is set to zero
");
        break;
    default:
        return -EINVAL;
    }

    return 0;
}

static loff_t globalmem_llseek(struct file *filp, loff_t offset, int orig)
{
    loff_t ret = 0;
    switch(orig) {
    case 0: /** 从文件开头位置 seek */
        if(offset < 0){
            ret = -EINVAL;
            break;
        }
        if((unsigned int)offset > GLOBALMEM_SIZE){
            ret = -EINVAL;
            break;
        }
        filp->f_pos = (unsigned int)offset;
        ret = filp->f_pos;
        break;
    case 1: /** 从文件当前位置开始 seek */
        if((filp->f_pos + offset) > GLOBALMEM_SIZE){
            ret = -EINVAL;
            break;
        }
        if((filp->f_pos + offset) < 0){
            ret = -EINVAL;
            break;
        }
        filp->f_pos += offset;
        ret = filp->f_pos;
        break;
    default:
        ret = -EINVAL;
        break;
    }

    return ret;
}

static ssize_t globalmem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
{
    unsigned long p = *ppos;
    unsigned int count = size;
    int ret = 0;
    struct globalmem_dev *dev = filp->private_data;

    if(p >= GLOBALMEM_SIZE)
        return 0;
    if(count > GLOBALMEM_SIZE - p)
        count = GLOBALMEM_SIZE - p;

    if(copy_from_user(dev->mem + p, buf, count))
        ret = -EFAULT;
    else {

        *ppos += count;
        ret = count;
        printk(KERN_INFO "written %u bytes(s) from %lu
", count, p);
    }

    return ret;
}

/**
 * *ppos 是要读的位置相对于文件开头的偏移，如果该偏移大于或等于 GLOBALMEM_SIZE，意味着已经独到文件末尾
 */
static ssize_t globalmem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
    unsigned long p = *ppos;
    unsigned int count = size;
    int ret = 0;
    struct globalmem_dev *dev = filp->private_data;

    if(p >= GLOBALMEM_SIZE)
        return 0;
    if(count > GLOBALMEM_SIZE - p)
        count = GLOBALMEM_SIZE - p;

    if(copy_to_user(buf, dev->mem + p, count)) {
        ret = -EFAULT;
    } else {
        *ppos += count;
        ret = count;
        printk(KERN_INFO "read %u bytes(s) from %lu
", count, p);
    }

    return ret;
}

static const struct file_operations globalmem_fops = {
    .owner = THIS_MODULE,
    .llseek = globalmem_llseek,
    .read = globalmem_read,
    .write = globalmem_write,
    .unlocked_ioctl = globalmem_ioctl,
    .open = globalmem_open,
    .release = globalmem_release,
};


/**
 * @brief  globalmem_setup_cdev     
 *
 * @param  dev
 * @param  index    次设备号
 */
static void globalmem_setup_cdev(struct globalmem_dev *dev, int index)
{
    int err;
    int devno = MKDEV(globalmem_major, index);

    /** 使用 cdev_init 即是静态初始化了 cdev */
    cdev_init(&dev->cdev, &globalmem_fops);
    dev->cdev.owner = THIS_MODULE;

    /** 设备编号范围设置为1，表示我们只申请了一个设备 */
    err = cdev_add(&dev->cdev, devno, 1);
    if(err)
        printk(KERN_NOTICE "Error %d adding globalmem%d
", err, index);
}

static int __init globalmem_init(void)
{
    int ret;
    int i;
    dev_t devno = MKDEV(globalmem_major, 0);

    if(globalmem_major)
        ret = register_chrdev_region(devno, DEVICE_NUMBER, "globalmem");
    else {
        ret = alloc_chrdev_region(&devno, 0, DEVICE_NUMBER, "gobalmem");
        globalmem_major = MAJOR(devno);
    }

    if(ret < 0)
        return ret;

    globalmem_devp = kzalloc(sizeof(struct globalmem_dev), GFP_KERNEL);
    if(!globalmem_devp){
        ret = -ENOMEM;
        goto fail_malloc;
    }

    for(i = 0; i < DEVICE_NUMBER; i++){
        globalmem_setup_cdev(globalmem_devp + i, i);
    }

fail_malloc:
    unregister_chrdev_region(devno, 1);
    return ret;
}

static void __exit globalmem_exit(void)
{
    int i;
    for(i = 0; i < DEVICE_NUMBER; i++) {
        cdev_del(&(globalmem_devp + i)->cdev);
    }
    kfree(globalmem_devp);
    unregister_chrdev_region(MKDEV(globalmem_major, 0), 1);
}

module_init(globalmem_init);
module_exit(globalmem_exit);

　　Makefile

.PHONY:all clean
ifneq ($(KERNELRELEASE),)

obj-m := globalmem.o

else
LINUX_KERNEL := $(shell uname -r)
LINUX_KERNEL_PATH := /usr/src/linux-headers-$(LINUX_KERNEL)
CURRENT_PATH  := $(shell pwd)
EXTRA_CFLAGS += -DDEBUG

all:
    make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules
clean:
    rm -fr *.ko *.o *.mod.o *.mod.c *.symvers *.order .*.ko .tmp_versions

endif

 　　验证：

　　加载

　　

　　cat /proc/devices

　　

 　　创建节点：

　　

 　　

 　　

 　　在创建了一个节点之后，同样可以再创建另外一个节点，进行读写。

　　删除模块：

　　

 　　删除模块后，/sys/module 下的 globalmem 文件夹会自动删除，但是再 /dev/ 下创建的 globalmem 节点需要使用 rm 命令手动删除，或者也可以将删除命令写入 Makefile 中，make clean 的时候自动去删除。