字符设备的申请和注册

设备号设计原则

 一般一个主设备号的一段连续子设备号共用一个驱动，称为cdev实例，所以有主设备号和子设备号之分

struct cdev {
    struct kobject kobj;
    struct module *owner;
    const struct file_operations *ops;
    struct list_head list;
    dev_t dev;  // 主设备号 + 第一个子设备号
    unsigned int count; // 子设备号数量
} __randomize_layout;

 

一个cdev实例共用一个 struct file_operation

设备号的申请

god@god-virtual-machine:/proc/bus/input$ cat /proc/devices
Character devices:
  1 mem
  4 /dev/vc/0
  4 tty
  4 ttyS
  5 /dev/tty
  5 /dev/console
  5 /dev/ptmx
  5 ttyprintk
  6 lp
  7 vcs
 10 misc
 13 input
......
252 ndctl
253 tpm
254 gpiochip

Block devices:
  7 loop
  8 sd
......
135 sd
253 device-mapper
254 mdp
259 blkext

由上可知，需要设备号的设备分为字符设备和块设备，数字表示主设备号

以下介绍的，无论是设备号，还是设备注册，都是指字符设备。

 

以下函数功能，包含了设备号的申请、字符设备的申请、字符设备添加到内核的全局变量

static inline int register_chrdev(unsigned int major, const char *name,
                  const struct file_operations *fops)
{
    return __register_chrdev(major, 0, 256, name, fops);
}

以下函数，只包含设备号的申请，可以跨主设备号。需要指定主设备号，所以属于静态申请设备号。from是起始设备号，由12位主设备号 + 20子设备号组成32bit值，count是申请设备号的数量

int register_chrdev_region(dev_t from, unsigned count, const char *name)

 以下函数，动态申请设备号，申请成功，设备号记录在入参的dev

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)

以下函数，只包含设备号的申请，不能跨主设备号，alloc_chrdev_region()、register_chrdev() 和 register_chrdev_region() 最终都是调用此函数进行设备号的申请

major为0表示动态申请

static struct char_device_struct *__register_chrdev_region(unsigned int major, unsigned int baseminor, int minorct, const char *name)

 

register_chrdev	设备号的申请，字符设备的申请、字符设备添加到内核的全局变量
register_chrdev_region	设备号的申请（函数名具有迷惑性，没有字符设备添加到内核功能）
alloc_chrdev_region	设备号的申请
__register_chrdev_region	设备号的申请（函数名具有迷惑性，没有字符设备添加到内核功能）

 

 

static struct char_device_struct *__register_chrdev_region(unsigned int major, unsigned int baseminor,
               int minorct, const char *name)
{
    struct char_device_struct *cd, *curr, *prev = NULL;
    int ret;
    int i;

    if (major >= CHRDEV_MAJOR_MAX) {
        pr_err("CHRDEV \"%s\" major requested (%u) is greater than the maximum (%u)\n",
               name, major, CHRDEV_MAJOR_MAX-1);
        return ERR_PTR(-EINVAL);
    }

    if (minorct > MINORMASK + 1 - baseminor) {
        pr_err("CHRDEV \"%s\" minor range requested (%u-%u) is out of range of maximum range (%u-%u) for a single major\n",
            name, baseminor, baseminor + minorct - 1, 0, MINORMASK);
        return ERR_PTR(-EINVAL);
    }

    cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);
    if (cd == NULL)
        return ERR_PTR(-ENOMEM);

    mutex_lock(&chrdevs_lock);

    if (major == 0) {
        ret = find_dynamic_major();
        if (ret < 0) {
            pr_err("CHRDEV \"%s\" dynamic allocation region is full\n",
                   name);
            goto out;
        }
        major = ret;
    }

    ret = -EBUSY;
    i = major_to_index(major);
    for (curr = chrdevs[i]; curr; prev = curr, curr = curr->next) {
        if (curr->major < major)
            continue;

        if (curr->major > major)
            break;

        if (curr->baseminor + curr->minorct <= baseminor)
            continue;

        if (curr->baseminor >= baseminor + minorct)
            break;

        goto out;
    }

    cd->major = major;
    cd->baseminor = baseminor;
    cd->minorct = minorct;
    strlcpy(cd->name, name, sizeof(cd->name));

    if (!prev) {
        cd->next = curr;
        chrdevs[i] = cd;
    } else {
        cd->next = prev->next;
        prev->next = cd;
    }

    mutex_unlock(&chrdevs_lock);
    return cd;
out:
    mutex_unlock(&chrdevs_lock);
    kfree(cd);
    return ERR_PTR(ret);
}

由此函数可知，主设备号虽然有12位，但是主设备号的范围只支持 0~511，子设备号则占满20bit。

传入的major主设备号是否为0，如果为0 则表明为动态申请内存，则调用find_dynamic_major()申请一个没有使用的主设备号。

