linux内核奇遇记之md源代码解读之三
转载请注明出处：http://blog.csdn.net/liumangxiong
这一节我们阅读阵列的创建过程。
按照常理出牌，我们到ioctl中找阵列创建命令，md对应的ioctl函数是md_ioctl，当找对应的cmd命令字时，却完全没有类似CREATE_ARRAY的命令，那么就说明md设备并不是通过ioctl函数来创建的。其实如果我们仔细阅读一下md_ioctl函数的原型就会发现其实创建md设备根本就不在这个地方，函数原型如下：
- 6303 static int md_ioctl(struct block_device *bdev, fmode_t mode,
- 6304 unsigned int cmd, unsigned long arg)
6303行，第一个参数是struct block_device*，就是说对一个块设备下发的命令，可是我们在创建md设备之前就没有对应的md块设备。
到此，线索就断了，创建设备的入口到底是在哪里呢？
此路不通，我们换一条路走。创建md设备总是要创建struct mddev结构吧，那就找哪里申请了struct mddev内存结构不就可以了吗？这个方法是可行的，可是struct mddev结构体是用kmalloc申请的，这是怎么知道的呢？因为在函数md_init中根本就没有申请struct mddev内存池的代码，只好用kmalloc申请了。我们在md.c文件中搜索kmalloc再根据结果一条条找就能找出struct mddev创建的位置。但这里我们使用一个更简便的方法，那就是申请到了struct mddev结构总要进行初始化的吧，初始化函数是mddev_init，搜索这个函数，md.c文件中只有函数mddev_find()一处调用到，很显然已经找到了struct mddev结构的创建入口了，那就接着往上层调用去找创建md设备的入口函数吧。
我们可以找到这样的调用关系，箭头表示调用关系：
mddev_find() <--- md_alloc() <--- md_probe()
md_probe()函数就是在模块初始化函数md_init()中调用的blk_register_region()函数中的传入参数，熟悉blk层的同学都知道，只要在用户态创建了一个md设备，就会相应调用到内核probe()函数，而这里传入的probe()函数正是md_probe()。所以创建struct mddev结构体是由用户态触发的，而不是由内核态直接进行的。如果到了今天这个时代，还把这种琐碎的事情放在内核态去做，你都不好意思说你是做linux开发的。做linux开发就是要引导时尚，崇尚简单才是美。linux内核只提供机制，不提供具体实现策略。跟机制不相关的控制命令就需要从内核搬到用户态，一方面简化了内核，突出重点，方便了内核维护，另一方面在用户态维护策略让应用程序更加灵活并且方便了调试。
这样我们就从内核态杀到了用户态，用户态程序就是大名鼎鼎的mdadm，网上随便一搜就是一大堆人云亦云的文章，但最好的文章不是在网上，而是用命令man mdadm。用命令mdadm create来创建一个阵列，这里不去阅读mdadm的代码，因为这是用户态程序不是我们阅读的重点，其次这些代码也很简单基本上学过初中英语的同学都能看得懂。我们需要知道的是mdadm create命令最终会调用mknod()函数来创建一个/dev/md*设备，这样内核也就相应有了struct mddev结构体，这时这个结构体还是一个空结构体，空的意思就是说这个阵列没有设置属性，没有对应的物理磁盘，没有运行阵列。
到这个时候既然已经有了md设备，那就轮到md_ioctl上场的时候了，这个函数对应的ioctl命令字在文件include\linux\raid\md_u.h：
- 36
- 37
- 38
- 39 #define RAID_VERSION _IOR (MD_MAJOR, 0x10, mdu_version_t)
- 40 #define GET_ARRAY_INFO _IOR (MD_MAJOR, 0x11, mdu_array_info_t)
- 41 #define GET_DISK_INFO _IOR (MD_MAJOR, 0x12, mdu_disk_info_t)
- 42 #define PRINT_RAID_DEBUG _IO (MD_MAJOR, 0x13)
- 43 #define RAID_AUTORUN _IO (MD_MAJOR, 0x14)
- 44 #define GET_BITMAP_FILE _IOR (MD_MAJOR, 0x15, mdu_bitmap_file_t)
- 45
- 46
- 47 #define CLEAR_ARRAY _IO (MD_MAJOR, 0x20)
- 48 #define ADD_NEW_DISK _IOW (MD_MAJOR, 0x21, mdu_disk_info_t)
- 49 #define HOT_REMOVE_DISK _IO (MD_MAJOR, 0x22)
- 50 #define SET_ARRAY_INFO _IOW (MD_MAJOR, 0x23, mdu_array_info_t)
- 51 #define SET_DISK_INFO _IO (MD_MAJOR, 0x24)
- 52 #define WRITE_RAID_INFO _IO (MD_MAJOR, 0x25)
- 53 #define UNPROTECT_ARRAY _IO (MD_MAJOR, 0x26)
- 54 #define PROTECT_ARRAY _IO (MD_MAJOR, 0x27)
- 55 #define HOT_ADD_DISK _IO (MD_MAJOR, 0x28)
- 56 #define SET_DISK_FAULTY _IO (MD_MAJOR, 0x29)
- 57 #define HOT_GENERATE_ERROR _IO (MD_MAJOR, 0x2a)
- 58 #define SET_BITMAP_FILE _IOW (MD_MAJOR, 0x2b, int)
- 59
- 60
- 61 #define RUN_ARRAY _IOW (MD_MAJOR, 0x30, mdu_param_t)
- 62
- 63 #define STOP_ARRAY _IO (MD_MAJOR, 0x32)
- 64 #define STOP_ARRAY_RO _IO (MD_MAJOR, 0x33)
- 65 #define RESTART_ARRAY_RW _IO (MD_MAJOR, 0x34)
这个文件为什么不放在md目录而放在include目录下？是因为文件里的内容是用户态跟内核态共用的，如果是内核态单独用的就没有必要放在这里了。
对于阵列的创建流程，最关心的命令字有：
SET_ARRAY_INFO 设置阵列信息
ADD_NEW_DISK 添加磁盘到阵列
RUN_ARRAY 运行阵列
首先看设置阵列信息，这个函数是这三个函数中最简单的一个：
- 6000
-
-
-
-
-
-
-
-
-
-
-
-
- 6013 static int set_array_info(struct mddev * mddev, mdu_array_info_t *info)
- 6014 {
- 6015
- 6016 if (info->raid_disks == 0) {
- 6017
- 6018 if (info->major_version < 0 ||
- 6019 info->major_version >= ARRAY_SIZE(super_types) ||
- 6020 super_types[info->major_version].name == NULL) {
- 6021
- 6022 printk(KERN_INFO
- 6023 "md: superblock version %d not known\n",
- 6024 info->major_version);
- 6025 return -EINVAL;
- 6026 }
- 6027 mddev->major_version = info->major_version;
- 6028 mddev->minor_version = info->minor_version;
- 6029 mddev->patch_version = info->patch_version;
- 6030 mddev->persistent = !info->not_persistent;
- 6031
-
-
- 6034 mddev->ctime = get_seconds();
- 6035 return 0;
- 6036 }
- 6037 mddev->major_version = MD_MAJOR_VERSION;
- 6038 mddev->minor_version = MD_MINOR_VERSION;
- 6039 mddev->patch_version = MD_PATCHLEVEL_VERSION;
- 6040 mddev->ctime = get_seconds();
- 6041
- 6042 mddev->level = info->level;
- 6043 mddev->clevel[0] = 0;
- 6044 mddev->dev_sectors = 2 * (sector_t)info->size;
- 6045 mddev->raid_disks = info->raid_disks;
- 6046
-
-
- 6049 if (info->state & (1<<MD_SB_CLEAN))
- 6050 mddev->recovery_cp = MaxSector;
- 6051 else
- 6052 mddev->recovery_cp = 0;
- 6053 mddev->persistent = ! info->not_persistent;
- 6054 mddev->external = 0;
- 6055
- 6056 mddev->layout = info->layout;
- 6057 mddev->chunk_sectors = info->chunk_size >> 9;
- 6058
- 6059 mddev->max_disks = MD_SB_DISKS;
- 6060
- 6061 if (mddev->persistent)
- 6062 mddev->flags = 0;
- 6063 set_bit(MD_CHANGE_DEVS, &mddev->flags);
- 6064
- 6065 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
- 6066 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
- 6067 mddev->bitmap_info.offset = 0;
- 6068
- 6069 mddev->reshape_position = MaxSector;
- 6070
- 6071
-
-
- 6074 get_random_bytes(mddev->uuid, 16);
- 6075
- 6076 mddev->new_level = mddev->level;
- 6077 mddev->new_chunk_sectors = mddev->chunk_sectors;
- 6078 mddev->new_layout = mddev->layout;
- 6079 mddev->delta_disks = 0;
- 6080 mddev->reshape_backwards = 0;
- 6081
- 6082 return 0;
- 6083 }
首先看注释，这个函数有两种用途，一是用于创建阵列，当创建阵列时，raid_disk>0，另一种用途是assemble阵列，这时raid_disk==0。
那这里的raid_disk到底是多少呢？注释里又有这样的一句话，如果raid_disk>0，那么直接创建0.90阵列超级块，很显然，我们要创建的阵列超级块是1.2的，所以6037-6080只是用于兼容老版本的阵列的，需要阅读的代码只有6016行if语句中的那几行代码。
6027-6029行，设置阵列超级块版本号。
6030行，设置persistent属性，就是说超级块是保存在磁盘上还是只放在内存中啊，这里我们都是保存在磁盘上，以后看到这个属性就永远为true。
6034行，设置阵列创建时间。
那么是在什么时候才开始设置阵列属性呢？比如说阵列级别？别急，好戏还在后头。
接着看ADD_NEW_DISK对应的处理函数：
- 5672 static int add_new_disk(struct mddev * mddev, mdu_disk_info_t *info)
- 5673 {
- 5674 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
- 5675 struct md_rdev *rdev;
- 5676 dev_t dev = MKDEV(info->major,info->minor);
- 5677
- 5678 if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
- 5679 return -EOVERFLOW;
- 5680
- 5681 if (!mddev->raid_disks) {
- 5682 int err;
- 5683
- 5684 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
- 5685 if (IS_ERR(rdev)) {
- 5686 printk(KERN_WARNING
- 5687 "md: md_import_device returned %ld\n",
- 5688 PTR_ERR(rdev));
- 5689 return PTR_ERR(rdev);
- 5690 }
- 5691 if (!list_empty(&mddev->disks)) {
- 5692 struct md_rdev *rdev0
- 5693 = list_entry(mddev->disks.next,
- 5694 struct md_rdev, same_set);
- 5695 err = super_types[mddev->major_version]
- 5696 .load_super(rdev, rdev0, mddev->minor_version);
- 5697 if (err < 0) {
- 5698 printk(KERN_WARNING
- 5699 "md: %s has different UUID to %s\n",
- 5700 bdevname(rdev->bdev,b),
- 5701 bdevname(rdev0->bdev,b2));
- 5702 export_rdev(rdev);
- 5703 return -EINVAL;
- 5704 }
- 5705 }
- 5706 err = bind_rdev_to_array(rdev, mddev);
- 5707 if (err)
- 5708 export_rdev(rdev);
- 5709 return err;
- 5710 }
这个函数只截取了一部分，因为这一次添加磁盘流程只会走到这一部分代码，首先注意到函数的参数：第一个参数是struct mddev结构体，这个结构体域比较多，我们会在后面用到具体域时再讲，第二个参数是表示一个要加入阵列的磁盘，这里用到了该结构体的两个域，major和minor，表示磁盘主设备号和次设备号。
5676行，根据主设备号和次设备号算出dev_t。
5678行，这里为什么还要再检查一下呢？返回的错误码叫溢出，意思是说很久很久以前linux中设备还不是很多的时候dev_t只要用16位来表示就可以了，然而随着linux服务器单一种类外设数量越来越多，dev_t扩展到32位，所以这里检查保证输入major，minor的正确。
5681行，这里还未添加磁盘，所以进入这个if分支。
5684行，创建磁盘struct md_rdev结构，继续跟入到函数中：
- 3236
-
-
-
-
-
-
-
-
-
- 3246 static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
- 3247 {
- 3248 char b[BDEVNAME_SIZE];
- 3249 int err;
- 3250 struct md_rdev *rdev;
- 3251 sector_t size;
- 3252
- 3253 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
- 3254 if (!rdev) {
- 3255 printk(KERN_ERR "md: could not alloc mem for new device!\n");
- 3256 return ERR_PTR(-ENOMEM);
- 3257 }
- 3258
- 3259 err = md_rdev_init(rdev);
- 3260 if (err)
- 3261 goto abort_free;
- 3262 err = alloc_disk_sb(rdev);
- 3263 if (err)
- 3264 goto abort_free;
- 3265
- 3266 err = lock_rdev(rdev, newdev, super_format == -2);
- 3267 if (err)
- 3268 goto abort_free;
- 3269
- 3270 kobject_init(&rdev->kobj, &rdev_ktype);
- 3271
- 3272 size = i_size_read(rdev->bdev->bd_inode) >> BLOCK_SIZE_BITS;
- 3273 if (!size) {
- 3274 printk(KERN_WARNING
- 3275 "md: %s has zero or unknown size, marking faulty!\n",
- 3276 bdevname(rdev->bdev,b));
- 3277 err = -EINVAL;
- 3278 goto abort_free;
- 3279 }
- 3280
- 3281 if (super_format >= 0) {
- 3282 err = super_types[super_format].
- 3283 load_super(rdev, NULL, super_minor);
- 3284 if (err == -EINVAL) {
- 3285 printk(KERN_WARNING
- 3286 "md: %s does not have a valid v%d.%d "
- 3287 "superblock, not importing!\n",
- 3288 bdevname(rdev->bdev,b),
- 3289 super_format, super_minor);
- 3290 goto abort_free;
- 3291 }
- 3292 if (err < 0) {
- 3293 printk(KERN_WARNING
- 3294 "md: could not read %s's sb, not importing!\n",
- 3295 bdevname(rdev->bdev,b));
- 3296 goto abort_free;
- 3297 }
- 3298 }
- 3299 if (super_format == -1)
- 3300
- 3301 rdev->badblocks.shift = -1;
- 3302
- 3303 return rdev;
- 3304
- 3305 abort_free:
- 3306 if (rdev->bdev)
- 3307 unlock_rdev(rdev);
- 3308 md_rdev_clear(rdev);
- 3309 kfree(rdev);
- 3310 return ERR_PTR(err);
- 3311 }
3252行，创建一个struct md_rdev结构体。
3259行，初始化struct md_rdev结构体。
3262行，申请一个page页，用于存放磁盘超级块信息。
3266行，对磁盘加锁，防止被其他程序操作如mount, 分区等。
3270行，初始化struct md_rdev磁盘kobject结构。
3272行，读磁盘大小，判断是否合法。
3281行，阵列超级块是1.2版本的，进入if分支。
3282行，读入阵列超级块信息，具体调用的函数是：
- 1450 static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
这个函数很简单，根据超级块版本从磁盘上读入阵列超级块信息并保存到md_rdev->sb_page中，做一些基本的校验和检查，并将超级块信息保存到struct md_rdev结构中。到这里就返回到add_new_disk函数，5684行返回的rdev就含有从磁盘上加载的超级块信息。
5691行，由于阵列中还没有磁盘，所以list_empty(&mddev->disks)成立，不会进入if分支。
5706行，建立阵列struct mddev和磁盘struct md_rdev结构之间的联系，进函数：
- 2077 static int bind_rdev_to_array(struct md_rdev * rdev, struct mddev * mddev)
- 2078 {
- 2079 char b[BDEVNAME_SIZE];
- 2080 struct kobject *ko;
- 2081 char *s;
- 2082 int err;
- 2083
- 2084 if (rdev->mddev) {
- 2085 MD_BUG();
- 2086 return -EINVAL;
- 2087 }
- 2088
- 2089
- 2090 if (find_rdev(mddev, rdev->bdev->bd_dev))
- 2091 return -EEXIST;
- 2092
- 2093
- 2094 if (rdev->sectors && (mddev->dev_sectors == 0 ||
- 2095 rdev->sectors < mddev->dev_sectors)) {
- 2096 if (mddev->pers) {
- 2097
-
-
-
- 2101 if (mddev->level > 0)
- 2102 return -ENOSPC;
- 2103 } else
- 2104 mddev->dev_sectors = rdev->sectors;
- 2105 }
- 2106
- 2107
-
-
-
- 2111 if (rdev->desc_nr < 0) {
- 2112 int choice = 0;
- 2113 if (mddev->pers) choice = mddev->raid_disks;
- 2114 while (find_rdev_nr(mddev, choice))
- 2115 choice++;
- 2116 rdev->desc_nr = choice;
- 2117 } else {
- 2118 if (find_rdev_nr(mddev, rdev->desc_nr))
- 2119 return -EBUSY;
- 2120 }
- 2121 if (mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
- 2122 printk(KERN_WARNING "md: %s: array is limited to %d devices\n",
- 2123 mdname(mddev), mddev->max_disks);
- 2124 return -EBUSY;
- 2125 }
- 2126 bdevname(rdev->bdev,b);
- 2127 while ( (s=strchr(b, '/')) != NULL)
- 2128 *s = '!';
- 2129
- 2130 rdev->mddev = mddev;
- 2131 printk(KERN_INFO "md: bind<%s>\n", b);
- 2132
- 2133 if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
- 2134 goto fail;
- 2135
- 2136 ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
- 2137 if (sysfs_create_link(&rdev->kobj, ko, "block"))
- 2138 ;
- 2139 rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
- 2140
- 2141 list_add_rcu(&rdev->same_set, &mddev->disks);
- 2142 bd_link_disk_holder(rdev->bdev, mddev->gendisk);
- 2143
- 2144
- 2145 mddev->recovery_disabled++;
- 2146
- 2147 return 0;
- 2148
- 2149 fail:
- 2150 printk(KERN_WARNING "md: failed to register dev-%s for %s\n",
- 2151 b, mdname(mddev));
- 2152 return err;
- 2153 }
2090行，检查是否磁盘已经加入阵列了，加过就不必重复添加。
2094-2105行，比较磁盘大小，记录最小的磁盘空间。
2111行，desc_nr分配，这个号只描述加入阵列的早晚。
2130行，建立struct md_rdev到mddev的关联。
2133-2139行，建立sysfs相关状态和链接。
2141行，建立mddev到struct md_rdev的关联。
add_new_disk就这么快结束了，简单地说就是创建struct md_rdev结构并与struct mddev结构之间创建联系。
第三个命令字RUN_ARRAY的处理过程具有重要的意义，并且其过程不是三言两语能够说完的，我们把该命令字处理流程放到下一个小节单独来讲。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
