设备注册和添加
1 char设备
(1) 注册
以input设备为例。
input_init()->register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
INPUT_MAX_CHAR_DEVICES, "input")
32位系统，高12bit是主设备号，低20bit是次设备号。
input_init()->register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
INPUT_MAX_CHAR_DEVICES, "input")
32位系统，高12bit是主设备号，低20bit是次设备号。
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);
//注册多个char设备，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);
}这个函数每次分配的是一组设备编号。其中from参数是这组连续设备号的起始设备号，count是这组设备号的大小（也是次设备号的个数），name参数处理本组设备的驱动名称。另外，当次设备号数目过多（count过多）的时候，次设备号可能会溢出到下一个主设备。因此我们在for语句中可以看到，首先得到下一个主设备号（其实也是一个设备号，只不过此时的次设备号为0）并存储于next中。然后判断在from的基础上再追加count个设备是否已经溢出到下一个主设备号。如果没有溢出（next小于to），那么整个for语句就只执行个一次__register_chrdev_region()函数；否则当设备号溢出时，会把当前溢出的设备号范围划分为几个小范围，分别调用__register_chrdev_region()函数。
如果在某个小范围调用__register_chrdev_region()时出现了失败，那么会将此前分配的设备号都释放。
其实register_chrdev_region()函数还没有完全说清楚设备号分配的具体过程，因为具体某个小范围的设备号是由__register_chrdev_region()函数来完成的。register_chrdev_region()函数中出现了这样一个结构char_device_struct *cd。
static struct char_device_struct {
struct char_device_struct *next;
unsigned int major;
unsigned int baseminor;
int minorct;
char name[64];
struct cdev *cdev; /* will die */
} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];
#define CHRDEV_MAJOR_HASH_SIZE 255在register_chrdev_region()函数中，在每个字符设备号的小范围上调用__register_chrdev_region()函数，都会返回一个struct char_device_struct类型的指针。因此我们可以得知，struct char_device_struct类型对应的并不是每一个字符设备，而是具有连续设备号的一组字符设备。从这个结构体内部的字段也可以看出，这组连续的设备号的主设备号为major，次设备号起始为baseminor，次设备号范围为minorct，这组设备号对应的设备驱动名称为name，cdev为指向这个字符设备驱动的指针。也就是说，每个char_device_struct对应的字符设备数是由minorct来决定的。
这里要特别说明的是，内核中所有已分配的字符设备编号都记录在一个名为chrdevs散列表里。该散列表中的每一个元素是一个 char_device_struct结构，这个散列表的大小为255（CHRDEV_MAJOR_HASH_SIZE），这是因为系统屏蔽了12位主设备号的前四位。既然说到散列表，那么肯定会出现冲突现象，因此next字段就是冲突链表中的下一个元素的指针。
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);
//为cd变量分配内存并用零来填充（这就是用kzalloc而不是kmalloc的原因）。
if (cd == NULL)
return ERR_PTR(-ENOMEM);
mutex_lock(&chrdevs_lock);
//通过P操作使得后续要执行的语句均处于临界区。
/* temporary */
/*
如果major为0，也就是未指定一个具体的主设备号，需要动态分配。那么接下来的if语句就在整个散列表中为这组设备寻找合适的位置，即从散列表的末尾开始寻找chrdevs[i]为空的情况。若找到后，那么i不仅代表这组设备的主设备号，也代表其在散列表中的关键字。但是i不会为0，0是UNNAMED_MAJOR，当然，如果主设备号实现已指定，那么可不去理会这部分代码。
*/
if (major == 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_to_index函数对其进行除模255运算，因此整个散列表关键字的范围是0～254。
*/
cd->major = major;
cd->baseminor = baseminor;
cd->minorct = minorct;
strlcpy(cd->name, name, sizeof(cd->name));
i = major_to_index(major);
/*
至此，我们通过上面的代码会得到一个有效的主设备号（如果可以继续执行下面代码的话），那么接下来还不能继续分配。正如你所知的那样，散列表中的冲突是在所难免的。因此我们得到major的值后，我们要去遍历冲突链表，为当前char_device_struct类型的变量cd去寻找正确的位置。更重要的是，我们要检查当前的次设备号范围，即baseminor~baseminor+minorct，是否和之前的已分配的次设备号（前提是major相同）范围有重叠。
下面的for循环是在冲突链表中查找合适的位置，当出现以下三种情况时，for语句会停止。
(1)如果冲突表中正被遍历的结点的主设备号（*(cp)->major）大于我们所分配的主设备号(major)，那么就可以跳出for语句，不再继续查找。此时应该说设备号分配成功了，那么cd结点只需等待被插到冲突链表当中（*cp节点之前）。
(2)如果(*cp)结点和cd结点的主设备号相同，但是前者的次设备号起点比cd结点的大，那么跳出for语句，等待下一步的范围重叠的检测。
(3)如果(*cp)结点和cd结点的主设备号相同，但是cd结点的次设备号起点小于(*cp)结点的次设备号的终点，那么会跳出for语句。此时很可能两个范围的次设备号发生了重叠。
由上面的分析可以看出，冲突表中是按照设备号递增的顺序排列的。
*/
for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
if ((*cp)->major > major ||
((*cp)->major == major &&
(((*cp)->baseminor >= baseminor) ||
((*cp)->baseminor + (*cp)->minorct > baseminor))))
break;
/*
接下来检测当主设备号相同时，次设备范围是否发生了重叠。首先依次计算出新老次设备号的范围，接着进行范围判断。第一个判断语句是检测新范围的终点是否在老范围的之间；第二个判断语句是检测新范围的起点是否在老范围之间。
*/
/* 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;
}
}
/*
当一切都正常后，就将char_device_struct描述符插入到中途链表中。至此，一次小范围的设备号分配成功。并且此时离开临界区，进行V操作。如果上述过程中有任何失败，则会跳转到out处，返回错误信息。
char_device_struct结构中的next，是一个冲突list。我们每次注册为主设备号i=major%255的一组次设备号连续的字符设备分配一个char_device_struct结构，如果是第一次注册改主设备chrdevs[i] = cd，如果是第二次注册同一主设备号的设备，检查完冲突后，就会挂到chrdevs[i]->next上了。
*/
cd->next = *cp;
*cp = cd;
mutex_unlock(&chrdevs_lock);
return cd;
out:
mutex_unlock(&chrdevs_lock);
kfree(cd);
return ERR_PTR(ret);
}全局数组chrdevs包含了255(CHRDEV_MAJOR_HASH_SIZE的值)个struct char_device_struct的元素。每一个对应一个相应的主设备号。如果分配了一个设备号,就会创建一个 struct char_device_struct 的对象，并将其添加到 chrdevs 中。这样，通过chrdevs数组，我们就可以知道分配了哪些设备号。
evdev_connect()->
cdev_init(&evdev->cdev, &evdev_fops);//引用计数refcount设为1
evdev->cdev.kobj.parent = &evdev->dev.kobj;
error = cdev_add(&evdev->cdev, evdev->dev.devt, 1);
顺便看了一下代码中的家族关系：
evdev->dev.parent = &dev->dev;(dev是input_dev->dev)
evdev->cdev.kobj.parent = &evdev->dev.kobj;
error = device_add(&evdev->dev);
parent = get_device(dev->parent);
kobj = get_device_parent(dev, parent);
if (kobj)
dev->kobj.parent = kobj;
input_dev->dev是爷爷，evdev->dev是爸爸，evdev->cdev是儿子。
cdev_init(&evdev->cdev, &evdev_fops);//引用计数refcount设为1
evdev->cdev.kobj.parent = &evdev->dev.kobj;
error = cdev_add(&evdev->cdev, evdev->dev.devt, 1);
顺便看了一下代码中的家族关系：
evdev->dev.parent = &dev->dev;(dev是input_dev->dev)
evdev->cdev.kobj.parent = &evdev->dev.kobj;
error = device_add(&evdev->dev);
parent = get_device(dev->parent);
kobj = get_device_parent(dev, parent);
if (kobj)
dev->kobj.parent = kobj;
input_dev->dev是爷爷，evdev->dev是爸爸，evdev->cdev是儿子。
(2) 添加
device_add()会创建一些文件和链接，怎么知道在哪个目录创建呢？kobj->sd记录了创建的目录。kset_register()->
kobject_add()->kobject_add_varg()->
kobject_add_internal()->create_dir()->sysfs_create_dir()->(kobj->sd = sd)
int cdev_add(struct cdev *p, dev_t dev, unsigned count)
{
int error;
p->dev = dev;
p->count = count;
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_map，块设备叫做bdev_map，里面维护了设备号到注册的设备本身数据结构的映射，最终也就拿到这设备驱动自己的核心数据结构，这一步完成了从用户态设备文件到对应在内核中的设备驱动核心数据结构的一个关系建立过程。
void __init chrdev_init(void)
{
cdev_map = kobj_map_init(base_probe, &chrdevs_lock);
bdi_init(&directly_mappable_cdev_bdi);
}
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;
};可见cdev_map对应255个probes，每个probes对应一个主设备号，设备会挂在next上。
struct kobject *kobj_lookup(struct kobj_map *domain, dev_t dev, int *index)根据设备号，在cdev_map中查找其cdev对象内嵌的kobject (probe->data->kobj)，返回的是cdev的kobject。打开一个字符设备文件会调用该函数，从而找到cdev，继而找到ops字段。
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 n = MAJOR(dev + range - 1) - MAJOR(dev) + 1;
//n是找不同主设备号的个数，通常为1
unsigned index = MAJOR(dev);
unsigned i;
struct probe *p;
if (n > 255)
n = 255;
p = kmalloc(sizeof(struct probe) * n, 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循环可以看出kobj_map中的probes数组中每个元素为一个struct probe链表的头指针。
每个链表中的probe对象有（MAJOR（probe.dev） % 255）值相同的关系。若主设备号小于255， 则每个链表中的probe都有相同的主设备号。
链表中的元素是按照range值从小到大排列的。
while循环即是找出该将p插入的位置。
*/
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;
}
2 block设备
(1) 注册
块设备也维护了一个hash表，用于记录已经组成的块设备，和字符设备的不太一样。
static struct blk_major_name {
struct blk_major_name *next;
int major;
char name[16];
} *major_names[BLKDEV_MAJOR_HASH_SIZE];
#define BLKDEV_MAJOR_HASH_SIZE 255
int register_blkdev(unsigned int major, const char *name)
{
struct blk_major_name **n, *p;
int index, ret = 0;
mutex_lock(&block_class_lock);
/* temporary */
//未指定主设备号，分配一个，index既是主设备号，也是major_names的索引
if (major == 0) {
for (index = ARRAY_SIZE(major_names)-1; index > 0; index--) {
if (major_names[index] == NULL)
break;
}
if (index == 0) {
printk("register_blkdev: failed to get major for %s\n",
name);
ret = -EBUSY;
goto out;
}
major = index;
ret = major;
}
p = kmalloc(sizeof(struct blk_major_name), GFP_KERNEL);
if (p == NULL) {
ret = -ENOMEM;
goto out;
}
p->major = major;
strlcpy(p->name, name, sizeof(p->name));
p->next = NULL;
index = major_to_index(major);
//冲突检查，冲突list一直都是NULL，并没有判断次设备号的范围
for (n = &major_names[index]; *n; n = &(*n)->next) {
if ((*n)->major == major)
break;
}
if (!*n)
*n = p;
else
ret = -EBUSY;
if (ret < 0) {
printk("register_blkdev: cannot get major %d for %s\n",
major, name);
kfree(p);
}
out:
mutex_unlock(&block_class_lock);
return ret;
}
(2) 添加
void add_disk(struct gendisk *disk)
{
struct backing_dev_info *bdi;
dev_t devt;
int retval;
/* minors == 0 indicates to use ext devt from part0 and should
* be accompanied with EXT_DEVT flag. Make sure all
* parameters make sense.
*/
WARN_ON(disk->minors && !(disk->major || disk->first_minor));
WARN_ON(!disk->minors && !(disk->flags & GENHD_FL_EXT_DEVT));
disk->flags |= GENHD_FL_UP;
retval = blk_alloc_devt(&disk->part0, &devt);//part0对应整个磁盘
if (retval) {
WARN_ON(1);
return;
}
disk_to_dev(disk)->devt = devt;
/* ->major and ->first_minor aren't supposed to be
* dereferenced from here on, but set them just in case.
*/
disk->major = MAJOR(devt);//主设备号
disk->first_minor = MINOR(devt);//第一个从设备号
disk_alloc_events(disk);
/* Register BDI before referencing it from bdev */
bdi = &disk->queue->backing_dev_info;
bdi_register_dev(bdi, disk_devt(disk));
blk_register_region(disk_devt(disk), disk->minors, NULL,
exact_match, exact_lock, disk);//minors之前已经确定，调用kobj_map()
register_disk(disk);
blk_register_queue(disk);
/*
* Take an extra ref on queue which will be put on disk_release()
* so that it sticks around as long as @disk is there.
*/
WARN_ON_ONCE(!blk_get_queue(disk->queue));
retval = sysfs_create_link(&disk_to_dev(disk)->kobj, &bdi->dev->kobj,
"bdi");
WARN_ON(retval);
disk_add_events(disk);
}
void del_gendisk(struct gendisk *disk)
{
struct disk_part_iter piter;
struct hd_struct *part;
disk_del_events(disk);
/* invalidate stuff */
disk_part_iter_init(&piter, disk,
DISK_PITER_INCL_EMPTY | DISK_PITER_REVERSE);
while ((part = disk_part_iter_next(&piter))) {
invalidate_partition(disk, part->partno);
delete_partition(disk, part->partno);
}
disk_part_iter_exit(&piter);
invalidate_partition(disk, 0);
set_capacity(disk, 0);
disk->flags &= ~GENHD_FL_UP;
sysfs_remove_link(&disk_to_dev(disk)->kobj, "bdi");
bdi_unregister(&disk->queue->backing_dev_info);
blk_unregister_queue(disk);
blk_unregister_region(disk_devt(disk), disk->minors);
part_stat_set_all(&disk->part0, 0);
disk->part0.stamp = 0;
kobject_put(disk->part0.holder_dir);
kobject_put(disk->slave_dir);
disk->driverfs_dev = NULL;
if (!sysfs_deprecated)
sysfs_remove_link(block_depr, dev_name(disk_to_dev(disk)));
pm_runtime_set_memalloc_noio(disk_to_dev(disk), false);
device_del(disk_to_dev(disk));
blk_free_devt(disk_to_dev(disk)->devt);
}
void blk_register_region(dev_t devt, unsigned long range, struct module *module,
struct kobject *(*probe)(dev_t, int *, void *),
int (*lock)(dev_t, void *), void *data)
{
kobj_map(bdev_map, devt, range, module, probe, lock, data);
}这里和字符设备类似。
初始化block设备映射表：
genhd_device_init()->
bdev_map = kobj_map_init(base_probe, &block_class_lock);