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}
341
2>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_chrdev
2096static inline void unregister_chrdev(unsigned int major, const char *name)
2097{
2098 __unregister_chrdev(major, 0, 256, name);
2099}