关联block_device结构

最新推荐文章于 2023-06-15 20:51:46 发布

苍月代表我

最新推荐文章于 2023-06-15 20:51:46 发布

阅读量814

点赞数

1.5.3 关联block_device结构

接下来是register_disk函数，来自fs/partitions/check.c：

473 /* Not exported, helper to add_disk(). */

474 void register_disk(struct gendisk *disk)

475 {

476 struct block_device *bdev;

477 char *s;

478 int i;

479 struct hd_struct *p;

480 int err;

481

482 strlcpy(disk->kobj.name,disk->disk_name,KOBJ_NAME_LEN);

483 /* ewww... some of these buggers have / in name... */

484 s = strchr(disk->kobj.name, '/');

485 if (s)

486 *s = '!';

487 if ((err = kobject_add(&disk->kobj)))

488 return;

489 err = disk_sysfs_symlinks(disk);

490 if (err) {

491 kobject_del(&disk->kobj);

492 return;

493 }

494 disk_sysfs_add_subdirs(disk);

495

496 /* No minors to use for partitions */

497 if (disk->minors == 1)

498 goto exit;

499

500 /* No such device (e.g., media were just removed) */

501 if (!get_capacity(disk))

502 goto exit;

503

504 bdev = bdget_disk(disk, 0);

505 if (!bdev)

506 goto exit;

507

508 /* scan partition table, but suppress uevents */

509 bdev->bd_invalidated = 1;

510 disk->part_uevent_suppress = 1;

511 err = blkdev_get(bdev, FMODE_READ, 0);

512 disk->part_uevent_suppress = 0;

513 if (err < 0)

514 goto exit;

515 blkdev_put(bdev);

516

517 exit:

518 /* announce disk after possible partitions are already created */

519 kobject_uevent(&disk->kobj, KOBJ_ADD);

520

521 /* announce possible partitions */

522 for (i = 1; i < disk->minors; i++) {

523 p = disk->part[i-1];

524 if (!p || !p->nr_sects)

525 continue;

526 kobject_uevent(&p->kobj, KOBJ_ADD);

527 }

528 }

首先487行这个kobject_add的作用是很直观的，在Sysfs中为这块磁盘建一个子目录，例如我们为的硬盘建立一个块设备驱动，则会在/sys/block/目录中看到一个sdf，要是把这个调用kobject_add函数这行注释掉，肯定就看不到这个sdf目录。这里有两个问题：

第一，为什么kobject_add这么一调用，生成的这个子目录的名字就叫做“sdf”，而不叫做别的呢？其实在sd_probe中做过这么一件事情，通过精心计算得到disk_name的，而这个disk_name正是struct gendisk的一个成员，这里我们看到482行我们把disk_name给了kobj.name，这就是为什么我们调用kobject_add添加一个kobject的时候，它的名字就是我们当时的disk_name。

第二，为什么生成的这个子目录是在/sys/block目录下面，而不是在别的位置呢？还记得在alloc_disk_node中我们申请struct gendisk的情景么？kobj_set_kset_s(disk,block_subsys)做的就是让disk对应的kobject从属于block_subsys对应的kobject下面。这就是为什么我们现在添加这个kobject的时候，它很自然的就会在/sys/block子目录下面建立文件。

继续走，disk_sysfs_symlinks来自fs/partitions/check.c，这个函数虽然不短，但是比较浅显易懂。

static int disk_sysfs_symlinks(struct gendisk *disk){

struct device *target = get_device(disk->driverfs_dev);

int err;

char *disk_name = NULL;

if (target) {

disk_name = make_block_name(disk);

if (!disk_name) {

err = -ENOMEM;

goto err_out;

}

err = sysfs_create_link(&disk->kobj, &target->kobj, "device");

if (err)

goto err_out_disk_name;

err = sysfs_create_link(&target->kobj, &disk->kobj, disk_name);

if (err)

goto err_out_dev_link;

}

err = sysfs_create_link(&disk->kobj, &block_subsys.kobj,

"subsystem");

if (err)

goto err_out_disk_name_lnk;

kfree(disk_name);

return 0;

err_out_disk_name_lnk:

if (target) {

sysfs_remove_link(&target->kobj, disk_name);

err_out_dev_link:

sysfs_remove_link(&disk->kobj, "device");

err_out_disk_name:

kfree(disk_name);

err_out:

put_device(target);

}

return err;

}

