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         /* 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代表不同的含义。

接下来是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函数。