LU-8465 e2fsck: merge EA blocks properly

EA blocks might be shared, merge them carefully.

Change-Id: Idb80a667eb364035448044a4a6e3c7a7f940ac81
Signed-off-by: Wang Shilong <wshilong@ddn.com>
Reviewed-on: https://review.whamcloud.com/37905
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>

diff --git a/e2fsck/e2fsck.h b/e2fsck/e2fsck.h
index ad43724..b372111 100644 (file)
--- a/e2fsck/e2fsck.h
+++ b/e2fsck/e2fsck.h
@@ -414,6 +414,7 @@ struct e2fsck_struct {
 
        ext2_refcount_t         refcount;
        ext2_refcount_t         refcount_extra;
+       ext2_refcount_t         refcount_orig;
 
        /*
         * Quota blocks and inodes to be charged for each ea block.

diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index f609105..534560f 100644 (file)
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -1433,14 +1433,39 @@ static void e2fsck_pass1_post(e2fsck_t ctx)
 {
        struct problem_context pctx;
        ext2_filsys fs = ctx->fs;
-       char *block_buf;
 
+       char *block_buf =
+               (char *)e2fsck_allocate_memory(ctx, ctx->fs->blocksize * 3,
+                                             "block interate buffer");
        reserve_block_for_root_repair(ctx);
        reserve_block_for_lnf_repair(ctx);
 
+       /*
+        * If any extended attribute blocks' reference counts need to
+        * be adjusted, either up (ctx->refcount_extra), or down
+        * (ctx->refcount), then fix them.
+        */
+       if (ctx->refcount) {
+               adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1);
+               ea_refcount_free(ctx->refcount);
+               ctx->refcount = 0;
+       }
+       if (ctx->refcount_extra) {
+               adjust_extattr_refcount(ctx, ctx->refcount_extra,
+                                       block_buf, +1);
+               ea_refcount_free(ctx->refcount_extra);
+               ctx->refcount_extra = 0;
+       }
+
        if (ctx->invalid_bitmaps)
                handle_fs_bad_blocks(ctx);
 
+       /* We don't need the block_ea_map any more */
+       if (ctx->block_ea_map) {
+               ext2fs_free_block_bitmap(ctx->block_ea_map);
+               ctx->block_ea_map = 0;
+       }
+
        if (ctx->flags & E2F_FLAG_RESIZE_INODE) {
                struct ext2_inode *inode;
                int inode_size = EXT2_INODE_SIZE(fs->super);
@@ -1480,10 +1505,6 @@ static void e2fsck_pass1_post(e2fsck_t ctx)
                        clear_problem_context(&pctx);
                        fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx);
                }
-               block_buf =
-                       (char *)e2fsck_allocate_memory(ctx,
-                                       ctx->fs->blocksize * 3,
-                                       "block interate buffer");
                e2fsck_pass1_dupblocks(ctx, block_buf);
                ext2fs_free_mem(&block_buf);
        }
@@ -2345,23 +2366,6 @@ void e2fsck_pass1_run(e2fsck_t ctx)
        ext2fs_close_inode_scan(scan);
        scan = NULL;
 
-       /*
-        * If any extended attribute blocks' reference counts need to
-        * be adjusted, either up (ctx->refcount_extra), or down
-        * (ctx->refcount), then fix them.
-        */
-       if (ctx->refcount) {
-               adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1);
-               ea_refcount_free(ctx->refcount);
-               ctx->refcount = 0;
-       }
-       if (ctx->refcount_extra) {
-               adjust_extattr_refcount(ctx, ctx->refcount_extra,
-                                       block_buf, +1);
-               ea_refcount_free(ctx->refcount_extra);
-               ctx->refcount_extra = 0;
-       }
-
        if (ctx->ea_block_quota_blocks) {
                ea_refcount_free(ctx->ea_block_quota_blocks);
                ctx->ea_block_quota_blocks = 0;
@@ -2372,13 +2376,6 @@ void e2fsck_pass1_run(e2fsck_t ctx)
                ctx->ea_block_quota_inodes = 0;
        }
 
