linux内核奇遇记之md源代码解读之十raid5数据流之同步数据流程
转载请注明出处：http://blog.youkuaiyun.com/liumangxiong
上一节讲到在raid5的同步函数sync_request中炸土豆片是通过handle_stripe来进行的。从最初的创建阵列，到申请各种资源，建立每个阵列的personality，所有的一切都是为了迎接数据流而作的准备。就像我们寒窗苦读就是为了上大学一样。数据流的过程就像大学校园一样丰富多彩并且富有挑战性，但只要跨过了这道坎，内核代码将不再神秘，剩下的问题只是时间而已。
首先看handle_stripe究竟把我们的土豆片带往何处：
- 3379 static void handle_stripe(struct stripe_head *sh)
- 3380 {
- 3381 struct stripe_head_state s;
- 3382 struct r5conf *conf = sh->raid_conf;
- 3383 int i;
- 3384 int prexor;
- 3385 int disks = sh->disks;
- 3386 struct r5dev *pdev, *qdev;
- 3387
- 3388 clear_bit(STRIPE_HANDLE, &sh->state);
- 3389 if (test_and_set_bit_lock(STRIPE_ACTIVE, &sh->state)) {
- 3390
-
- 3392 set_bit(STRIPE_HANDLE, &sh->state);
- 3393 return;
- 3394 }
- 3395
- 3396 if (test_and_clear_bit(STRIPE_SYNC_REQUESTED, &sh->state)) {
- 3397 set_bit(STRIPE_SYNCING, &sh->state);
- 3398 clear_bit(STRIPE_INSYNC, &sh->state);
- 3399 }
- 3400 clear_bit(STRIPE_DELAYED, &sh->state);
- 3401
- 3402 pr_debug("handling stripe %llu, state=%#lx cnt=%d, "
- 3403 "pd_idx=%d, qd_idx=%d\n, check:%d, reconstruct:%d\n",
- 3404 (unsigned long long)sh->sector, sh->state,
- 3405 atomic_read(&sh->count), sh->pd_idx, sh->qd_idx,
- 3406 sh->check_state, sh->reconstruct_state);
- 3407
- 3408 analyse_stripe(sh, &s);
这个函数代码比较长先贴第一部分，分析条带。分析的作用就是根据条带的状态做一些预处理，根据这些状态再来判断下一步应该做什么具体操作。比如说同步，那么首先会读数据盘，等读回来之后，再校验，然后再写校验值。但是这些步骤又不是一次性在handle_stripe里就完成的，因为跟磁盘IO都是异步的，所以必要要等上一次磁盘请求回调之后再次调用handle_stripe，通常每个数据流都会多次进入handle_stripe，而每一次进入经过的代码流程是不大一样的。
struct stripe_head有很多状态，这些状态决定条带应该怎么处理，所以必须非常小心处理这些标志，这些标志很多，现在先简单地过一下。
- enum {
- STRIPE_ACTIVE,
- STRIPE_HANDLE,
- STRIPE_SYNC_REQUESTED,
- STRIPE_SYNCING,
- STRIPE_INSYNC,
- STRIPE_PREREAD_ACTIVE,
- STRIPE_DELAYED,
- STRIPE_DEGRADED,
- STRIPE_BIT_DELAY,
- STRIPE_EXPANDING,
- STRIPE_EXPAND_SOURCE,
- STRIPE_EXPAND_READY,
- STRIPE_IO_STARTED,
- STRIPE_FULL_WRITE,
- STRIPE_BIOFILL_RUN,
- STRIPE_COMPUTE_RUN,
- STRIPE_OPS_REQ_PENDING,
- STRIPE_ON_UNPLUG_LIST,
- };
3388行，清除需要处理标志。
3389行，设置正在处理标志。
3392行，如果已经在处理则设置下次处理标志并返回。
3396行，如果是同步请求。
3397行，设置正在处理同步标志。
3398行，清除已同步标志。
3400行，清除延迟处理标志。
3408行，分析stripe，这个函数很长分几段来说明：
- 3198 static void analyse_stripe(struct stripe_head *sh, struct stripe_head_state *s)
- 3199 {
- 3200 struct r5conf *conf = sh->raid_conf;
- 3201 int disks = sh->disks;
- 3202 struct r5dev *dev;
- 3203 int i;
- 3204 int do_recovery = 0;
- 3205
- 3206 memset(s, 0, sizeof(*s));
- 3207
- 3208 s->expanding = test_bit(STRIPE_EXPAND_SOURCE, &sh->state);
- 3209 s->expanded = test_bit(STRIPE_EXPAND_READY, &sh->state);
- 3210 s->failed_num[0] = -1;
- 3211 s->failed_num[1] = -1;
- 3212
- 3213
- 3214 rcu_read_lock();
数据初始化和加锁，接着看：
- 3215 for (i=disks; i--; ) {
- 3216 struct md_rdev *rdev;
- 3217 sector_t first_bad;
- 3218 int bad_sectors;
- 3219 int is_bad = 0;
- 3220
- 3221 dev = &sh->dev[i];
- 3222
- 3223 pr_debug("check %d: state 0x%lx read %p write %p written %p\n",
- 3224 i, dev->flags,
- 3225 dev->toread, dev->towrite, dev->written);
接着是一个大循环，循环次数是数据盘的个数，循环的对象的3221行的dev，dev的类型是struct r5dev，那我们先来看一看这个结构，这个结构是嵌套在struct stripe_head里面的：
- struct r5dev {
-
-
-
- struct bio req, rreq;
- struct bio_vec vec, rvec;
- struct page *page;
- struct bio *toread, *read, *towrite, *written;
- sector_t sector;
- unsigned long flags;
- } dev[1];
首先看注释，rreq 和rvec由replacement设备在写数据时使用。r就是replacement的简写，replacement是什么意思呢？就是原数据盘的替代，replacement是最近几个版本里才引入的特性，在实际产品中这个特性很重要，具体实现后面会讲到。page是缓存页，通常用于运行计算，接着几个bio是读写bio头指针。sector是条带对应的物理扇区位置。flags是struct r5dev的标志。
- 3226
-
-
-
-
- 3231 if (test_bit(R5_UPTODATE, &dev->flags) && dev->toread &&
- 3232 !test_bit(STRIPE_BIOFILL_RUN, &sh->state))
- 3233 set_bit(R5_Wantfill, &dev->flags);
- 3234
- 3235
- 3236 if (test_bit(R5_LOCKED, &dev->flags))
- 3237 s->locked++;
- 3238 if (test_bit(R5_UPTODATE, &dev->flags))
- 3239 s->uptodate++;
- 3240 if (test_bit(R5_Wantcompute, &dev->flags)) {
- 3241 s->compute++;
- 3242 BUG_ON(s->compute > 2);
- 3243 }
- 3244
- 3245 if (test_bit(R5_Wantfill, &dev->flags))
- 3246 s->to_fill++;
- 3247 else if (dev->toread)
- 3248 s->to_read++;
- 3249 if (dev->towrite) {
- 3250 s->to_write++;
- 3251 if (!test_bit(R5_OVERWRITE, &dev->flags))
- 3252 s->non_overwrite++;
- 3253 }
- 3254 if (dev->written)
- 3255 s->written++;
3231行，什么样的r5dev要设置R5_Wantfill标志呢？已更新、有读请求、不在拷贝过程。这又是什么意思呢？就是说需要的数据已经为最新了，这时只要把数据从page拷贝到bio就可以了。
3236行，统计加锁磁盘数
3238行，统计已最新磁盘数
3240行，统计需要计算的磁盘数
3245行，统计需要拷贝操作磁盘数
3247行，统计需要读的磁盘数
3249行，统计需要写的磁盘数
3251行，统计满写的磁盘数
3254行，统计已下发写的磁盘数
- 3256
-
-
- 3259 rdev = rcu_dereference(conf->disks[i].replacement);
- 3260 if (rdev && !test_bit(Faulty, &rdev->flags) &&
- 3261 rdev->recovery_offset >= sh->sector + STRIPE_SECTORS &&
- 3262 !is_badblock(rdev, sh->sector, STRIPE_SECTORS,
- 3263 &first_bad, &bad_sectors))
- 3264 set_bit(R5_ReadRepl, &dev->flags);
- 3265 else {
- 3266 if (rdev)
- 3267 set_bit(R5_NeedReplace, &dev->flags);
- 3268 rdev = rcu_dereference(conf->disks[i].rdev);
- 3269 clear_bit(R5_ReadRepl, &dev->flags);
- 3270 }
- 3271 if (rdev && test_bit(Faulty, &rdev->flags))
- 3272 rdev = NULL;
- 3273 if (rdev) {
- 3274 is_bad = is_badblock(rdev, sh->sector, STRIPE_SECTORS,
- 3275 &first_bad, &bad_sectors);
- 3276 if (s->blocked_rdev == NULL
- 3277 && (test_bit(Blocked, &rdev->flags)
- 3278 || is_bad < 0)) {
- 3279 if (is_bad < 0)
- 3280 set_bit(BlockedBadBlocks,
- 3281 &rdev->flags);
- 3282 s->blocked_rdev = rdev;
- 3283 atomic_inc(&rdev->nr_pending);
- 3284 }
- 3285 }
3256行，优先读重建过并没有坏扇区的replacement盘
3264行，读replacement盘
3267行，写replacement盘
3271行，坏盘
3273行，检查坏扇区
3286行，初始化dev状态
3300行，没有坏扇区，设置同步标志
3312行，写错误处理
3325行，数据盘修复处理
3336行，replacement盘修复处理
3352行，记录不同步盘
3360行，判断同步还是重构replacement盘
到此analyse_stripe就结束了，那么对于同步来说，这个函数做了哪些事情呢？就只是设置了s.syncing=1而已，所以不要看这个函数那么长，每一次进来做的事情却很少。
继续返回到handle_stripe函数中，中间不执行的代码先跳过，然后就会执行到这里：
- 3468
-
-
-
- 3472 if (s.to_read || s.non_overwrite
- 3473 || (conf->level == 6 && s.to_write && s.failed)
- 3474 || (s.syncing && (s.uptodate + s.compute < disks))
- 3475 || s.replacing
- 3476 || s.expanding)
- 3477 handle_stripe_fill(sh, &s, disks);
3468行，这里是准备读磁盘，在生成校验、读写请求时都有可能读磁盘
3474行，在analyse_stripe中设置了syncing标志，所以这里满足这个条件，进入handle_stripe_fill函数。
- 2707
-
-
- 2710 static void handle_stripe_fill(struct stripe_head *sh,
- 2711 struct stripe_head_state *s,
- 2712 int disks)
- 2713 {
- 2714 int i;
- 2715
- 2716
-
-
-
- 2720 if (!test_bit(STRIPE_COMPUTE_RUN, &sh->state) && !sh->check_state &&
- 2721 !sh->reconstruct_state)
- 2722 for (i = disks; i--; )
- 2723 if (fetch_block(sh, s, i, disks))
- 2724 break;
- 2725 set_bit(STRIPE_HANDLE, &sh->state);
- 2726 }
2720行，如果已经在计算、校验或重建状态，则不需要再读磁盘
2722行，循环每一个r5dev看是否需要读磁盘
跟进fetch_block函数：
2618 /* fetch_block - checks the given member device to see if its data needs
2619 * to be read or computed to satisfy a request.
2620 *
2621 * Returns 1 when no more member devices need to be checked, otherwise returns
2622 * 0 to tell the loop in handle_stripe_fill to continue
2623 */
查看指定设置是否有必要读入数据，返回1表示剩余设置不需要检查了，返回0表示需要继续检查剩余的设置。
- 2624 static int fetch_block(struct stripe_head *sh, struct stripe_head_state *s,
- 2625 int disk_idx, int disks)
- 2626 {
- 2627 struct r5dev *dev = &sh->dev[disk_idx];
- 2628 struct r5dev *fdev[2] = { &sh->dev[s->failed_num[0]],
- 2629 &sh->dev[s->failed_num[1]] };
- 2630
- 2631
- 2632 if (!test_bit(R5_LOCKED, &dev->flags) &&
- 2633 !test_bit(R5_UPTODATE, &dev->flags) &&
- 2634 (dev->toread ||
- 2635 (dev->towrite && !test_bit(R5_OVERWRITE, &dev->flags)) ||
- 2636 s->syncing || s->expanding ||
- 2637 (s->replacing && want_replace(sh, disk_idx)) ||
- 2638 (s->failed >= 1 && fdev[0]->toread) ||
- 2639 (s->failed >= 2 && fdev[1]->toread) ||
- 2640 (sh->raid_conf->level <= 5 && s->failed && fdev[0]->towrite &&
- 2641 !test_bit(R5_OVERWRITE, &fdev[0]->flags)) ||
- 2642 (sh->raid_conf->level == 6 && s->failed && s->to_write))) {
- 2643
-
-
- 2646 BUG_ON(test_bit(R5_Wantcompute, &dev->flags));
- 2647 BUG_ON(test_bit(R5_Wantread, &dev->flags));
- 2648 if ((s->uptodate == disks - 1) &&
- 2649 (s->failed && (disk_idx == s->failed_num[0] ||
- 2650 disk_idx == s->failed_num[1]))) {
- 2651
-
-
- 2654 pr_debug("Computing stripe %llu block %d\n",
- 2655 (unsigned long long)sh->sector, disk_idx);
- 2656 set_bit(STRIPE_COMPUTE_RUN, &sh->state);
- 2657 set_bit(STRIPE_OP_COMPUTE_BLK, &s->ops_request);
- 2658 set_bit(R5_Wantcompute, &dev->flags);
- 2659 sh->ops.target = disk_idx;
- 2660 sh->ops.target2 = -1;
- 2661 s->req_compute = 1;
- 2662
-
-
-
-
-
- 2668 s->uptodate++;
- 2669 return 1;
- 2670 } else if (s->uptodate == disks-2 && s->failed >= 2) {
- 2671
-
-
- 2674 int other;
- 2675 for (other = disks; other--; ) {
- 2676 if (other == disk_idx)
- 2677 continue;
- 2678 if (!test_bit(R5_UPTODATE,
- 2679 &sh->dev[other].flags))
- 2680 break;
- 2681 }
- 2682 BUG_ON(other < 0);
- 2683 pr_debug("Computing stripe %llu blocks %d,%d\n",
- 2684 (unsigned long long)sh->sector,
- 2685 disk_idx, other);
- 2686 set_bit(STRIPE_COMPUTE_RUN, &sh->state);
- 2687 set_bit(STRIPE_OP_COMPUTE_BLK, &s->ops_request);
- 2688 set_bit(R5_Wantcompute, &sh->dev[disk_idx].flags);
- 2689 set_bit(R5_Wantcompute, &sh->dev[other].flags);
- 2690 sh->ops.target = disk_idx;
- 2691 sh->ops.target2 = other;
- 2692 s->uptodate += 2;
- 2693 s->req_compute = 1;
- 2694 return 1;
- 2695 } else if (test_bit(R5_Insync, &dev->flags)) {
- 2696 set_bit(R5_LOCKED, &dev->flags);
- 2697 set_bit(R5_Wantread, &dev->flags);
- 2698 s->locked++;
- 2699 pr_debug("Reading block %d (sync=%d)\n",
- 2700 disk_idx, s->syncing);
- 2701 }
- 2702 }
- 2703
- 2704 return 0;
- 2705 }
从这个函数进入，我们拥有的仅仅是s.syncing这张牌，那么这张牌在这里能不能发挥作用呢？
2632行，判断是否需要读设置
2636行，很明显地，这个判断为真，因为s.syncing==1，其他判断暂且不看
2648行，当前设置都未读入，所以s->uptodate==0
2670行，同上也不成立
2695行，真正执行到的是这个分支
2696行，设置设备加锁标志
2697行，设置设备准备读标志
2698行，递增本条带加锁设备数
handle_stripe函数执行完成，条带的每个struct r5dev都被设置了R5_Wantread标志。在接下来handle_stripe就会调用ops_run_io函数去读：
我们再跟进这个函数，为了突出重点，这里只列出跟同步相关的代码：
- 537 static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
- 538 {
- 539 struct r5conf *conf = sh->raid_conf;
- 540 int i, disks = sh->disks;
- 541
- 542 might_sleep();
- 543
- 544 for (i = disks; i--; ) {
- 545 int rw;
- 546 int replace_only = 0;
- 547 struct bio *bi, *rbi;
- 548 struct md_rdev *rdev, *rrdev = NULL;
- ...
- 554 } else if (test_and_clear_bit(R5_Wantread, &sh->dev[i].flags))
- 555 rw = READ;
- ...
- 560 } else
- 561 continue;
- 564
- 565 bi = &sh->dev[i].req;
- 566 rbi = &sh->dev[i].rreq;
- 567
- 568 bi->bi_rw = rw;
- 569 rbi->bi_rw = rw;
- 570 if (rw & WRITE) {
- 573 } else
- 574 bi->bi_end_io = raid5_end_read_request;
- 575
- 576 rcu_read_lock();
- 577 rrdev = rcu_dereference(conf->disks[i].replacement);
- 578 smp_mb();
- 579 rdev = rcu_dereference(conf->disks[i].rdev);
- 580 if (!rdev) {
- 581 rdev = rrdev;
- 582 rrdev = NULL;
- 583 }
- ...
- 598 if (rdev)
- 599 atomic_inc(&rdev->nr_pending);
- ...
- 604 rcu_read_unlock();
- ...
- 643 if (rdev) {
- 644 if (s->syncing || s->expanding || s->expanded
- 645 || s->replacing)
- 646 md_sync_acct(rdev->bdev, STRIPE_SECTORS);
- 647
- 648 set_bit(STRIPE_IO_STARTED, &sh->state);
- 649
- 650 bi->bi_bdev = rdev->bdev;
- 651 pr_debug("%s: for %llu schedule op %ld on disc %d\n",
- 652 __func__, (unsigned long long)sh->sector,
- 653 bi->bi_rw, i);
- 654 atomic_inc(&sh->count);
- 655 if (use_new_offset(conf, sh))
- 656 bi->bi_sector = (sh->sector
- 657 + rdev->new_data_offset);
- 658 else
- 659 bi->bi_sector = (sh->sector
- 660 + rdev->data_offset);
- 661 if (test_bit(R5_ReadNoMerge, &sh->dev[i].flags))
- 662 bi->bi_rw |= REQ_FLUSH;
- 663
- 664 bi->bi_flags = 1 << BIO_UPTODATE;
- 665 bi->bi_idx = 0;
- 666 bi->bi_io_vec[0].bv_len = STRIPE_SIZE;
- 667 bi->bi_io_vec[0].bv_offset = 0;
- 668 bi->bi_size = STRIPE_SIZE;
- 669 bi->bi_next = NULL;
- 670 if (rrdev)
- 671 set_bit(R5_DOUBLE_LOCKED, &sh->dev[i].flags);
- 672 generic_make_request(bi);
- 673 }
- ...
- 709 }
- 710 }
542行，函数可能休眠
544行，遍历每一个r5dev
554行，设置读标志
568行，设置bio为读
574行，设置bio回调函数为raid5_end_read_request，这里将是下发读请求之后代码继续执行的入口点。
598行，增加设备nr_pending
646行，统计信息
648行，设置IO下发标志
650行，设置bio设备为对应的磁盘设备
654行，增加stripe_head引用计数
655-660行，设置新的扇区数，需要加上磁盘上的数据偏移
661行，如果为NoMerge读，则设置bio REQ_FLUSH标志
664行，接着设置bio其他域
672行，下发bio到磁盘
在磁盘执行完读请求的时候，raid5_end_read_request被调用：
- 1710 static void raid5_end_read_request(struct bio * bi, int error)
- 1711 {
- ...
- 1824 rdev_dec_pending(rdev, conf->mddev);
- 1825 clear_bit(R5_LOCKED, &sh->dev[i].flags);
- 1826 set_bit(STRIPE_HANDLE, &sh->state);
- 1827 release_stripe(sh);
- 1828 }
在这个函数中，清除了R5_LOCKED标志，并重新将stripe_head加入处理。经过raid5d中转，重新调用到handle_stripe函数，这一次调用时在analyse_stripe函数中递增s->uptodate，所有数据盘都递增1，所以s->uptodate等于数据盘。接着handle_tripe函数到达：
- 3528 if (sh->check_state ||
- 3529 (s.syncing && s.locked == 0 &&
- 3530 !test_bit(STRIPE_COMPUTE_RUN, &sh->state) &&
- 3531 !test_bit(STRIPE_INSYNC, &sh->state))) {
- 3532 if (conf->level == 6)
- 3533 handle_parity_checks6(conf, sh, &s, disks);
- 3534 else
- 3535 handle_parity_checks5(conf, sh, &s, disks);
- 3536 }
进入3535行进行校验，进入handle_parity_check5函数：
- 2881 switch (sh->check_state) {
- 2882 case check_state_idle:
- 2883
- 2884 if (s->failed == 0) {
- 2885 BUG_ON(s->uptodate != disks);
- 2886 sh->check_state = check_state_run;
- 2887 set_bit(STRIPE_OP_CHECK, &s->ops_request);
- 2888 clear_bit(R5_UPTODATE, &sh->dev[sh->pd_idx].flags);
- 2889 s->uptodate--;
- 2890 break;
- 2891 }
2881行，check_state为0，进入2882行分支
2886行，设置check_state_run状态
2887行，设置STRIPE_OP_CHECK操作
2889行，递减s->uptodate
由于这里设置了STRIPE_OP_CHECK操作，所以在handle_stripe会调用到raid_run_ops，进而会调用到：
- 1412 if (test_bit(STRIPE_OP_CHECK, &ops_request)) {
- 1413 if (sh->check_state == check_state_run)
- 1414 ops_run_check_p(sh, percpu);
ops_run_check_p校验条带是否同步，对应的回调函数为：
- 1301static void ops_complete_check(void *stripe_head_ref)
- 1302{
- 1303 struct stripe_head *sh = stripe_head_ref;
- 1304
- 1305 pr_debug("%s: stripe %llu\n", __func__,
- 1306 (unsigned long long)sh->sector);
- 1307
- 1308 sh->check_state = check_state_check_result;
- 1309 set_bit(STRIPE_HANDLE, &sh->state);
- 1310 release_stripe(sh);
- 1311}
第1308行将状态设置为check_state_check_result，条带继续又重新加入到handle_list。handle_stripe再一次调用到handle_parity_check5函数，但这一次check_state==check_state_check_result：
- 2916 case check_state_check_result:
- 2917 sh->check_state = check_state_idle;
- 2918
- 2919
-
-
- 2922 if (s->failed)
- 2923 break;
- 2924
- 2925
-
-
-
- 2929 if ((sh->ops.zero_sum_result & SUM_CHECK_P_RESULT) == 0)
- 2930
-
-
- 2933 set_bit(STRIPE_INSYNC, &sh->state);
- 2934 else {
- 2935 conf->mddev->resync_mismatches += STRIPE_SECTORS;
- 2936 if (test_bit(MD_RECOVERY_CHECK, &conf->mddev->recovery))
- 2937
- 2938 set_bit(STRIPE_INSYNC, &sh->state);
- 2939 else {
- 2940 sh->check_state = check_state_compute_run;
- 2941 set_bit(STRIPE_COMPUTE_RUN, &sh->state);
- 2942 set_bit(STRIPE_OP_COMPUTE_BLK, &s->ops_request);
- 2943 set_bit(R5_Wantcompute,
- 2944 &sh->dev[sh->pd_idx].flags);
- 2945 sh->ops.target = sh->pd_idx;
- 2946 sh->ops.target2 = -1;
- 2947 s->uptodate++;
- 2948 }
- 2949 }
- 2950 break;
2929行，如果校验的结果是同步的
2933行，直接设置条带为同步的，不需要进行其他任何操作了
2934行，如果条带不同步
2940行，设置check_state为check_state_compute_run
2942行，ops_request 为STRIPE_OP_COMPUTE_BLK，即准备计算校验
2943行，计算目标为条带校验盘
2947行，由于之前计算校验时uptodate递减，这里恢复
如果条带已经同步了，那么带着STRIPE_INSYNC标志我们来到了handle_stripe：
- 3550 if ((s.syncing || s.replacing) && s.locked == 0 &&
- 3551 test_bit(STRIPE_INSYNC, &sh->state)) {
- 3552 md_done_sync(conf->mddev, STRIPE_SECTORS, 1);
- 3553 clear_bit(STRIPE_SYNCING, &sh->state);
- 3554 }
如果条带未同步，那带着STRIPE_OP_COMPUTE_BLK标志来到了raid_run_ops函数，该函数调用__raid_run_ops：
- 1383 if (test_bit(STRIPE_OP_COMPUTE_BLK, &ops_request)) {
- 1384 if (level < 6)
- 1385 tx = ops_run_compute5(sh, percpu);
最终调用ops_run_compute5函数计算出条带中校验盘的值，该函数回调函数ops_complete_compute：
- 856static void ops_complete_compute(void *stripe_head_ref)
- 857{
- 858 struct stripe_head *sh = stripe_head_ref;
- 859
- 860 pr_debug("%s: stripe %llu\n", __func__,
- 861 (unsigned long long)sh->sector);
- 862
- 863
- 864 mark_target_uptodate(sh, sh->ops.target);
- 865 mark_target_uptodate(sh, sh->ops.target2);
- 866
- 867 clear_bit(STRIPE_COMPUTE_RUN, &sh->state);
- 868 if (sh->check_state == check_state_compute_run)
- 869 sh->check_state = check_state_compute_result;
- 870 set_bit(STRIPE_HANDLE, &sh->state);
- 871 release_stripe(sh);
- 872}
864行，设置校验盘dev为R5_UPTODATE
869行，由于handle_parity_check5中设置为check_state_compute_run，这里继续设置为check_state_compute_result
870行，设置处理标志，在871之后再一次进入handle_stripe
当再一次进入handle_stripe函数，又再一次来到handle_parity_check5函数，由于这次是check_state_compute_result标志：
- 2894 case check_state_compute_result:
- 2895 sh->check_state = check_state_idle;
- 2896 if (!dev)
- 2897 dev = &sh->dev[sh->pd_idx];
- 2898
- 2899
- 2900 if (test_bit(STRIPE_INSYNC, &sh->state))
- 2901 break;
- 2902
- 2903
- 2904 BUG_ON(!test_bit(R5_UPTODATE, &dev->flags));
- 2905 BUG_ON(s->uptodate != disks);
- 2906
- 2907 set_bit(R5_LOCKED, &dev->flags);
- 2908 s->locked++;
- 2909 set_bit(R5_Wantwrite, &dev->flags);
- 2910
- 2911 clear_bit(STRIPE_DEGRADED, &sh->state);
- 2912 set_bit(STRIPE_INSYNC, &sh->state);
- 2913 break;
我们可以一眼看2912行设置了STRIPE_INSYNC标志，那么也意味着条带同步的结束。但是也别高兴得太早，回头看却有2908行s->locked++，同步结束的判断条件之一就是s->locked==0，所以在同步结束之前我们还有一件事情要做，2909行设置了R5_Wantwrite标志就是告诉我们需要调用一次ops_run_io将刚才计算的校验值写入条带的校验盘中，再写成功再返回时就会满足同步结束的条件了。就这样，一次简单的同步过程就完成了。
本文深入剖析Linux内核中RAID5的同步流程，详细介绍了handle_stripe函数如何处理条带，包括数据同步、计算过程及状态更新等内容。
扫一扫
6290
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
