linux内核奇遇记之md源代码解读之八阵列同步二
转载请注明出处：http://blog.csdn.net/liumangxiong
在上一小节里讲到启动同步线程：
- 7824 mddev->sync_thread = md_register_thread(md_do_sync,
- 7825 mddev,
- 7826 "resync");
md_register_thread函数如下：
- 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
- 7264 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
- 7265 return;
- 7266 if (mddev->ro)
- 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
-
-
- 7351 max_sectors = mddev->resync_max_sectors;
- 7352 mddev->resync_mismatches = 0;
- 7353
- 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
- 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);
7347行，是同步。
7348行，同步默认是physical size，也可以是virtual size。如果你第一次阅读就能明白其中的意思，那么恭喜你是一个内核天才。如果我这一次讲完你能看懂，那么恭喜你是一个内核人才。如果看不懂也没有多大关系，毕竟大多数人都只是想混混日子而已，只要有一颗向上努力的心，始终都有市场的。想当初我也是抱着赵炯博士的linux内核完全注释足足看了七遍，整本书都已经被我笔记得体无完肤了，但是仍然只是一知半解。所以看不懂没有关系，但是要把握两点：一是要把握方法，看懂原理挑重点看，二是多动手修改几行代码试试，并且持之以恒。
那什么是physical size，什么是virtual size？物理大小就是单个磁盘用于创建阵列空间的大小，虚拟大小就是阵列大小。怎么样，终于相信自己是内核天才了吧！那为什么同步要有这样的区别呢？这就要跟阵列的特性相关了，raid5阵列是属于前者，按磁盘从头到尾同步，raid10阵列是属于后者，是按照镜像对进行同步的。
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
-
-
- 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
- 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
-
-
-
- 7437 flush_signals(current);
- 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) {
- 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
-
-
- 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
- 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
-
-
-
-
-
-
-
- 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
- 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
- 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函数。
577
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
