linux字符设备

linux有一个全局的结构体数组，共255个元素，记录系统中的设备节点。主设备号相同，次设备号不同的设备组成链表。参考：http://edsionte.com/techblog/archives/1393

注册一个字符设备调用函数register_chrdev(major, DEV_NAME, &fops)

static inline int register_chrdev(unsigned int major, const char *name,
                  const struct file_operations *fops)
{
    return __register_chrdev(major, 0, 256, name, fops);
}
//申请次设备号最小从0开始，申请256个次设备。
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;
    //从全局的字符设备结构体数组中获取可以使用的结构体char_device_struct
    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;
}

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

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

    mutex_lock(&chrdevs_lock);
    /* temporary */
    if (major == 0) {
    //如果设备号为0，那么遍历字符设备节点的数组，查找空闲的设备号，分配给设备
        for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {
            if (chrdevs[i] == NULL)
                break;
        }

        if (i == 0) {
            ret = -EBUSY;
            goto out;
        }
        major = i;
        ret = major;
    }

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

    i = major_to_index(major);
    //遍历设备链表，将新的设备根据主设备号和次设备号添加到链表的合适位置
    //偏移主设备号
    for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
        if ((*cp)->major > major ||
            ((*cp)->major == major &&
             (((*cp)->baseminor >= baseminor) ||
              ((*cp)->baseminor + (*cp)->minorct > baseminor))))
            break;
　　 //检查次设备号的范围是否有重叠，但是这个函数一开始就已经指定了此设备0-255（256个），　　 //所以肯定会重叠，这就要求，主设备号不能与已经存在的字符设备重叠，否则注册设备必然会失败　　 //其他的函数范围可能更小，就需要下面进行判断    /* Check for overlapping minor ranges.  */
    if (*cp && (*cp)->major == major) {
        int old_min = (*cp)->baseminor;
        int old_max = (*cp)->baseminor + (*cp)->minorct - 1;
        int new_min = baseminor;
        int new_max = baseminor + minorct - 1;

        /* New driver overlaps from the left.  */
        if (new_max >= old_min && new_max <= old_max) {
            ret = -EBUSY;
            goto out;
        }

        /* New driver overlaps from the right.  */
        if (new_min <= old_max && new_min >= old_min) {
            ret = -EBUSY;
            goto out;
        }
    }
    //添加到链表中
    cd->next = *cp;
    *cp = cd;
    mutex_unlock(&chrdevs_lock);
    return cd;
out:
    mutex_unlock(&chrdevs_lock);
    kfree(cd);
    return ERR_PTR(ret);
}

另一种注册字符设备函数,过程与上面的类似。struct cdev cdev;dev_t devno;int __init test_init(void){    int ret;　　//静态分配　　//指定主设备号和次设备号，并设备好的范围是1　　//dev_t devno = MKDEV(globalmem_major, 0);　　//ret = register_chrdev_region(&devno, 1, DEV_NAME);　　　　//动态分配    ret = alloc_chrdev_region(&devno, 0, 1, DEV_NAME);    if(ret)    {           printk("alloc_chrdev_region failed!\n");        return -EAGAIN;    }       else        printk("major = %d\n", MAJOR(devno));

    cdev_init(&cdev, &fops);    cdev.owner = THIS_MODULE;

    ret = cdev_add(&cdev, devno, 1);     if(ret)    {           //释放之前分配的设备号        unregister_chrdev_region(devno, 1);         printk("cdev_add failed!\n");    }   

    return ret;}

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

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

结构体关系如下所示