我们用实际效果来解读这个函数。首先我们看正常工作的U盘会在/sys/block/sdf下面有哪些内容：

[root@localhost ~]# ls /sys/block/sdf/

capability dev device holders queue range removable size slaves stat subsystem uevent

第一个sysfs_create_link创建的就是这里这个device这个软链接文件。我们来看它链接到哪里去了：

[root@localhost ~]# ls -l /sys/block/sdf/device

lrwxrwxrwx 1 root root 0 Dec 13 07:09

/sys/block/sdf/device

-> ../../devices/pci0000:00/0000:00:1d.7/usb4/4-4/4-4:1.0/host24/target24:0:0/24:0:0:0

第二个sysfs_create_link则从那边又建立一个反链接，又给链接回来了：

[root@localhost~]# ls -l ……

lrwxrwxrwx 1 root root 0 Dec 13 21:16

/sys/devices/pci0000:00/0000:00:1d.7/usb4/4-4/4-4:1.0/host24/target24:0:0/24:0:0:0/block:sdf -> ../../../../../../../../../block/sdf

于是这就等于你中有我我中有你，你那边有一个文件链接到了我这边，我这边有一个文件链接到了你那边。第三个sysfs_create_link，生成的是/sys/block/sdf/subsystem这个软链接文件。

[root@localhost ~]# ls -l /sys/block/sdf/subsystem

lrwxrwxrwx 1 root root 0 Dec 13 07:09 /sys/block/sdf/subsystem -> ../../block

三个链接文件建立好之后，disk_sysfs_symlinks也就结束了它的使命。接下来一个函数是disk_sysfs_add_subdirs。同样来自fs/partitions/check.c：

static inline void disk_sysfs_add_subdirs(struct gendisk *disk){

struct kobject *k;

k = kobject_get(&disk->kobj);

disk->holder_dir = kobject_add_dir(k, "holders");

disk->slave_dir = kobject_add_dir(k, "slaves");

kobject_put(k);

}

这个函数的意图太明显了，无非就是建立holders和slaves两个子目录。

504行接着调用一个内联函数，bdget_disk，《Thinking in C++》告诉我们内联函数最好定义在头文件中，所以这个函数来自include/linux/genhd.h：

static inline struct block_device *bdget_disk(struct gendisk *disk, int index){

return bdget(MKDEV(disk->major, disk->first_minor) + index);

}

bdget来自fs/block_dev.c：

struct block_device *bdget(dev_t dev){

struct block_device *bdev;

struct inode *inode;

inode = iget5_locked(bd_mnt->mnt_sb, hash(dev),

bdev_test, bdev_set, &dev);

if (!inode)

return NULL;

bdev = &BDEV_I(inode)->bdev;

if (inode->i_state & I_NEW) {

bdev->bd_contains = NULL;

bdev->bd_inode = inode;

bdev->bd_block_size = (1 << inode->i_blkbits);

bdev->bd_part_count = 0;

bdev->bd_invalidated = 0;

inode->i_mode = S_IFBLK;

inode->i_rdev = dev;

inode->i_bdev = bdev;

inode->i_data.a_ops = &def_blk_aops;

mapping_set_gfp_mask(&inode->i_data, GFP_USER);

inode->i_data.backing_dev_info = &default_backing_dev_info;

spin_lock(&bdev_lock);

list_add(&bdev->bd_list, &all_bdevs);

spin_unlock(&bdev_lock);

unlock_new_inode(inode);

}

return bdev;

}

这个函数是什么意思呢，还记得前面讲过的struct block_device数据结构，以及我们的老熟人struct inode数据结构。不错，Linux中每一个Block设备都由这么一个结构体变量表示，这玩意儿因此被称作块设备描述符。inode我们不多讲，但是这里一个很重要的结构体是struct bdev_inode：