由于主设备号是0~511，而chrdevs数组的容量是255，所以把每个数组成员都设计为链表，即每个数组成员可以对应多个主设备号

 

 上图是没有考虑子设备号情况，考虑到子设备号，实际的数据结构如下，每一个框都对应一个 struct char_device_struct 实例。

 

 

static int find_dynamic_major(void)
{
    int i;
    struct char_device_struct *cd;

    for (i = ARRAY_SIZE(chrdevs)-1; i >= CHRDEV_MAJOR_DYN_END; i--) {
        if (chrdevs[i] == NULL)
            return i;
    }

    for (i = CHRDEV_MAJOR_DYN_EXT_START; i >= CHRDEV_MAJOR_DYN_EXT_END; i--) {
        for (cd = chrdevs[major_to_index(i)]; cd; cd = cd->next)
            if (cd->major == i) // i这个主设备号已经被占了
                break;

        if (cd == NULL) // i这个设备号没有被占
            return i;
    }

    return -EBUSY;
}

先看 254 ~ 234，是否有未被占用的主设备号；再看 511 ~ 384。由此可知，动态申请的设备号只能在这两个范围内，其他用于静态分配

 

字符设备添加到内核的全局变量cdev_map

函数调用关系：

register_chrdev()

　　__register_chrdev()

　　　　__register_chrdev_region() 申请设备号

　　　　cdev_alloc()　　　　　字符设备申请

　　　　cdev_add()　　　　　　字符设备添加到内核的全局变量

static inline int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops)
{
    return __register_chrdev(major, 0, 256, name, fops);
}

 

int __register_chrdev(unsigned int major, unsigned int baseminor, unsigned int count, const char *name, const struct file_operations *fops)
{
    struct char_device_struct *cd;
    struct cdev *cdev;
    int err = -ENOMEM;

    cd = __register_chrdev_region(major, baseminor, count, name);
    if (IS_ERR(cd))
        return PTR_ERR(cd);

    cdev = cdev_alloc();
    if (!cdev)
        goto out2;

    cdev->owner = fops->owner;
    cdev->ops = fops;
    kobject_set_name(&cdev->kobj, "%s", name);

    err = cdev_add(cdev, MKDEV(cd->major, baseminor), count);
    if (err)
        goto out;

    cd->cdev = cdev;

    return major ? 0 : cd->major;
out:
    kobject_put(&cdev->kobj);
out2:
    kfree(__unregister_chrdev_region(cd->major, baseminor, count));
    return err;
}

 

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

    p->dev = dev;
    p->count = count;

    if (WARN_ON(dev == WHITEOUT_DEV))
        return -EBUSY;

    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实例对应一个主设备号的多个连续子设备，每个cdev实例都会存储在全局变量cdev_map中，类型为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;
};

 

void __init chrdev_init(void)
{
    cdev_map = kobj_map_init(base_probe, &chrdevs_lock);
}

 

struct kobj_map *kobj_map_init(kobj_probe_t *base_probe, struct mutex *lock)
{
    struct kobj_map *p = kmalloc(sizeof(struct kobj_map), GFP_KERNEL);
    struct probe *base = kzalloc(sizeof(*base), GFP_KERNEL);
    int i;

    if ((p == NULL) || (base == NULL)) {
        kfree(p);
        kfree(base);
        return NULL;
    }

    base->dev = 1;
    base->range = ~0;
    base->get = base_probe;
    for (i = 0; i < 255; i++)
        p->probes[i] = base;
    p->lock = lock;
    return p;
}

全局变量cdev_map内有一个 struct probe*类型的数组，容量为255，每个数组成员都是一个链表，使用起来和数组chrdevs一样

int kobj_map(struct kobj_map *domain, dev_t dev, unsigned long range, struct module *module, kobj_probe_t *probe, int (*lock)(dev_t, void *), void *data)
{
    unsigned int n = MAJOR(dev + range - 1) - MAJOR(dev) + 1;
    unsigned int index = MAJOR(dev);
    unsigned int i;
    struct probe *p;

    if (n > 255)
        n = 255;

    p = kmalloc_array(n, sizeof(struct probe), GFP_KERNEL);
    if (p == NULL)
        return -ENOMEM;

    for (i = 0; i < n; i++, p++) {
        p->owner = module;
        p->get = probe;
        p->lock = lock;
        p->dev = dev;
        p->range = range;
        p->data = data;
    }
    mutex_lock(domain->lock);
    for (i = 0, p -= n; i < n; i++, p++, index++) {
        struct probe **s = &domain->probes[index % 255];
        while (*s && (*s)->range < range)
            s = &(*s)->next;
        p->next = *s;
        *s = p;
    }
    mutex_unlock(domain->lock);
    return 0;
}