关联block_device结构

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的知识，这是用户空间的程序，咱们就不多说了。