e2fsck: merge icounts after thread finishes

Merge inode_count and inode_link_info properly after
threads finish.

E2fsprogs-commit: bb78742b5e2e95c3e7e9a76755144fdf8ec12285

Change-Id: If40930a87595010963fd59a54709a4d2b27d223b
Signed-off-by: Li Xi <lixi@ddn.com>
Signed-off-by: Wang Shilong <wshilong@ddn.com>
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>

diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index a6efb13..2136f00 100644 (file)
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -2424,6 +2424,41 @@ static void e2fsck_pass1_merge_dir_info(e2fsck_t global_ctx, e2fsck_t thread_ctx
                              global_ctx->dir_info);
 }
 
+static inline errcode_t
+e2fsck_pass1_merge_icount(ext2_icount_t *dest_icount,
+                         ext2_icount_t *src_icount)
+{
+       if (*src_icount) {
+               if (*dest_icount == NULL) {
+                       *dest_icount = *src_icount;
+                       *src_icount = NULL;
+               } else {
+                       errcode_t ret;
+
+                       ret = ext2fs_icount_merge(*src_icount,
+                                                 *dest_icount);
+                       if (ret)
+                               return ret;
+               }
+       }
+
+       return 0;
+}
+
+static errcode_t e2fsck_pass1_merge_icounts(e2fsck_t global_ctx, e2fsck_t thread_ctx)
+{
+       errcode_t ret;
+
+       ret = e2fsck_pass1_merge_icount(&global_ctx->inode_count,
+                                       &thread_ctx->inode_count);
+       if (ret)
+               return ret;
+       ret = e2fsck_pass1_merge_icount(&global_ctx->inode_link_info,
+                                       &thread_ctx->inode_link_info);
+
+       return ret;
+}
+
 static int e2fsck_pass1_thread_join_one(e2fsck_t global_ctx, e2fsck_t thread_ctx)
 {
        errcode_t        retval;
@@ -2444,6 +2479,8 @@ static int e2fsck_pass1_thread_join_one(e2fsck_t global_ctx, e2fsck_t thread_ctx
        ext2fs_block_bitmap block_ea_map = global_ctx->block_ea_map;
        ext2fs_block_bitmap block_metadata_map = global_ctx->block_metadata_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;
 
 #ifdef HAVE_SETJMP_H
        jmp_buf          old_jmp;
@@ -2468,6 +2505,8 @@ static int e2fsck_pass1_thread_join_one(e2fsck_t global_ctx, e2fsck_t thread_ctx
        global_ctx->block_metadata_map = block_metadata_map;
        global_ctx->dir_info = dir_info;
        e2fsck_pass1_merge_dir_info(global_ctx, thread_ctx);
+       global_ctx->inode_count = inode_count;
+       global_ctx->inode_link_info = inode_link_info;
 
        /* Keep the global singal flags*/
        global_ctx->flags |= (flags & E2F_FLAG_SIGNAL_MASK) |
@@ -2483,6 +2522,12 @@ static int e2fsck_pass1_thread_join_one(e2fsck_t global_ctx, e2fsck_t thread_ctx
        global_ctx->logf = global_logf;
        global_ctx->problem_logf = global_problem_logf;
        global_ctx->global_ctx = NULL;
+       retval = e2fsck_pass1_merge_icounts(global_ctx, thread_ctx);
+       if (retval) {
+               com_err(global_ctx->program_name, 0,
+                       _("while merging icounts\n"));
+               return retval;
+       }
 
        retval = e2fsck_pass1_merge_bitmap(global_fs,
                                &thread_ctx->inode_used_map,
@@ -2568,6 +2613,8 @@ static int e2fsck_pass1_thread_join(e2fsck_t global_ctx, e2fsck_t thread_ctx)
        e2fsck_pass1_free_bitmap(&thread_ctx->block_ea_map);
        e2fsck_pass1_free_bitmap(&thread_ctx->block_metadata_map);
        e2fsck_free_dir_info(thread_ctx);
+       ext2fs_free_icount(thread_ctx->inode_count);
+       ext2fs_free_icount(thread_ctx->inode_link_info);
        ext2fs_free_mem(&thread_ctx);
 
        return retval;

diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h
index 4e3aedd..d332b87 100644 (file)
--- a/lib/ext2fs/ext2fs.h
+++ b/lib/ext2fs/ext2fs.h
@@ -1527,6 +1527,7 @@ extern errcode_t ext2fs_icount_decrement(ext2_icount_t icount, ext2_ino_t ino,
                                         __u16 *ret);
 extern errcode_t ext2fs_icount_store(ext2_icount_t icount, ext2_ino_t ino,
                                     __u16 count);
+extern errcode_t ext2fs_icount_merge(ext2_icount_t src, ext2_icount_t dest);
 extern ext2_ino_t ext2fs_get_icount_size(ext2_icount_t icount);
 errcode_t ext2fs_icount_validate(ext2_icount_t icount, FILE *);
 

diff --git a/lib/ext2fs/icount.c b/lib/ext2fs/icount.c
index 888a90b..766eccc 100644 (file)
--- a/lib/ext2fs/icount.c
+++ b/lib/ext2fs/icount.c
@@ -13,6 +13,7 @@
 #if HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+#include <assert.h>
 #include <string.h>
 #include <stdio.h>
 #include <sys/stat.h>
@@ -701,6 +702,108 @@ errcode_t ext2fs_icount_store(ext2_icount_t icount, ext2_ino_t ino,
        return 0;
 }
 
+errcode_t ext2fs_icount_merge_full_map(ext2_icount_t src, ext2_icount_t dest)
+{
+       /* TODO: add the support for full map */
+       return EOPNOTSUPP;
+}
+
+errcode_t ext2fs_icount_merge_el(ext2_icount_t src, ext2_icount_t dest)
+{
+       int                      src_count = src->count;
+       int                      dest_count = dest->count;
+       int                      size = src_count + dest_count;
+       int                      size_entry = sizeof(struct ext2_icount_el);
+       struct ext2_icount_el   *array;
+       struct ext2_icount_el   *array_ptr;
+       struct ext2_icount_el   *src_array = src->list;
+       struct ext2_icount_el   *dest_array = dest->list;
+       int                      src_index = 0;
+       int                      dest_index = 0;
+       errcode_t                retval;
+
+       if (src_count == 0)
+               return 0;
+
+       retval = ext2fs_get_array(size, size_entry, &array);
+       if (retval)
+               return retval;
+
+       array_ptr = array;
+       /*
+        * This can be improved by binary search and memcpy, but codes
+        * would be more complex. And if number of bad blocks is small,
+        * the optimization won't improve performance a lot.
+        */
+       while (src_index < src_count || dest_index < dest_count) {
+               if (src_index >= src_count) {
+                       memcpy(array_ptr, &dest_array[dest_index],
+                              (dest_count - dest_index) * size_entry);
+                       break;
+               }
+               if (dest_index >= dest_count) {
+                       memcpy(array_ptr, &src_array[src_index],
+                              (src_count - src_index) * size_entry);
+                       break;
+               }
+               if (src_array[src_index].ino < dest_array[dest_index].ino) {
+                       *array_ptr = src_array[src_index];
+                       src_index++;
+               } else {
+                       assert(src_array[src_index].ino >
+                              dest_array[dest_index].ino);
+                       *array_ptr = dest_array[dest_index];
+                       dest_index++;
+               }
+               array_ptr++;
+       }
+
+       ext2fs_free_mem(&dest->list);
+       dest->list = array;
+       dest->count = src_count + dest_count;
+       dest->size = size;
+       dest->last_lookup = NULL;
+       return 0;
+}
+
+errcode_t ext2fs_icount_merge(ext2_icount_t src, ext2_icount_t dest)
+{
+       errcode_t       retval;
+
+       if (src->fullmap && !dest->fullmap)
+               return EINVAL;
+
+       if (!src->fullmap && dest->fullmap)
+               return EINVAL;
+
+       if (src->multiple && !dest->multiple)
+               return EINVAL;
+
+       if (!src->multiple && dest->multiple)
+               return EINVAL;
+
+       if (src->fullmap)
+               return ext2fs_icount_merge_full_map(src, dest);
+
+       retval = ext2fs_merge_bitmap(src->single, dest->single, NULL,
+                                    NULL);
+       if (retval)
+               return retval;
+
+       if (src->multiple) {
+               retval = ext2fs_merge_bitmap(src->multiple, dest->multiple,
+                                            NULL, NULL);
+               if (retval)
+                       return retval;
+       }
+
+       retval = ext2fs_icount_merge_el(src, dest);
+       if (retval)
+               return retval;
+
+       return 0;
+}
+
 ext2_ino_t ext2fs_get_icount_size(ext2_icount_t icount)
 {
        if (!icount || icount->magic != EXT2_ET_MAGIC_ICOUNT)