linux内核奇遇记之md源代码解读之八阵列同步二
转载请注明出处：http://blog.csdn.net/liumangxiong
在上一小节里讲到启动同步线程：
7824 mddev->sync_thread = md_register_thread(md_do_sync,
7825 mddev,
7826 "resync");
6697 struct md_thread *md_register_thread(void (*run) (struct mddev *), struct mddev *mddev, 6698 const char *name) 6699 { 6700 struct md_thread *thread; 6701 6702 thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL); 6703 if (!thread) 6704 return NULL; 6705 6706 init_waitqueue_head(&thread->wqueue); 6707 6708 thread->run = run; 6709 thread->mddev = mddev; 6710 thread->timeout = MAX_SCHEDULE_TIMEOUT; 6711 thread->tsk = kthread_run(md_thread, thread, 6712 "%s_%s", 6713 mdname(thread->mddev), 6714 name); 6715 if (IS_ERR(thread->tsk)) { 6716 kfree(thread); 6717 return NULL; 6718 } 6719 return thread; 6720 }
我相信所有拿过程序员证书，北大青鸟证书的哥们看这些代码是轻而易举，然而我没上过这些培训学校，也没有拿过程序员证，实在是惭愧啊。这在很大程度上拖了广大技术人员的后腿，于是心里十分忐忑，特别是上海火灾是临时工所为，火车票系统出错是程序员无证上岗所为。想想在学校时老师教育我们：难道你们四年的学习都比不上一张证书，老师四年的培养都比不上一张程序员证吗？当时准备报名考试的我顿时就羞愧难当了。然而社会就是社会从来都没有哪次求职说要程序员证。但最怕的还是有关部门，哪天都有可能被抓去判个无证上岗。
这个函数有两个看点：
6706行，初始化等待队列，在此等待队列上休眠的线程正是md_thread，那又是谁来唤醒的呢？唤醒的函数都叫wakeup，那就find symbol看一下有没有叫md wakeup的函数，果真有md_wakeup_thread()函数。所以下次看到这个函数的时候就知道轮到线程处理啦。
6711行，创建一个线程，先关心一下线程的名字，是md名和作用名的结合。当这里执行完成之后，在用户态ps一下就能看到这个线程了。除了线程名字，我们还关心这个线程做什么？运行的是md_thread()函数，这个函数只是提供了一个线程运行模板，真正做的事情是函数传进来的run函数。回到7824行，我们知道同步真正做事情的是md_do_sync。
于是我们就跟进md_do_sync函数：
7245 #define SYNC_MARKS 10
7246 #define SYNC_MARK_STEP (3*HZ)
7247 void md_do_sync(struct mddev *mddev)
7248 {
7249 struct mddev *mddev2;
7250 unsigned int currspeed = 0,
7251 window;
7252 sector_t max_sectors,j, io_sectors;
7253 unsigned long mark[SYNC_MARKS];
7254 sector_t mark_cnt[SYNC_MARKS];
7255 int last_mark,m;
7256 struct list_head *tmp;
7257 sector_t last_check;
7258 int skipped = 0;
7259 struct md_rdev *rdev;
7260 char *desc;
7261 struct blk_plug plug;
7262
7263 /* just incase thread restarts... */
7264 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
7265 return;
7266 if (mddev->ro) /* never try to sync a read-only array */
7267 return;
7268
7269 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7270 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
7271 desc = "data-check";
7272 else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7273 desc = "requested-resync";
7274 else
7275 desc = "resync";
7276 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7277 desc = "reshape";
7278 else
7279 desc = "recovery";
7264行，检查同步是否完成，再次友情提醒，这里的同步是指广义上的同步。
7266行，只读阵列就不要同步了。
7269行之后，设置线程打印信息。
7279-7345行，是用磁盘分区创建的阵列同步互斥用的。商业化的阵列没有必要用磁盘分区做阵列的，所以直接跳过。
7346 j = 0;
7347 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7348 /* resync follows the size requested by the personality,
7349 * which defaults to physical size, but can be virtual size
7350 */
7351 max_sectors = mddev->resync_max_sectors;
7352 mddev->resync_mismatches = 0;
7353 /* we don't use the checkpoint if there's a bitmap */
7354 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7355 j = mddev->resync_min;
7356 else if (!mddev->bitmap)
7357 j = mddev->recovery_cp;
7358
7359 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7360 max_sectors = mddev->resync_max_sectors;
7361 else {
7362 /* recovery follows the physical size of devices */
7363 max_sectors = mddev->dev_sectors;
7364 j = MaxSector;
7365 rcu_read_lock();
7366 rdev_for_each_rcu(rdev, mddev)
7367 if (rdev->raid_disk >= 0 &&
7368 !test_bit(Faulty, &rdev->flags) &&
7369 !test_bit(In_sync, &rdev->flags) &&
7370 rdev->recovery_offset < j)
7371 j = rdev->recovery_offset;
7372 rcu_read_unlock();
7373 }
7374
7375 printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
7376 printk(KERN_INFO "md: minimum _guaranteed_ speed:"
7377 " %d KB/sec/disk.\n", speed_min(mddev));
7378 printk(KERN_INFO "md: using maximum available idle IO bandwidth "
7379 "(but not more than %d KB/sec) for %s.\n",
7380 speed_max(mddev), desc);
7381
7382 is_mddev_idle(mddev, 1); /* this initializes IO event counters */
7347行，是同步。
7348行，同步默认是physical size，也可以是virtual size。如果你第一次阅读就能明白其中的意思，那么恭喜你是一个内核天才。如果我这一次讲完你能看懂，那么恭喜你是一个内核人才。如果看不懂也没有多大关系，毕竟大多数人都只是想混混日子而已，只要有一颗向上努力的心，始终都有市场的。想当初我也是抱着赵炯博士的linux内核完全注释足足看了七遍，整本书都已经被我笔记得体无完肤了，但是仍然只是一知半解。所以看不懂没有关系，但是要把握两点：一是要把握方法，看懂原理挑重点看，二是多动手修改几行代码试试，并且持之以恒。
那什么是physical size，什么是virtual size？物理大小就是单个磁盘用于创建阵列空间的大小，虚拟大小就是阵列大小。怎么样，终于相信自己是内核天才了吧！那为什么同步要有这样的区别呢？这就要跟阵列的特性相关了，raid5阵列是属于前者，按磁盘从头到尾同步，raid10阵列是属于后者，是按照镜像对进行同步的。
7351行，所以对于不同阵列，max_sectors代表不同的含义。
7351行，所以对于不同阵列，max_sectors代表不同的含义。
接下来是reshape和重建，跳过。
7375行，打印阵列同步信息。
7376-7380行，打印同步速度信息。同步有速度控制是为了不影响正常数据流。
7382行，初始化rdev->last_events。函数is_mddev_idle用于控制同步速度，当一小段时间内IO太多时会休眠来降低同步速度。
7384 io_sectors = 0;
7385 for (m = 0; m < SYNC_MARKS; m++) {
7386 mark[m] = jiffies;
7387 mark_cnt[m] = io_sectors;
7388 }
7389 last_mark = 0;
7390 mddev->resync_mark = mark[last_mark];
7391 mddev->resync_mark_cnt = mark_cnt[last_mark];
7392
7393 /*
7394 * Tune reconstruction:
7395 */
7396 window = 32*(PAGE_SIZE/512);
7397 printk(KERN_INFO "md: using %dk window, over a total of %lluk.\n",
7398 window/2, (unsigned long long)max_sectors/2);
7399
7400 atomic_set(&mddev->recovery_active, 0);
7401 last_check = 0;
7402
7403 if (j>2) {
7404 printk(KERN_INFO
7405 "md: resuming %s of %s from checkpoint.\n",
7406 desc, mdname(mddev));
7407 mddev->curr_resync = j;
7408 }
7409 mddev->curr_resync_completed = j;
7385-7391行，同步点记录的初始化。这里设置了几个观察点，用几个观察点之间下发的数据流速度来控制同步线程。
7396行，设置窗口大小，数据流大小这个窗口大小才进入观察点。
7400行，下发但未返回请求的大小。
7403行，继续同步的。
7409行，设置同步完成点。
7411 blk_start_plug(&plug);
7412 while (j < max_sectors) {
7413 sector_t sectors;
7414
7415 skipped = 0;
7416
7417 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
7418 ((mddev->curr_resync > mddev->curr_resync_completed &&
7419 (mddev->curr_resync - mddev->curr_resync_completed)
7420 > (max_sectors >> 4)) ||
7421 (j - mddev->curr_resync_completed)*2
7422 >= mddev->resync_max - mddev->curr_resync_completed
7423 )) {
7424 /* time to update curr_resync_completed */
7425 wait_event(mddev->recovery_wait,
7426 atomic_read(&mddev->recovery_active) == 0);
7427 mddev->curr_resync_completed = j;
7428 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7429 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
7430 }
7431
7432 while (j >= mddev->resync_max && !kthread_should_stop()) {
7433 /* As this condition is controlled by user-space,
7434 * we can block indefinitely, so use '_interruptible'
7435 * to avoid triggering warnings.
7436 */
7437 flush_signals(current); /* just in case */
7438 wait_event_interruptible(mddev->recovery_wait,
7439 mddev->resync_max > j
7440 || kthread_should_stop());
7441 }
7442
7443 if (kthread_should_stop())
7444 goto interrupted;
7445
7446 sectors = mddev->pers->sync_request(mddev, j, &skipped,
7447 currspeed < speed_min(mddev));
7448 if (sectors == 0) {
7449 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7450 goto out;
7451 }
7452
7453 if (!skipped) { /* actual IO requested */
7454 io_sectors += sectors;
7455 atomic_add(sectors, &mddev->recovery_active);
7456 }
7457
7458 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7459 break;
7460
7461 j += sectors;
7462 if (j>1) mddev->curr_resync = j;
7463 mddev->curr_mark_cnt = io_sectors;
7464 if (last_check == 0)
7465 /* this is the earliest that rebuild will be
7466 * visible in /proc/mdstat
7467 */
7468 md_new_event(mddev);
7469
7470 if (last_check + window > io_sectors || j == max_sectors)
7471 continue;
7472
7473 last_check = io_sectors;
7474 repeat:
7475 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
7476 /* step marks */
7477 int next = (last_mark+1) % SYNC_MARKS;
7478
7479 mddev->resync_mark = mark[next];
7480 mddev->resync_mark_cnt = mark_cnt[next];
7481 mark[next] = jiffies;
7482 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
7483 last_mark = next;
7484 }
7485
7486
7487 if (kthread_should_stop())
7488 goto interrupted;
7489
7490
7491 /*
7492 * this loop exits only if either when we are slower than
7493 * the 'hard' speed limit, or the system was IO-idle for
7494 * a jiffy.
7495 * the system might be non-idle CPU-wise, but we only care
7496 * about not overloading the IO subsystem. (things like an
7497 * e2fsck being done on the RAID array should execute fast)
7498 */
7499 cond_resched();
7500
7501 currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
7502 /((jiffies-mddev->resync_mark)/HZ +1) +1;
7503
7504 if (currspeed > speed_min(mddev)) {
7505 if ((currspeed > speed_max(mddev)) ||
7506 !is_mddev_idle(mddev, 0)) {
7507 msleep(500);
7508 goto repeat;
7509 }
7510 }
7511 }
7512 printk(KERN_INFO "md: %s: %s done.\n",mdname(mddev), desc);
这个循环真是长啊，为了保持完整性还是全部放在这样了。
7411行，这个函数背后还真有故事，不过是属于块层的。详细说明可参考我的另一篇博文：http://blog.csdn.net/liumangxiong/article/details/10279089
7412行，同步点小于最大同步值。
7417行，并非reshape
7418行，当前同步点大于当前同步完成位置
7419行，已下发未返回同步大小大于十六分之一总同步大小
7421行，已下发未返回同步大小*2大于等于同步检查点-当前同步完成点
这几行是什么意思呢？如果你坚持看完了前面两行并没有头晕的症状，那么恭喜你身体状况很好可以去玩跳伞等刺激活动。这几行的意思是说下发的同步请求太多了，超过这些阀值，需要停下来等待请求返回，并保存新的完成同步点。
7425行，等待同步请求返回。同步请求是按顺序下发的，但是底层的块设备不一定按原顺序完成，所以需要等待确认都返回。
7427行，保存新的同步完成点。
7428行，设置改变标志。
7429行，更新sysfs同步点。
7432行，由用户指定同步最大值，可以用于数据流很大时停止同步或其他类似用途。
7443行，设置了线程停止标志
7445行，调用pers的sync_request，每种阵列具体同步操作，这个在后面讲解
7448行，没有同步
7449行，设置同步中断标志
7453行，skipped表示bitmap认为是已同步条带，所以直接跳过。这里表示不能跳过
7454行，累计真实IO大小
7455行，累计下发同步IO大小
7461行，递增当前同步点
7462行，更新mddev当前同步点
7463行，统计用
7464行，更新/proc/stat显示
7470行，上次观察点以来下发同步IO不足窗口大小则继续下发同步请求
7475行，至少SYNC_MARK_STEP时间建立一个观察点
7501行，计算这次观察点的速度
7504行，如果小于最小速度则继续同步
7505行，如果大于最大速度或者非idle则短暂休眠再同步
7512行，看到done很开心，表示同步完成了
抛开同步具体的数据流不管，md_do_sync就只是一个简单的控制器用于控制同步的推进。
1）下发同步请求
2）记录同步观察点
3）同步速度太快则休眠
4）超过阀值，等待所有请求返回，更新同步完成点
5）转到步骤1）继续同步
继续往下看，同步完成之后还有一些事情要处理，说直接点就是要保存同步结果。
7518 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
7519
7520 /* tell personality that we are finished */
7521 mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
7522
7523 if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
7524 mddev->curr_resync > 2) {
7525 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7526 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
7527 if (mddev->curr_resync >= mddev->recovery_cp) {
7528 printk(KERN_INFO
7529 "md: checkpointing %s of %s.\n",
7530 desc, mdname(mddev));
7531 mddev->recovery_cp =
7532 mddev->curr_resync_completed;
7533 }
7534 } else
7535 mddev->recovery_cp = MaxSector;
7536 } else {
7537 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7538 mddev->curr_resync = MaxSector;
7539 rcu_read_lock();
7540 rdev_for_each_rcu(rdev, mddev)
7541 if (rdev->raid_disk >= 0 &&
7542 mddev->delta_disks >= 0 &&
7543 !test_bit(Faulty, &rdev->flags) &&
7544 !test_bit(In_sync, &rdev->flags) &&
7545 rdev->recovery_offset < mddev->curr_resync)
7546 rdev->recovery_offset = mddev->curr_resync;
7547 rcu_read_unlock();
7548 }
7549 }
7550 skip:
7551 set_bit(MD_CHANGE_DEVS, &mddev->flags);
7552
7553 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
7554 /* We completed so min/max setting can be forgotten if used. */
7555 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7556 mddev->resync_min = 0;
7557 mddev->resync_max = MaxSector;
7558 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7559 mddev->resync_min = mddev->curr_resync_completed;
7560 mddev->curr_resync = 0;
7561 wake_up(&resync_wait);
7562 set_bit(MD_RECOVERY_DONE, &mddev->recovery);
7563 md_wakeup_thread(mddev->thread);
7564 return;
7518行，等待所有同步请求返回
7521行，根据同步结果更新bitmap，回收资源
7525行，如果同步中断则设置recovery_cp为同步完成点，正常完成则设置为MaxSector。
7551行，设置改变状态
7553-7560行，恢复同步值
7561行，唤醒同磁盘分区同步等待线程
7562行，设置同步完成标志
7563行，唤醒主线程。
如果到这里就认为同步完成了，那就大错特错了。记得有一句话讲，每一个阶段的结束就是下一个阶段的起点。看到md_wake_up我们就想到事情又有了一个新起点。
在唤醒主线程之后，主线程会调用上一小节中的md_check_recovery来清理现场，最终调用到7774行的reap_sync_thread函数。对于同步来说，这个函数做了以下事情：
1）回收同步线程
2）更新超级块
3）更新mddev标志
其实阵列的同步很简单，下一小节讲raid5同步过程sync_request函数。
转载请注明出处：http://blog.csdn.net/liumangxiong
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