struct bdev_inode {

struct block_device bdev;

struct inode vfs_inode;

};

bdev_inode好像没出现过，用来干嘛呢？我们来看看BDEV_I函数，这个内联函数来自fs/block_dev.c：

static inline struct bdev_inode *BDEV_I(struct inode *inode){

return container_of(inode, struct bdev_inode, vfs_inode);

}

很显然，从inode得到相应的bdev_inode。于是这个&BDEV_I(inode)->bdev表示的就是inode对应的bdev_inode的成员struct block_device bdev。

但是bdev结构体变量是不会自动来到你的面前，需要的时候你要去申请才会有。iget5_locked就是干这件事情的，这个函数来自fs/inode.c，跟我们前面接触到的iget类似。我们显然不会去深入看它，只能告诉你，这个函数这么一执行，我们就既有inode又有block_device了，而且对于第一次申请的inode，其i_state成员是设置了I_NEW这个flag的，所以bdget()函数中，最后一段if语句是要被执行的。这一段if语句的作用就是初始化inode结构体指针inode以及block_device结构体指针bdev。而函数最终返回的也正是bdev。需要强调一下，bdev正是从这一刻开始正式崭露头角的。

回到register_disk()中，继续往下。下一个重量级的函数是blkdev_get，来自fs/block_dev.c：

static int __blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags,

int for_part){

struct file fake_file = {};

struct dentry fake_dentry = {};

fake_file.f_mode = mode;

fake_file.f_flags = flags;

fake_file.f_path.dentry = &fake_dentry;

fake_dentry.d_inode = bdev->bd_inode;

return do_open(bdev, &fake_file, for_part);

}

int blkdev_get(struct block_device *bdev, mode_t mode, unsigned flags){

return __blkdev_get(bdev, mode, flags, 0);

}

看到blkdev_get调用的是__blkdev_get，所以我们两个函数一块贴出来了。很显然，真正需要看的却是do_open，来自同一个文件，我们来详细讨论一下：

1110 static int do_open(struct block_device *bdev, struct file *file, int for_part)

1111 {

1112 struct module *owner = NULL;

1113 struct gendisk *disk;

1114 int ret = -ENXIO;

1115 int part;

1116

1117 file->f_mapping = bdev->bd_inode->i_mapping;

1118 lock_kernel();

1119 disk = get_gendisk(bdev->bd_dev, &part); /* part肯定为0 */

1120 if (!disk) {

1121 unlock_kernel();

1122 bdput(bdev);

1123 return ret;

1124 }

1125 owner = disk->fops->owner;

1126

1127 mutex_lock_nested(&bdev->bd_mutex, for_part);

1128 if (!bdev->bd_openers) {

1129 bdev->bd_disk = disk;

1130 bdev->bd_contains = bdev;

1131 if (!part) {

1132 struct backing_dev_info *bdi;

1133 if (disk->fops->open) {

1134 ret = disk->fops->open(bdev->bd_inode, file);

1135 if (ret)

1136 goto out_first;

1137 }

1138 if (!bdev->bd_openers) {

1139 bd_set_size(bdev,(loff_t)get_capacity(disk)<<9);

1140 bdi = blk_get_backing_dev_info(bdev);

1141 if (bdi == NULL)

1142 bdi = &default_backing_dev_info;

1143 bdev->bd_inode->i_data.backing_dev_info = bdi;

1144 }

1145 if (bdev->bd_invalidated)

1146 rescan_partitions(disk, bdev);

1147 } else {

1148 struct hd_struct *p;

1149 struct block_device *whole;

1150 whole = bdget_disk(disk, 0);

1151 ret = -ENOMEM;

1152 if (!whole)

1153 goto out_first;

1154 BUG_ON(for_part);

1155 ret = __blkdev_get(whole, file->f_mode, file->f_flags, 1);

1156 if (ret)

1157 goto out_first;

1158 bdev->bd_contains = whole;

1159 p = disk->part[part - 1];

1160 bdev->bd_inode->i_data.backing_dev_info =

1161 whole->bd_inode->i_data.backing_dev_info;

1162 if (!(disk->flags & GENHD_FL_UP) || !p || !p->nr_sects) {

1163 ret = -ENXIO;

1164 goto out_first;

1165 }

1166 kobject_get(&p->kobj);

1167 bdev->bd_part = p;

1168 bd_set_size(bdev, (loff_t) p->nr_sects << 9);

1169 }

1170 } else {

1171 put_disk(disk);

1172 module_put(owner);

1173 if (bdev->bd_contains == bdev) {

1174 if (bdev->bd_disk->fops->open) {

1175 ret = bdev->bd_disk->fops->open(bdev->bd_inode, file);

1176 if (ret)

1177 goto out;

1178 }

1179 if (bdev->bd_invalidated)

1180 rescan_partitions(bdev->bd_disk, bdev);

1181 }

1182 }

1183 bdev->bd_openers++;

1184 if (for_part)

1185 bdev->bd_part_count++;

1186 mutex_unlock(&bdev->bd_mutex);

1187 unlock_kernel();

1188 return 0;

1189

1190 out_first:

1191 bdev->bd_disk = NULL;

1192 bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;

1193 if (bdev != bdev->bd_contains)

1194 __blkdev_put(bdev->bd_contains, 1);

1195 bdev->bd_contains = NULL;

1196 put_disk(disk);

1197 module_put(owner);

1198 out:

1199 mutex_unlock(&bdev->bd_mutex);

1200 unlock_kernel();

1201 if (ret)

1202 bdput(bdev);

1203 return ret;

1204 }

