Linux字符设备驱动基本结构

1、Linux字符设备驱动的基本结构

Linux系统下具有三种设备，分别是字符设备、块设备和网络设备，Linux下的字符设备是指只能一个字节一个字节读写的设备，不能随机读取设备内存中某一数据，读取数据的时候需要按照先后顺序进行，字符设备是面向流的设备，常见的字符设备有鼠标、键盘、串口、控制台和LED等，接下来，简单介绍Linux字符设备驱动的基本结构。

（1）cdev结构体

在Linux内核中，使用结构体cdev对字符设备进行描述，其定义如下图所示：

struct cdev {
    struct kobject kobj;    //内嵌的kobject对象
    struct module *owner;    //所属模块
    const struct file_operations *ops;    //文件操作结构体
    struct list_head list;    //双向链表
    dev_t dev;                //设备号，高12位为主设备号，低20位为次设备号
    /*
    *MAJOR(dev_t dev)宏可获得主设备号
    *MINOR(dev_t dev)宏可获得次设备号
    *MKDEV(int major, int minor)通过主设备号和次设备号生成dev_t
    */
    unsigned int count;
} __randomize_layout;

Linux内核提供了一组函数用于对cdev结构体的操作：

void cdev_init(struct cdev *, const struct file_operations *);
struct cdev *cdev_alloc(void);
void cdev_put(struct cdev *p);
int cdev_add(struct cdev *, dev_t, unsigned);
void cdev_del(struct cdev *);

1）cdev_init()函数

cdev_init()的作用用来初始化一个cdev结构体，函数的代码如下所示：

void cdev_init(struct cdev *cdev, const struct file_operations *fops)
{
    memset(cdev, , sizeof *cdev);    //将cdev结构体的所有成员以0进行填充
    INIT_LIST_HEAD(&cdev->list);    //双向链表初始化
    kobject_init(&cdev->kobj, &ktype_cdev_default);    //kobject对象初始化
    cdev->ops = fops;    //将cdev内的file_operations成员进行赋值
}

参数：

cdev：要初始化化的cdev结构体

fops：设备的file_operations结构体

返回值：

无

2）cdev_alloc()

cdev_alloc()的作用是用来动态分配一个cdev结构体，函数的代码如下所示：

struct cdev *cdev_alloc(void)
{
    struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);//内核中动态分配内存
    if (p) {
        INIT_LIST_HEAD(&p->list);    //cdev中的双向链表成员初始化
        kobject_init(&p->kobj, &ktype_cdev_dynamic);//cdev中的kobject对象初始化
    }
    return p;
}

参数：

无

返回值：

成功：返回cdev结构体的指针

失败：返回NULL

3）cdev_put()

cdev_put()函数的作用用来释放cdev，函数的代码如下所示：

void cdev_put(struct cdev *p)
{
    if (p) {
        struct module *owner = p->owner;
        kobject_put(&p->kobj);
        module_put(owner);
    }
}

参数：

p：cdev结构体指针

返回值：

无

4）cdev_add()

cdev_add()函数用于向系统添加一个cdev，完成字符设备的注册，函数的代码如下所示：

int cdev_add(struct cdev *p, dev_t dev, unsigned count)
{
    int error;

    p->dev = dev;    //设备号
    p->count = count;    //与主设备号对应的次设备数量

    error = kobj_map(cdev_map, dev, count, NULL,
             exact_match, exact_lock, p);
    if (error)
        return error;

    kobject_get(p->kobj.parent);

    return ;
}

参数：

p：字符设备的cdev结构体指针

dev：此设备负责的第一个设备号

count：与此对应的次设备号的数量

返回值：

成功：返回0

失败：返回error号

5）cdev_del()

cdev_del()向系统删除一个cdev，用于完成字符设备的注销，函数的代码如下所示：

void cdev_del(struct cdev *p)
{
    cdev_unmap(p->dev, p->count);
    kobject_put(&p->kobj);
}

参数：

p：要在系统中移除的cdev结构体指针

返回值：

无

（2）分配和释放设备号

