linux学习--字符设备驱动

linux驱动有基本的接口进行注册和卸载，这里不再做详细说明，本文主要关注linux字符设备驱动框架实现的细节。

目录

• 1.字符设备驱动抽象结构
• 2.设备号及设备节点
  • 2.1 设备号分配与管理
  • 2.2 设备节点的生成
• 3.打开设备文件

1.字符设备驱动抽象结构

字符设备驱动管理的核心对象是字符设备，从字符设备驱动程序的设计框架出发，内核为字符设备抽象出数据结构struct cdev，定义如下：

include/linux/cdev.h
struct cdev {
    struct kobject kobj;
    struct module *owner;
    const struct file_operations *ops;
    struct list_head list;
    dev_t dev;
    unsigned int count;
};

设备驱动程序中可以有两种方式来产生struct cdev对象，一种是静态定义的方式，另一种是在程序的执行期通过动态分配。而一个struct cdev对象在被加入系统前，应该被初始化，可以通过cdev_init接口完成，具体实现如下：

void cdev_init(struct cdev *cdev, const struct file_operations *fops)
{
    memset(cdev, 0, sizeof *cdev);
    INIT_LIST_HEAD(&cdev->list);
    kobject_init(&cdev->kobj, &ktype_cdev_default);
    cdev->ops = fops;
}

2.设备号及设备节点

由于struct cdev在添加到系统时需要设备号和设备节点的知识，所以此处先做个简介。

2.1 设备号分配与管理

linux系统中设备号由主设备号和次设备号组成，内核使用主设备号来定位设备驱动程序，用次设备号来管理同类设备。使用dev_t类型变量标记设备号，具体定义如下：

include/linux/types.h
typedef __u32 __kernel_dev_t;
typedef __kernel_dev_t dev_t;

在当前版本内核，dev_t的低20位表示次设备号，高12位表示主设备号，具体定义如下：

include/linux/kdev_t.h
#define MINORBITS20
#define MINORMASK ((1U << MINORBITS) - 1)

#define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))
#define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))
#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))

字符设备涉及到设备号分配的内核函数

fs/char_dev.c
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)+1, 0);
        if (next > to)
            next = to;
        cd = __register_chrdev_region(MAJOR(n), MINOR(n), next - n, name);
        if (IS_ERR(cd))
            goto fail;
    }

    return 0;
fail:
    to = n;
    for (n = from; n < to; n = next) {
        next = MKDEV(MAJOR(n)+1, 0);
        kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
    }
    return PTR_ERR(cd);
}

该函数第一个参数表示设备号，第二个参数表示连续设备编号个数，即驱动管理的同类设备个数，第三个参数表示设备的名称，该函数的核心是__register_chrdev_region，讨论该函数前需要先看下全局指针数组chrdevs，这个数组每一项都指向一个struct char_device_struct结构，具体定义如下：

static struct char_device_struct
{
    struct char_device_struct *next;
    unsigned int major;
    unsigned int baseminor;
    int minorct;
    char name[64];
    struct cdev *cdev;/* will die */
} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];

__register_chrdev_region将当前设备驱动程序使用的设备号记录到这个数组中，首先分配一个struct char_device_struct的对象，然后对其初始化，完成后哈希遍历char devs并将这个对象添加到数组中。 在对字符设备初始化后，需要将该设备添加到内核当中，可以查看cdev_add函数定义。

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 0;
}

cdev_add函数的核心是通过kobj_map实现，后者通过操作一个全局变量cdev_map把设备加入到哈希表中，cdev_map定义如下： static struct kobj_map *cdev_map;

struct kobj_map {
    struct probe {
        struct probe *next;
        dev_t dev;
        unsigned long range;
        struct module *owner;
        kobj_probe_t *get;
        int (*lock)(dev_t, void *);
        void *data;
    } *probes[255];
    struct mutex *lock;
};

简单的说，设备驱动程序通过调用cdev_add把它所管理的设备对象指针嵌入到一个struct probe节点对象中，然后再把该节点加入到cdev_map的哈希链表中。

2.2 设备节点的生成

设备节点的创建可以使用mknod指令在/dev目录下进行创建，例如mknod /dev/demodev c 2 0，如果该指令成功执行，将会在/dev目录下生成一个demodev的字符设备节点。

而mknod实际上是通过系统调用sys_mknod进入内核空间，函数的原型asmlinkage long sys_mknod(const char __user *filename, umode_t mode, unsigned dev);

mknod首先在根目录下寻找dev目录所对应的inode，通过inode编号得到该inode的内存地址，然后通过dev的inode结构中的i_op成员指针(ext3_dir_inode_operations)，来调用该对象的mknod方法，这将导致ext3_mknod函数被调用。

ext3_mknod函数会创建一个新的inode节点，然后调用init_special_inode函数与设备相关联，具体实现如下：