一开始的时候，bd_openers是被初始化为了0，所以1128这个if语句是要被执行的。bd_openers为0表示一个文件还没有被打开过。

一开始我们还没有涉及到分区的信息，所以一开始我们只有sda这个概念，而没有sda1，sda2，sda3…这些概念。这时候我们调用get_gendisk得到的part一定是0。所以1131行的if语句也会执行。而disk->fops->open很明显，就是sd_open。(因为我们在sd_probe中曾经设置了gd->fops等于&sd_fops)

但此时此刻我们执行sd_open实际上是不做什么正经事儿的。顶多就是测试一下看看sd_open能不能执行，如果能执行，那么就返回0。如果根本就不能执行，那就赶紧汇报错误。

接下来还有几个函数，主要做一些赋值，暂时不去看它，等到适当的时候需要看了再回来看。

而1146行这个rescan_partitions()显然是我们要看的，首先我们在调用blkdev_get之前把bd_invalidated设置为了1，所以这个函数这次一定会被执行。从这一刻开始分区信息闯入了我们的生活。这个函数来自fs/partitions/check.c：

530 int rescan_partitions(struct gendisk *disk, struct block_device *bdev)

531 {

532 struct parsed_partitions *state;

533 int p, res;

534

535 if (bdev->bd_part_count)

536 return -EBUSY;

537 res = invalidate_partition(disk, 0);

538 if (res)

539 return res;

540 bdev->bd_invalidated = 0;

541 for (p = 1; p < disk->minors; p++)

542 delete_partition(disk, p);

543 if (disk->fops->revalidate_disk)

544 disk->fops->revalidate_disk(disk);

545 if (!get_capacity(disk) || !(state = check_partition(disk, bdev)))

546 return 0;

547 if (IS_ERR(state)) /* I/O error reading the partition table */

548 return -EIO;

549 for (p = 1; p < state->limit; p++) {

550 sector_t size = state->parts[p].size;

551 sector_t from = state->parts[p].from;

552 if (!size)

553 continue;

554 if (from + size > get_capacity(disk)) {

555 printk(" %s: p%d exceeds device capacity/n",

556 disk->disk_name, p);

557 }

558 add_partition(disk, p, from, size, state->parts[p].flags);

559 #ifdef CONFIG_BLK_DEV_MD

560 if (state->parts[p].flags & ADDPART_FLAG_RAID)

561 md_autodetect_dev(bdev->bd_dev+p);

562 #endif

563 }

564 kfree(state);

565 return 0;

566 }

