Linux字符设备驱动之register_chrdev_region()系列

Linux字符设备驱动之 register_chrdev_region()函数系列1.内核中所有已分配的字符设备编号都记录在一个名为 chrdevs 散列表里。该散列表中的每一个元素是一个 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 file_operations *fops;      struct cdev *cdev;        // 指向字符设备驱动程序描述符的指针} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];1>内核并不是为每一个字符设备编号定义一个 char_device_struct 结构，而是为一组对应同一个字符设备驱动的设备编号范围定义一个 char_device_struct 结构。chrdevs 散列表的大小是 255，散列算法是把每组字符设备编号范围的主设备号以 255 取模插入相应的散列桶中。同一个散列桶中的字符设备编号范围是按起始次设备号递增排序的。2.注册内核提供了三个函数来注册一组字符设备编号，这三个函数分别是 register_chrdev_region()、alloc_chrdev_region() 和 register_chrdev()。这三个函数都会调用一个共用的 __register_chrdev_region() 函数来注册一组设备编号范围（即一个 char_device_struct 结构）。1>int register_chrdev_region(dev_t from, unsigned count, const char *name)from :要分配的设备编号范围的初始值(次设备号常设为0); Count:连续编号范围. name:编号相关联的设备名称. (/proc/devices);  2>动态分配: int alloc_chrdev_region(dev_t *dev,unsigned int firstminor,unsigned int count,char *name); firstminor是请求的最小的次编号；count是请求的连续设备编号的总数；name为设备名，返回值小于0表示分配失败。然后通过major=MMOR(dev)获取主设备号3>释放: Void unregist_chrdev_region(dev_t first,unsigned int count); 调用Documentation/devices.txt中能够找到已分配的设备号．3.__register_chrdev_region() 函数的实现代码/*  84 * Register a single major with a specified minor range.  85 *  86 * If major == 0 this functions will dynamically allocate a major and return  87 * its number.  88 *  89 * If major > 0 this function will attempt to reserve the passed range of  90 * minors and will return zero on success.  91 *  92 * Returns a -ve errno on failure.  93 */  94static struct char_device_struct *  95__register_chrdev_region(unsigned int major, unsigned int baseminor,  96                           int minorct, const char *name)  97{  98        struct char_device_struct *cd, **cp;  99        int ret = 0; 100        int i; 101 102        cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL); 103        if (cd == NULL) 104                return ERR_PTR(-ENOMEM); 105 106        mutex_lock(&chrdevs_lock); 107 108        /* temporary */ 109        if (major == 0) { 110                for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) { 111                        if (chrdevs[i] == NULL) 112                                break; 113                } 114 115                if (i == 0) { 116                        ret = -EBUSY; 117                        goto out; 118                } 119                major = i; 120                ret = major; 121        } 122 123        cd->major = major; 124        cd->baseminor = baseminor; 125        cd->minorct = minorct; 126        strlcpy(cd->name, name, sizeof(cd->name)); 127 128        i = major_to_index(major); 129 130        for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next) 131                if ((*cp)->major > major || 132                    ((*cp)->major == major && 133                     (((*cp)->baseminor >= baseminor) || 134                      ((*cp)->baseminor + (*cp)->minorct > baseminor)))) 135                        break; 136 137        /* Check for overlapping minor ranges.  */ 138        if (*cp && (*cp)->major == major) { 139                int old_min = (*cp)->baseminor; 140                int old_max = (*cp)->baseminor + (*cp)->minorct - 1; 141                int new_min = baseminor; 142                int new_max = baseminor + minorct - 1; 143 144                /* New driver overlaps from the left.  */ 145                if (new_max >= old_min && new_max <= old_max) { 146                        ret = -EBUSY; 147                        goto out; 148                } 149 150                /* New driver overlaps from the right.  */ 151                if (new_min <= old_max && new_min >= old_min) { 152                        ret = -EBUSY; 153                        goto out; 154                } 155        } 156 157        cd->next = *cp; 158        *cp = cd; 159        mutex_unlock(&chrdevs_lock); 160        return cd; 161out: 162        mutex_unlock(&chrdevs_lock); 163        kfree(cd); 164        return ERR_PTR(ret); 165} 函数 __register_chrdev_region() 主要执行以下步骤：1> 分配一个新的 char_device_struct 结构，并用 0 填充。2> 如果申请的设备编号范围的主设备号为 0，那么表示设备驱动程序请求动态分配一个主设备号。动态分配主设备号的原则是从散列表的最后一个桶向前寻找，那个桶是空的，主设备号就是相应散列桶的序号。所以动态分配的主设备号总是小于 256，如果每个桶都有字符设备编号了，那动态分配就会失败。3> 根据参数设置 char_device_struct 结构中的初始设备号，范围大小及设备驱动名称。4> 计算出主设备号所对应的散列桶，为新的 char_device_struct 结构寻找正确的位置。同时，如果设备编号范围有重复的话，则出错返回。5> 将新的 char_device_struct 结构插入散列表中，并返回 char_device_struct 结构的地址。4.分析三个注册函数1> register_chrdev_region() 186 187/** 188 * register_chrdev_region() - register a range of device numbers 189 * @from: the first in the desired range of device numbers; must include 190 *        the major number. 191 * @count: the number of consecutive device numbers required 192 * @name: the name of the device or driver. 193 * 194 * Return value is zero on success, a negative error code on failure. 195 */ 196int register_chrdev_region(dev_t from, unsigned count, const char *name) 197{ 198        struct char_device_struct *cd; 199        dev_t to = from + count; 200        dev_t n, next; 201 202        for (n = from; n < to; n = next) { 203                next = MKDEV(MAJOR(n)+1, 0); 204                if (next > to) 205                        next = to; 206                cd = __register_chrdev_region(MAJOR(n), MINOR(n), 207                               next - n, name); 208                if (IS_ERR(cd)) 209                        goto fail; 210        } 211        return 0; 212fail: 213        to = n; 214        for (n = from; n < to; n = next) { 215                next = MKDEV(MAJOR(n)+1, 0); 216                kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n)); 217        } 218        return PTR_ERR(cd);} register_chrdev_region() 函数用于分配指定的设备编号范围。如果申请的设备编号范围跨越了主设备号，它会把分配范围内的编号按主设备号分割成较小的子范围，并在每个子范围上调用 __register_chrdev_region() 。如果其中有一次分配失败的话，那会把之前成功分配的都全部退回。2> alloc_chrdev_region() 221/** 222 * alloc_chrdev_region() - register a range of char device numbers 223 * @dev: output parameter for first assigned number 224 * @baseminor: first of the requested range of minor numbers 225 * @count: the number of minor numbers required 226 * @name: the name of the associated device or driver 227 * 228 * Allocates a range of char device numbers.  The major number will be 229 * chosen dynamically, and returned (along with the first minor number) 230 * in @dev.  Returns zero or a negative error code. 231 */ 232int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, 233                        const char *name) 234{ 235        struct char_device_struct *cd; 236        cd = __register_chrdev_region(0, baseminor, count, name); 237        if (IS_ERR(cd)) 238                return PTR_ERR(cd); 239        *dev = MKDEV(cd->major, cd->baseminor); 240        return 0;}alloc_chrdev_region() 函数用于动态申请设备编号范围，这个函数好像并没有检查范围过大的情况，不过动态分配总是找个空的散列桶，所以问题也不大。通过指针参数返回实际获得的起始设备编号。3> register_chrdev()2090static inline int register_chrdev(unsigned int major, const char *name,2091                                  const struct file_operations *fops)2092{2093        return __register_chrdev(major, 0, 256, name, fops);2094}2095最后一个 register_chrdev() 是一个老式分配设备编号范围的函数。它分配一个单独主设备号和 0 ~ 255 的次设备号范围。如果申请的主设备号为 0 则动态分配一个。该函数还需传入一个 file_operations 结构的指针，函数内部自动分配了一个新的 cdev 结构。关于这些，在后续讲字符设备驱动的注册时会说明5.注销：和注册分配字符设备编号范围类似，内核提供了两个注销字符设备编号范围的函数，分别是 unregister_chrdev_region() 和 unregister_chrdev() 。它们都调用了 __unregister_chrdev_region() 函数。1>__unregister_chrdev_region() 319 320/** 321 * __unregister_chrdev - unregister and destroy a cdev 322 * @major: major device number 323 * @baseminor: first of the range of minor numbers 324 * @count: the number of minor numbers this cdev is occupying 325 * @name: name of this range of devices 326 * 327 * Unregister and destroy the cdev occupying the region described by 328 * @major, @baseminor and @count.  This function undoes what 329 * __register_chrdev() did. 330 */ 331void __unregister_chrdev(unsigned int major, unsigned int baseminor, 332                         unsigned int count, const char *name) 333{ 334        struct char_device_struct *cd; 335 336        cd = __unregister_chrdev_region(major, baseminor, count); 337        if (cd && cd->cdev) 338                cdev_del(cd->cdev); 339        kfree(cd); 340} 3412>unregister_chrdev_region() 298/** 299 * unregister_chrdev_region() - return a range of device numbers 300 * @from: the first in the range of numbers to unregister 301 * @count: the number of device numbers to unregister 302 * 303 * This function will unregister a range of @count device numbers, 304 * starting with @from.  The caller should normally be the one who 305 * allocated those numbers in the first place... 306 */ 307void unregister_chrdev_region(dev_t from, unsigned count) 308{ 309        dev_t to = from + count; 310        dev_t n, next; 311 312        for (n = from; n < to; n = next) { 313                next = MKDEV(MAJOR(n)+1, 0); 314                if (next > to) 315                        next = to; 316                kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n)); 317        }3>unregister_chrdev2096static inline void unregister_chrdev(unsigned int major, const char *name)2097{2098        __unregister_chrdev(major, 0, 256, name);2099}