在使用cdev_add()向系统注册字符设备之前，需要先调用register_chrdev_region()或者alloc_chrdev_region()函数向系统申请设备号，在调用cdev_del()向系统注销字符设备之后，需要调用unregister_chrdev_region()释放原先申请的设备号。

1）register_chrdev_region()

该函数用于已知起始设备的设备号的情况，函数的原型如下所示：

int register_chrdev_region(dev_t from, unsigned count, const char *name)
{
    struct char_device_struct *cd;
    dev_t to = from + count;
    dev_t n, next;

    for (n = from; n < to; n = next) {
        next = MKDEV(MAJOR(n)+, );
        if (next > to)
            next = to;
        cd = __register_chrdev_region(MAJOR(n), MINOR(n),
                   next - n, name);
        if (IS_ERR(cd))
            goto fail;
    }
    return ;
fail:
    to = n;
    for (n = from; n < to; n = next) {
        next = MKDEV(MAJOR(n)+, );
        kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
    }
    return PTR_ERR(cd);
}

参数：

from：所需设备编号范围内的第一个，必须包括主设备号

count：所需要的连续设备编号数量

name：设备或驱动程序的名称

返回值：

成功：返回0

失败：返回负的错误号

2）alloc_chrdev_region()

该函数用于向系统动态申请未被占用的设备号，能自动避开设备号重复的冲突，函数的原型如下：

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
            const char *name)
{
    struct char_device_struct *cd;
    cd = __register_chrdev_region(, baseminor, count, name);
    if (IS_ERR(cd))
        return PTR_ERR(cd);
    *dev = MKDEV(cd->major, cd->baseminor);
    return ;
}

参数：

dev：传出参数，传出第一个分配的设备号

baseminor：所需要的第一个次设备号

count：需要的次设备号的数量

name：设备或驱动的名称

返回值：

成功：返回0

失败：返回负的错误号

3）unregister_chrdev_region()

该函数用于释放掉原先申请的设备号，函数的原型如下所示：

void unregister_chrdev_region(dev_t from, unsigned count)
{
    dev_t to = from + count;
    dev_t n, next;

    for (n = from; n < to; n = next) {
        next = MKDEV(MAJOR(n)+, );
        if (next > to)
            next = to;
        kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
    }
}

参数：

from：需要释放的设备号范围的第一个

count：需要释放的设备号的数量

返回值：

无

（3）file_operations结构体描述

file_operations结构体中的成员函数是字符设备驱动程序设计的主体内容，这些函数会在应用程序进行Linux的open、write、read、clsoe系统调用时，最终被内核进行调用，该结构体的成员函数如下所示：

struct file_operations {
    struct module *owner;
    loff_t (*llseek) (struct file *, loff_t, int);
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
    ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
    int (*iterate) (struct file *, struct dir_context *);
    int (*iterate_shared) (struct file *, struct dir_context *);
    unsigned int (*poll) (struct file *, struct poll_table_struct *);
    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    int (*mmap) (struct file *, struct vm_area_struct *);
    unsigned long mmap_supported_flags;
    int (*open) (struct inode *, struct file *);
    int (*flush) (struct file *, fl_owner_t id);
    int (*release) (struct inode *, struct file *);
    int (*fsync) (struct file *, loff_t, loff_t, int datasync);
    int (*fasync) (int, struct file *, int);
    int (*lock) (struct file *, int, struct file_lock *);
    ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
    unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
    int (*check_flags)(int);
    int (*setfl)(struct file *, unsigned long);
    int (*flock) (struct file *, int, struct file_lock *);
    ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
    ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
    int (*setlease)(struct file *, long, struct file_lock **, void **);
    long (*fallocate)(struct file *file, int mode, loff_t offset,
              loff_t len);
    void (*show_fdinfo)(struct seq_file *m, struct file *f);
#ifndef CONFIG_MMU
    unsigned (*mmap_capabilities)(struct file *);
#endif
    ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
            loff_t, size_t, unsigned int);
    int (*clone_file_range)(struct file *, loff_t, struct file *, loff_t,
            u64);
    ssize_t (*dedupe_file_range)(struct file *, u64, u64, struct file *,
            u64);
} __randomize_layout;