这个函数执行过后，关于分区的信息我们就算都有了。关于分区，前面我们看到是用struct hd_struct这么个结构体来表示的，而struct hd_struct也正是struct gendisk的成员，并且是个二级指针。接着，get_capacity()。没有比这个函数更简单的函数了。来自include/linux/genhd.h：

static inline sector_t get_capacity(struct gendisk *disk){

return disk->capacity;

}

而check_partition就稍微复杂一些了，来自fs/partitions/check.c，我们就不多讲了，这个函数主要是利用parsed_partitions数据结构来记录分区信息的，并且调用check_part来专门指定一个分区表格式，然后我们就来到了add_partition，仍然是来自fs/partitions/check.c：

371 void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len, int flags)

372 {

373 struct hd_struct *p;

374

375 p = kmalloc(sizeof(*p), GFP_KERNEL);

376 if (!p)

377 return;

378

379 memset(p, 0, sizeof(*p));

380 p->start_sect = start;

381 p->nr_sects = len;

382 p->partno = part;

383 p->policy = disk->policy;

384

385 if (isdigit(disk->kobj.name[strlen(disk->kobj.name)-1]))

386 snprintf(p->kobj.name,KOBJ_NAME_LEN,"%sp%d",disk->kobj.name,part);

387 else

388 snprintf(p->kobj.name,KOBJ_NAME_LEN,"%s%d",disk->kobj.name,part);

389 p->kobj.parent = &disk->kobj;

390 p->kobj.ktype = &ktype_part;

391 kobject_init(&p->kobj);

392 kobject_add(&p->kobj);

393 if (!disk->part_uevent_suppress)

394 kobject_uevent(&p->kobj, KOBJ_ADD);

395 sysfs_create_link(&p->kobj, &block_subsys.kobj, "subsystem");

396 if (flags & ADDPART_FLAG_WHOLEDISK) {

397 static struct attribute addpartattr = {

398 .name = "whole_disk",

399 .mode = S_IRUSR | S_IRGRP | S_IROTH,

400 .owner = THIS_MODULE,

401 };

402

403 sysfs_create_file(&p->kobj, &addpartattr);

404 }

405 partition_sysfs_add_subdir(p);

406 disk->part[part-1] = p;

407 }

有了之前的经验，现在再看这些kobject相关的，sysfs相关的函数就容易多了。

389行这个p->kobj.parent = &disk->kobj保证了我们接下来生成的东西在刚才的目录之下，即sda1、sda2、…在sda目录下。而395行sysfs_create_link的效果也很显然。而partition_sysfs_add_subdir也没什么好说的，添加了holders子目录。

最后，让我们记住这个函数做过的一件事情，对p的各个成员进行了赋值，而在函数的结尾处把disk->part[part-1]指向了p。也就是说，从此以后，struct hd_struct这个指针数组里就应该有内容了，而不再是空的。

到这里，rescan_partitions()宣告结束，回到do_open()中.1183行，让bd_openers这个引用计数增加1，如果for_part有值，那么就让它对应的引用计数也加1。然后do_open也就华丽丽的结束了，像多米诺骨牌一样，__blkdev_get和blkdev_get相继返回。blkdev_put和blkdev_get做的事情基本相反，我们就不看了，只是需要注意，它把刚才增加上去的这两个引用计数给减了回去。

最后，register_disk()中调用的最后一个函数就是kobject_uevent()，这个函数就是通知用户空间的进程udevd，告诉它有事件发生了，如果你使用的发行版正确配置了udev的配置文件(详见/etc/udev/目录下)，那么其效果就是让/dev目录下面有了相应的设备文件。比如：

[root@localhost tedkdb]# ls /dev/sda*

/dev/sda /dev/sda10 /dev/sda12 /dev/sda14 /dev/sda2 /dev/sda5 /dev/sda7 /dev/sda9 /dev/sda1 /dev/sda11 /dev/sda13 /dev/sda15 /dev/sda3 /dev/sda6 /dev/sda8

至于为什么，你可以去阅读关于udev的知识，这是用户空间的程序，咱们就不多说了。