void init_special_inode(struct inode *inode, umode_t mode, dev_t rdev)
{
    inode->i_mode = mode;
    if (S_ISCHR(mode)) {
        inode->i_fop = &def_chr_fops;
        inode->i_rdev = rdev;
    } else if (S_ISBLK(mode)) {
        inode->i_fop = &def_blk_fops;
        inode->i_rdev = rdev;
    } else if (S_ISFIFO(mode))
        inode->i_fop = &pipefifo_fops;
    else if (S_ISSOCK(mode))
        inode->i_fop = &bad_sock_fops;
    else
        printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o) for"" inode %s:%lu\n", mode, inode->i_sb->s_id,inode->i_ino);
}

这个函数主要是初始化inode的成员i_fop和i_rdev，其中i_rdev成员表示该inode所对应设备的设备号。

3.打开设备文件

假设已经实现了/dev/demodev的创建，我们再来看下用户空间open函数是如何打开设备文件的。

首先看下linux用户空间open函数原型，详细说明可以使用man 2 open查看，其定义int open(const char pathname, int flags, mode_t mode);

而struct file_operations结构中对应open函数原型int (*open) (struct inode *, struct file *)两者差别很大，那么用户态的open接口是如何一步步的调用到内核态的open函数呢？首先用户空间的open会产生系统调用，通过sys_open进入内核空间，而sys_open函数声明如下：

asmlinkage long sys_open(const char __user *filename, int flags, umode_t mode);

但是源码中搜寻不到sys_open函数实现，可以通过”SYSCALL_DEFINE3(open”搜索源代码，感兴趣的同学可以把这个宏展开，这里不再赘述，看下函数定义：

SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
{
    if (force_o_largefile())
    flags |= O_LARGEFILE;

    return do_sys_open(AT_FDCWD, filename, flags, mode);
}

//很明显do_sys_open才是代码核心，接着来看：
long do_sys_open(int dfd, const char __user *filename, int flags, umode_t mode)
{
    struct open_flags op;
    int lookup = build_open_flags(flags, mode, &op);
    struct filename *tmp = getname(filename);
    int fd = PTR_ERR(tmp);

    if (!IS_ERR(tmp)) {
        fd = get_unused_fd_flags(flags);
        if (fd >= 0) {
            struct file *f = do_filp_open(dfd, tmp, &op, lookup);
            if (IS_ERR(f)) {
                put_unused_fd(fd);
                fd = PTR_ERR(f);
            } else {
                fsnotify_open(f);
                fd_install(fd, f);
            }
        }
        putname(tmp);
    }

    return fd;
}

其中do_sys_open首先会调用get_unused_fd_flags为这次open操作分配一个文件描述符fd，get_unused_fd_flags实际上是对alloc_fd的封装。随后do_sys_open调用do_filp_open函数，后者会查询/dev/demodev设备文件inode，将inode结构中i_fop赋值给filp->f_op，然后调用i_fop中的open函数。在设备节点的生成时，inode->i_fop = &def_chr_fops，所以open函数直接调用chrdev_open。

const struct file_operations def_chr_fops = {
    .open = chrdev_open,
    .llseek = noop_llseek,
};

static int chrdev_open(struct inode *inode, struct file *filp)
{
    struct cdev *p;
    struct cdev *new = NULL;
    int ret = 0;

    spin_lock(&cdev_lock);
    p = inode->i_cdev;

    if (!p) {
        struct kobject *kobj;
        int idx;
        spin_unlock(&cdev_lock);
        kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);
        if (!kobj)
            return -ENXIO;
        new = container_of(kobj, struct cdev, kobj);
        spin_lock(&cdev_lock);
        /* Check i_cdev again in case somebody beat us to it while
          we dropped the lock. */
        p = inode->i_cdev;
        if (!p) {
            inode->i_cdev = p = new;
            list_add(&inode->i_devices, &p->list);
            new = NULL;
        } else if (!cdev_get(p))
            ret = -ENXIO;
    } else if (!cdev_get(p))
        ret = -ENXIO;
    spin_unlock(&cdev_lock);
    cdev_put(new);
    if (ret)
        return ret;

    ret = -ENXIO;
    filp->f_op = fops_get(p->ops);
    if (!filp->f_op)
        goto out_cdev_put;

    if (filp->f_op->open) {
        ret = filp->f_op->open(inode, filp);
        if (ret)
            goto out_cdev_put;
    }

    return 0;

out_cdev_put:
    cdev_put(p);
    return ret;
}

chrdev_open通过调用kobj_lookup在cdev_map中用inode->i_rdev来查找设备号对应的字符设备，成功找到设备后，通过filp->f_op = fops_get(p->ops)将cdev对象的ops赋值给file对象的filp成员，同时会把cdev对象保存到inode->i_cdev成员中，这时已经将file和file_operations关联起来。