常用成员指针函数简单介绍：

llseek()：用来修改一个文件的当前读写位置，并将新的位置进行返回，如果出错，则函数返回一个负值；

read()：用来从设备中读取数据，成功时返回读取到的字节数，出错时，则函数返回一个负值；

write()：用于向设备发送数据，成功时返回写入的字节数，若该函数未实行时，用户进行函数调用，将得到-EINVAL返回值；

unlocked_ioctl()：提供设备相关的控制命令的实现（不是读和写操作），调用成功时，返回给调用程序一个非负值，与应用程序调用fcntl和ioctl函数相对应；

mmap()：函数将设备内存映射到进程的虚拟地址空间中，当设备驱动未实现此函数时，用户进行调用将会得到-ENODEV返回值；

open()：用于打开驱动设备，若驱动程序中不实现此函数，则设备的打开操作永远成功；

release()：与open相反，用于关闭设备；

poll()：一般用于询问设备是否可被非阻塞地立即读写；

aio_read()：对文件描述符对应的设备进行异步读操作；

aio_write()：对文件描述符对应的设备进行异步写操作。

（4）Linux字符设备驱动的组成

在Linux中，字符设备驱动主要由下面几个部分组成，分别是驱动模块的加载函数、驱动模块的卸载函数，file_operations结构体中的成员函数指针实现。

1）字符设备驱动模块加载与卸载函数

在字符设备驱动模块的加载函数中要实现设备号的申请和cdev的注册，然而在字符设备驱动模块的卸载函数中，要实现cdev的注销以及设备号的释放，常见的设备结构体，模块加载和模块卸载函数如下图所示：

struct xxx_dev_t {
    struct cdev cdev;
    ...
}
static int __init xxx_init(void)
{
    ...
    cdev_init(&xxx_dev.cdev, &xxx_fops);
    xxx_dev.cdev.owner = THIS_MODULE;

    if (xxx_major) {
        register_chrdev_region(xxx_dev_no, , DEV_NAME);
    } else {
        alloc_chrdev_region(&xxx_dev_no, , , DEV_NAME);
    }
    ret = cdev_add(&xxx_dev.cdev, xxx_dev_no, );
    ...

    return ;
}

static void __exit xxx_exit(void)
{
    unregister_chrdev_region(xxx_dev_no, );
    cdev_del(&xxx_dev.cdev);
    ...
}

2）file_operations结构体中的成员函数

file_operations结构体的成员函数是字符设备驱动与内核虚拟文件系统的接口，是用户空间对Linux系统调用的最终落实者，常见的字符设备驱动的3个函数的形式如下所示：

ssize_t xxx_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    ...
    copy_to_user(buf, ..., ...);
    ...
}

ssize_t xxx_write(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    ...
    copy_from_user(..., buf, ...);
    ...
}

long xxx_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    ...
    switch (cmd) {
    case XXX_CMD1:
        ...
        break;
    case XXX_CMD2:
        ...
        break;
    default:
        return -ENOTTY;
    }

    return ;
}

在读设备驱动函数中，filp是文件结构体指针，buf是用户空间的内存地址，count是要读取的字节数，f_pos是读的位置相对于文件开头的漂移，设备驱动写函数的参数类似，用户空间的内存地址在内核中不能直接访问，copy_from_user()完成用户空间缓冲区到内核空间的复制，而copy_to_user完成内核空间到用户空间缓冲区的复制。

3）文件操作结构体

在字符设备驱动中，需要定义一个file_operations的实例，并将具体的设备驱动函数赋值给file_operations的成员，如下所示：

struct file_operations xxx_fops {
    .owner = THIS_MODULE;
    .read = xxx_read;
    .write = xxx_write;
    .unlocked_ioctl = xxx_ioctl;
    ...
}

该file_operations结构体实例，通过cdev_init()函数与cdev进行连接。

（5）字符设备驱动的结构框图：

参考：

《Linux设备驱动开发详解：基于最新的Linux 4.0内核》

《LINUX设备驱动程序(第3版)》