-
-       /* We don't need the block_ea_map any more */
-       if (ctx->block_ea_map) {
-               ext2fs_free_block_bitmap(ctx->block_ea_map);
-               ctx->block_ea_map = 0;
-       }
-
        if (ctx->flags & E2F_FLAG_RESTART) {
                /*
                 * Only the master copy of the superblock and block
@@ -2856,6 +2853,156 @@ static errcode_t e2fsck_pass1_merge_dirs_to_hash(e2fsck_t global_ctx,
        return retval;
 }
 
+static errcode_t e2fsck_pass1_merge_ea_inode_refs(e2fsck_t global_ctx,
+                                                 e2fsck_t thread_ctx)
+{
+       ea_value_t count;
+       blk64_t blk;
+       errcode_t retval;
+
+       if (!thread_ctx->ea_inode_refs)
+               return 0;
+
+       if (!global_ctx->ea_inode_refs) {
+               global_ctx->ea_inode_refs = thread_ctx->ea_inode_refs;
+               thread_ctx->ea_inode_refs = NULL;
+               return 0;
+       }
+
+       ea_refcount_intr_begin(thread_ctx->ea_inode_refs);
+       while (1) {
+               if ((blk = ea_refcount_intr_next(thread_ctx->ea_inode_refs,
+                                                &count)) == 0)
+                       break;
+               if (!global_ctx->block_ea_map ||
+                   !ext2fs_fast_test_block_bitmap2(global_ctx->block_ea_map,
+                                                   blk)) {
+                       retval = ea_refcount_store(global_ctx->ea_inode_refs,
+                                                  blk, count);
+                       if (retval)
+                               return retval;
+               }
+       }
+
+       return retval;
+}
+
+static ea_value_t ea_refcount_usage(e2fsck_t ctx, blk64_t blk,
+                                   ea_value_t *orig)
+{
+       ea_value_t count_cur;
+       ea_value_t count_extra = 0;
+       ea_value_t count_orig;
+
+       ea_refcount_fetch(ctx->refcount_orig, blk, &count_orig);
+       ea_refcount_fetch(ctx->refcount, blk, &count_cur);
+       /* most of time this is not needed */
+       if (ctx->refcount_extra && count_cur == 0)
+               ea_refcount_fetch(ctx->refcount_extra, blk, &count_extra);
+
+       if (!count_orig)
+               count_orig = *orig;
+       else if (orig)
+               *orig = count_orig;
+
+       return count_orig + count_extra - count_cur;
+}
+
+static errcode_t e2fsck_pass1_merge_ea_refcount(e2fsck_t global_ctx,
+                                               e2fsck_t thread_ctx)
+{
+       ea_value_t count;
+       blk64_t blk;
+       errcode_t retval = 0;
+
+       if (!thread_ctx->refcount)
+               return 0;
+
+       if (!global_ctx->refcount) {
+               global_ctx->refcount = thread_ctx->refcount;
+               thread_ctx->refcount = NULL;
+               global_ctx->refcount_extra = thread_ctx->refcount;
+               thread_ctx->refcount_extra = NULL;
+               return 0;
+       }
+
+       ea_refcount_intr_begin(thread_ctx->refcount);
+       while (1) {
+               if ((blk = ea_refcount_intr_next(thread_ctx->refcount,
+                                                &count)) == 0)
+                       break;
+               /**
+                * this EA has never seen before, so just store its
+                * refcount and refcount_extra into global_ctx if needed.
+                */
+               if (!global_ctx->block_ea_map ||
+                   !ext2fs_fast_test_block_bitmap2(global_ctx->block_ea_map,
+                                                   blk)) {
+                       ea_value_t extra;
+
+                       retval = ea_refcount_store(global_ctx->refcount,
+                                                  blk, count);
+                       if (retval)
+                               return retval;
+
+                       if (count > 0 || !thread_ctx->refcount_extra)
+                               continue;
+                       ea_refcount_fetch(thread_ctx->refcount_extra, blk,
+                                         &extra);
+                       if (extra == 0)
+                               continue;
+
+                       if (!global_ctx->refcount_extra) {
+                               retval = ea_refcount_create(0,
+                                               &global_ctx->refcount_extra);
+                               if (retval)
+                                       return retval;
+                       }
+                       retval = ea_refcount_store(global_ctx->refcount_extra,
+                                                  blk, extra);
+                       if (retval)
+                               return retval;
+               } else {
+                       ea_value_t orig;
+                       ea_value_t thread_usage;
+                       ea_value_t global_usage;
+                       ea_value_t new;
+
+                       thread_usage = ea_refcount_usage(thread_ctx,
+                                                        blk, &orig);
+                       global_usage = ea_refcount_usage(global_ctx,
+                                                        blk, &orig);
+                       if (thread_usage + global_usage <= orig) {
+                               new = orig - thread_usage - global_usage;
+                               retval = ea_refcount_store(global_ctx->refcount,
+                                                          blk, new);
+                               if (retval)
+                                       return retval;
+                               continue;
+                       }
+                       /* update it is as zero */
+                       retval = ea_refcount_store(global_ctx->refcount,
+                                                  blk, 0);
+                       if (retval)
+                               return retval;
+                       /* Ooops, this EA was referenced more than it stated */
+                       if (!global_ctx->refcount_extra) {
+                               retval = ea_refcount_create(0,
+                                               &global_ctx->refcount_extra);
+                               if (retval)
+                                       return retval;
+                       }
+                       new = global_usage + thread_usage - orig;
+                       retval = ea_refcount_store(global_ctx->refcount_extra,
+                                                  blk, new);
+                       if (retval)
+                               return retval;
+               }
+       }
+
+       return retval;
+}
+
 static int e2fsck_pass1_thread_join_one(e2fsck_t global_ctx, e2fsck_t thread_ctx)
 {
        errcode_t        retval;
@@ -2873,7 +3020,6 @@ static int e2fsck_pass1_thread_join_one(e2fsck_t global_ctx, e2fsck_t thread_ctx
        ext2fs_inode_bitmap inode_imagic_map = global_ctx->inode_imagic_map;
        ext2fs_inode_bitmap inode_reg_map = global_ctx->inode_reg_map;
        ext2fs_block_bitmap block_dup_map = global_ctx->block_dup_map;
-       ext2fs_block_bitmap block_ea_map = global_ctx->block_ea_map;
        ext2fs_block_bitmap inodes_to_rebuild = global_ctx->inodes_to_rebuild;
        ext2_icount_t inode_count = global_ctx->inode_count;
        ext2_icount_t inode_link_info = global_ctx->inode_link_info;
@@ -2903,6 +3049,13 @@ static int e2fsck_pass1_thread_join_one(e2fsck_t global_ctx, e2fsck_t thread_ctx
        int *invalid_inode_bitmap_flag = global_ctx->invalid_inode_bitmap_flag;
        int *invalid_inode_table_flag  = global_ctx->invalid_inode_table_flag;
        int invalid_bitmaps = global_ctx->invalid_bitmaps;
+       ext2_refcount_t refcount = global_ctx->refcount;
+       ext2_refcount_t refcount_extra = global_ctx->refcount_extra;
+       ext2_refcount_t refcount_orig = global_ctx->refcount_orig;
+       ext2_refcount_t ea_block_quota_blocks = global_ctx->ea_block_quota_blocks;
+       ext2_refcount_t ea_block_quota_inodes = global_ctx->ea_block_quota_inodes;
+       ext2fs_block_bitmap block_ea_map = global_ctx->block_ea_map;
+       ext2_refcount_t ea_inode_refs = global_ctx->ea_inode_refs;
 
 #ifdef HAVE_SETJMP_H
        jmp_buf          old_jmp;
@@ -2921,7 +3074,6 @@ static int e2fsck_pass1_thread_join_one(e2fsck_t global_ctx, e2fsck_t thread_ctx
        global_ctx->inode_imagic_map = inode_imagic_map;
        global_ctx->inodes_to_rebuild = inodes_to_rebuild;
        global_ctx->inode_reg_map = inode_reg_map;
-       global_ctx->block_ea_map = block_ea_map;
        global_ctx->block_dup_map = block_dup_map;
        global_ctx->dir_info = dir_info;
        e2fsck_pass1_merge_dir_info(global_ctx, thread_ctx);
@@ -2931,6 +3083,13 @@ static int e2fsck_pass1_thread_join_one(e2fsck_t global_ctx, e2fsck_t thread_ctx
        e2fsck_pass1_merge_dx_dir(global_ctx, thread_ctx);
        global_ctx->inode_count = inode_count;
        global_ctx->inode_link_info = inode_link_info;
+       global_ctx->refcount = refcount;
+       global_ctx->refcount_extra = refcount_extra;
+       global_ctx->refcount_orig = refcount_orig;
+       global_ctx->ea_block_quota_blocks = ea_block_quota_blocks;
+       global_ctx->ea_block_quota_inodes = ea_block_quota_inodes;
+       global_ctx->block_ea_map = block_ea_map;
+       global_ctx->ea_inode_refs = ea_inode_refs;
        global_ctx->inode_badness = inode_badness;
        global_ctx->fs_directory_count += fs_directory_count;
        global_ctx->fs_regular_count += fs_regular_count;
@@ -2977,6 +3136,8 @@ static int e2fsck_pass1_thread_join_one(e2fsck_t global_ctx, e2fsck_t thread_ctx
                return retval;
        }
 
+       e2fsck_pass1_merge_ea_inode_refs(global_ctx, thread_ctx);
+       e2fsck_pass1_merge_ea_refcount(global_ctx, thread_ctx);
        global_ctx->qctx = qctx;
        retval = quota_merge_and_update_usage(global_ctx->qctx,
                                              thread_ctx->qctx);
@@ -3053,6 +3214,14 @@ static int e2fsck_pass1_thread_join(e2fsck_t global_ctx, e2fsck_t thread_ctx)
        e2fsck_pass1_free_bitmap(&thread_ctx->inode_reg_map);
        e2fsck_pass1_free_bitmap(&thread_ctx->inodes_to_rebuild);
        e2fsck_pass1_free_bitmap(&thread_ctx->block_ea_map);
+       if (thread_ctx->refcount)
+               ea_refcount_free(thread_ctx->refcount);
+       if (thread_ctx->refcount_extra)
+               ea_refcount_free(thread_ctx->refcount_extra);
+       if (thread_ctx->ea_inode_refs)
+               ea_refcount_free(thread_ctx->ea_inode_refs);
+       if (thread_ctx->refcount_orig)
+               ea_refcount_free(thread_ctx->refcount_orig);
        e2fsck_free_dir_info(thread_ctx);
        ext2fs_free_icount(thread_ctx->inode_count);
        ext2fs_free_icount(thread_ctx->inode_link_info);
@@ -3709,6 +3878,15 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx,
 
        /* Create the EA refcount structure if necessary */
        if (!ctx->refcount) {
+               pctx->errcode = ea_refcount_create(0,
+                                       &ctx->refcount_orig);
+               if (pctx->errcode) {
+                       pctx->num = 1;
+                       fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
+                       ctx->flags |= E2F_FLAG_ABORT;
+                       return 0;
+               }
+
                pctx->errcode = ea_refcount_create(0, &ctx->refcount);
                if (pctx->errcode) {
                        pctx->num = 1;
@@ -3913,6 +4091,7 @@ refcount_fail:
 
        inc_ea_inode_refs(ctx, pctx, first, end);
        ea_refcount_store(ctx->refcount, blk, header->h_refcount - 1);
+       ea_refcount_store(ctx->refcount_orig, blk, header->h_refcount);
        mark_block_used(ctx, blk);
        ext2fs_fast_mark_block_bitmap2(ctx->block_ea_map, blk);
        return 1;