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);
}如果在某个小范围调用__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这里要特别说明的是，内核中所有已分配的字符设备编号都记录在一个名为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);
}
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;
}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;
};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 255int 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);
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
