1 /**
2 * register_chrdev_region() - register a range of device numbers
3 * @from: the first in the desired range of device numbers; must include
4 * the major number.
5 * @count: the number of consecutive device numbers required
6 * @name: the name of the device or driver.
7 *
8 * Return value is zero on success, a negative error code on failure.
9 */
10
11 /*register_chrdev_region函数的功能是在已知起始设备号的情况下去申请一组连续的设备号*/
12 int register_chrdev_region(dev_t from, unsigned count, const char *name)
13 {
14 struct char_device_struct *cd;
15 dev_t to = from + count;
16 dev_t n, next;
17
18 for (n = from; n < to; n = next) { /*每次申请256个设备号*/
19 next = MKDEV(MAJOR(n)+1, 0); /*先得到下一个设备号（其实也是一个设备号，只不过此时的次设备号为0）并存储于next中*/
20 if (next > to) /*溢出的情况*/ /*判断在from的基础上再追加count个设备(dev_t to = from+count)是否已经溢出到下一个主设备号*/
21 next = to;
22 /*
23 如果没有溢出（next小于to），那么整个for语句就只执行个一次__register_chrdev_region函数；
24 否则当设备号溢出时，会把当前溢出的设备号范围划分为几个小范围，分别调用__register_chrdev_region函数。
25 */
26 cd = __register_chrdev_region(MAJOR(n), MINOR(n), next - n, name); /*核心函数*/
27 if (IS_ERR(cd)) /*判断错误码*/
28 goto fail;
29 }
30 return 0;
31 fail: /*当任何一次分配失败的时候，释放所有已经申请的设备号*/
32 to = n; /*此时n=已经注册好的设备号*/
33 for (n = from; n < to; n = next) {
34 next = MKDEV(MAJOR(n)+1, 0);
35 kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n)); /*核心函数*/
36 }
37 return PTR_ERR(cd);
38 }
1 MKDEV(ma,mi)
#define MKDEV(ma,mi) ((ma)<<8 | (mi))
所以MKDEV(5, 0)，最后得到的值为【5*(2的8次幂)+0】，等于1280。
2.dev_t
typedef __u32 __kernel_dev_t;
typedef __kernel_dev_t dev_t;
3.MAJOR 和 MINOR
#define MAJOR(dev) ((dev)>>8)
#define MINOR(dev) ((dev) & 0xff)
4.major_to_index
static inline int major_to_index(int major)
{
return major % MAX_PROBE_HASH;//MAX_PROBE_HASH=255
}
5.ERR_PTR，通过指针的方式传递错误码
linux/err.h
/*
* Kernel pointers have redundant information, so we can use a
* scheme where we can return either an error code or a dentry
* pointer with the same return value.
*
* This should be a per-architecture thing, to allow different
* error and pointer decisions.
*/
static inline void *ERR_PTR(long error)
{
return (void *) error;
}
6.IS_ERR 判断错误码
static inline long IS_ERR(const void *ptr)
{
return unlikely((unsigned long)ptr > (unsigned long)-1000L);
}
1 1.struct char_device_struct结构
2 fs/char_dev.c
3 static struct char_device_struct {
4 struct char_device_struct *next; // 指向散列冲突链表中的下一个元素的指针
5 unsigned int major; // 主设备号
6 unsigned int baseminor; // 起始次设备号
7 int minorct; // 设备编号的范围大小
8 const char *name; // 处理该设备编号范围内的设备驱动的名称
9 struct file_operations *fops; // 没有使用
10 struct cdev *cdev; /* will die指向字符设备驱动程序描述符的指针*/
11 } *chrdevs[MAX_PROBE_HASH];
12
13 2.__register_chrdev_region
14 /*
15 *例子：__register_chrdev_region(5, 0, 256, “ville”);
16 *
17 * Register a single major with a specified minor range.
18 *
19 * If major == 0 this functions will dynamically allocate a major and return
20 * its number.
21 *
22 * If major > 0 this function will attempt to reserve the passed range of
23 * minors and will return zero on success.
24 *
25 * Returns a -ve errno on failure.
26 */
27 static struct char_device_struct *
28 __register_chrdev_region(unsigned int major/*5*/, unsigned int baseminor/*0*/,
29 int minorct/*256*/, const char *name/*ville*/)
30 {
31 struct char_device_struct *cd, **cp;
32 int i;
33 int ret = 0;
34
35 cd = kmalloc(sizeof(struct char_device_struct), GFP_KERNEL);/*slab分配一个char_device_struct变量*/
36 if (cd == NULL)
37 return ERR_PTR(-ENOMEM);
38
39 memset(cd, 0, sizeof(struct char_device_struct));/*将刚刚分配的变量的内存区清零*/
40
41 write_lock_irq(&chrdevs_lock);/*关中断，禁止内核抢占+读写锁*/
42
43 /* temporary */
44 if (major == 0) {/*分配一个主设备号！*/
45 for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {
46 if (chrdevs[i] == NULL)
47 break;
48 }
49
50 if (i == 0) {
51 ret = -EBUSY;
52 goto out;
53 }
54 major = i;
55 ret = major;
56 }
57
58 cd->major = major;
59 cd->baseminor = baseminor;
60 cd->minorct = minorct;/*申请设备号的个数*/
61 cd->name = name;
62 /****************以上为第一部分，处理char_device_struct变量的分配和初始化************/
63 /****************以下为第二部分，将char_device_struct变量注册到内核*****************/
64 i = major_to_index(major);/*将major对256取余数，得到可以存放char_device_struct在chrdevs中的索引*/
65
66 /*
67 *退出循环：
68 (1)chrdevs[i]为空
69 (2)chrdevs[i]的主设备号大于major
70 (3)chrdevs[i]的主设备号等于major，但是次设备号大于等于baseminor
71 */
72 for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
73 if ((*cp)->major > major ||
74 ((*cp)->major == major && (*cp)->baseminor >= baseminor))
75 break;
76 /*
77 *如果*cp不空，并且*cp的major与要申请的major相同，
78 *此时，如果(*cp)->baseminor < baseminor + minorct，就会发生冲突
79 *因为和已经分配了的设备号冲突了。
80 *出错！
81 */
82 if (*cp && (*cp)->major == major &&
83 (*cp)->baseminor < baseminor + minorct) {
84 ret = -EBUSY;
85 goto out;
86 }
87
88 /*
89 *所要申请的设备号可以满足
90 */
91 cd->next = *cp;/*按照主设备号从小到达的顺序排列*/
92 *cp = cd;
93 write_unlock_irq(&chrdevs_lock);
94 return cd;
95 out:
96 write_unlock_irq(&chrdevs_lock);
97 kfree(cd);
98 return ERR_PTR(ret);
99 }
总结：
大体上分为两个步骤：
1.char_device_struct类型变量的分配以及初始化
2.将char_device_struct变量注册到内核
1.char_device_struct类型变量的分配以及初始化
(1)首先，调用 kmalloc 分配一个 char_device_struct 变量cd。
检查返回值，进行错误处理。
(2)将分配的char_device_struct变量的内存区清零memset。
(3)获取chrdevs_lock读写锁，并且关闭中断，禁止内核抢占，write_lock_irq。
(4)如果传入的主设备号major不为0，跳转到第(7)步。
(5)这时，major为0，首先需要分配一个合适的主设备号。
将 i 赋值成 ARRAY_SIZE(chrdevs)-1，其中的 chrdevs 是包含有256个char_device_struct *类型的数组，
然后递减 i 的值，直到在chrdevs数组中出现 NULL。当chrdevs数组中不存在空值的时候，
ret = -EBUSY; goto out;
(6)到达这里，就表明主设备号major已经有合法的值了，接着进行char_device_struct变量的初始化。
设置major, baseminor, minorct以及name。
2.将char_device_struct变量注册到内核
(7)将 i 赋值成 major_to_index(major)
将major对256取余数，得到可以存放char_device_struct在chrdevs中的索引
(8)进入循环，在chrdevs[i]的链表中找到一个合适位置。
退出循环的条件：
(1)chrdevs[i]为空。
(2)chrdevs[i]的主设备号大于major。
(3)chrdevs[i]的主设备号等于major，但是次设备号大于等于baseminor。
注意：cp = &(*cp)->next，cp是char_device_struct **类型，(*cp)->next是一个char_device_struct *
类型，所以&(*cp)->next，就得到一个char_device_struct **，并且这时候由于是指针，所以
对cp赋值，就相当于对链表中的元素的next字段进行操作。
(9)进行冲突检查，因为退出循环的情况可能造成设备号冲突(产生交集)。
如果*cp不空，并且*cp的major与要申请的major相同，此时，如果(*cp)->baseminor < baseminor + minorct，
就会发生冲突，因为和已经分配了的设备号冲突了。出错就跳转到ret = -EBUSY; goto out;
(10)到这里，内核可以满足设备号的申请，将cd链接到链表中。
(11)释放chrdevs_lock读写锁，开中断，开内核抢占。
(12)返回加入链表的char_device_struct变量cd。
(13)out出错退出
a.释放chrdevs_lock读写锁，开中断，开内核抢占。
b.释放char_device_struct变量cd，kfree。
c.返回错误信息
3.__unregister_chrdev_region
static struct char_device_struct *
__unregister_chrdev_region(unsigned major, unsigned baseminor, int minorct)
{
struct char_device_struct *cd = NULL, **cp;
int i = major_to_index(major);
write_lock_irq(&chrdevs_lock);
for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
if ((*cp)->major == major &&
(*cp)->baseminor == baseminor &&
(*cp)->minorct == minorct)
break;
if (*cp) {
cd = *cp;
*cp = cd->next;
}
write_unlock_irq(&chrdevs_lock);
return cd;
}
总结：
(1)注意只有major，baseminor和minorct全都相同，才能标示一个 char_device_struct 变量。
(2)在__unregister_chrdev_region之中，并不释放内存。
三.总结
1.首先，内核使用char_device_struct 结构表示一次字符设备号的申请(针对__register_chrdev_region来说)。
其中单纯对于字符设备号管理而言，最重要的就是
struct char_device_struct *next; // 指向散列冲突链表中的下一个元素的指针
unsigned int major; // 主设备号
unsigned int baseminor; // 起始次设备号
int minorct; // 设备编号的范围大小
2.内核对字符设备号的集中管理体现在chrdevs数组中，它也是一个散列表，使用chrdevs_lock读写锁进行保护，
操作的时候，需要关闭中断，关闭内核抢占。
散列函数：major_to_index(major)，单纯的进行 major%256
使用链表处理冲突。
3.对于字符设备号申请，有可能出现，申请范围很大超出256的情况，这时候，就会在一次register_chrdev_region调用中，
产生多个char_device_struct的情况。其中只有最后一个minorct小于等于256，其余的全都等于256。
4.alloc_chrdev_region 动态的分配设备号
char_dev.c
a.参数：
dev:
仅仅作为输出参数，成功分配后将保存已分配的第一个设备编号。
baseminor:
被请求的第一个次设备号，通常是0。
count:
所要分配的设备号的个数。
name:
和所分配的设备号范围相对应的设备名称。
b.返回值：
成功返回0，失败返回负的错误编码。
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;
}
通过以上分析很好理解。
5.unregister_chrdev_region释放字符设备号
char_dev.c
a.参数：
from:
所要释放的第一个设备号。
count:
释放设备号的个数。
b.返回值：
void unregister_chrdev_region(dev_t from, unsigned count)
{
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;
kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
}
}
通过对__unregister_chrdev_region的分析，很好理解这个函数。