dict: support comparison with context

[tools/e2fsprogs.git] / e2fsck / pass1b.c

diff --git a/e2fsck/pass1b.c b/e2fsck/pass1b.c
index 392ff2c..2f8c14c 100644 (file)
--- a/e2fsck/pass1b.c
+++ b/e2fsck/pass1b.c
@@ -104,7 +104,7 @@ static dict_t clstr_dict, ino_dict;
 
 static ext2fs_inode_bitmap inode_dup_map;
 
-static int dict_int_cmp(const void *a, const void *b)
+static int dict_int_cmp(const void* cmp_ctx, const void *a, const void *b)
 {
        intptr_t        ia, ib;
 
@@ -180,10 +180,10 @@ static void inode_dnode_free(dnode_t *node,
        di = (struct dup_inode *) dnode_get(node);
        for (p = di->cluster_list; p; p = next) {
                next = p->next;
-               free(p);
+               ext2fs_free_mem(&p);
        }
-       free(di);
-       free(node);
+       ext2fs_free_mem(&di);
+       ext2fs_free_mem(&node);
 }
 
 /*
@@ -198,10 +198,10 @@ static void cluster_dnode_free(dnode_t *node,
        dc = (struct dup_cluster *) dnode_get(node);
        for (p = dc->inode_list; p; p = next) {
                next = p->next;
-               free(p);
+               ext2fs_free_mem(&p);
        }
-       free(dc);
-       free(node);
+       ext2fs_free_mem(&dc);
+       ext2fs_free_mem(&node);
 }
 
 
@@ -245,6 +245,24 @@ void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf)
        pass1d(ctx, block_buf);
        print_resource_track(ctx, "Pass 1d", &rtrack, ctx->fs->io);
 
+       if (ext2fs_has_feature_shared_blocks(ctx->fs->super) &&
+           (ctx->options & E2F_OPT_UNSHARE_BLOCKS)) {
+               /*
+                * If we successfully managed to unshare all blocks, unset the
+                * shared block feature.
+                */
+               blk64_t next;
+               int result = ext2fs_find_first_set_block_bitmap2(
+                       ctx->block_dup_map,
+                       ctx->fs->super->s_first_data_block,
+                       ext2fs_blocks_count(ctx->fs->super) - 1,
+                       &next);
+               if (result == ENOENT && !(ctx->options & E2F_OPT_NO)) {
+                       ext2fs_clear_feature_shared_blocks(ctx->fs->super);
+                       ext2fs_mark_super_dirty(ctx->fs);
+               }
+       }
+
        /*
         * Time to free all of the accumulated data structures that we
         * don't need anymore.
@@ -582,14 +600,21 @@ static void pass1d(e2fsck_t ctx, char *block_buf)
                        fix_problem(ctx, PR_1D_DUP_BLOCKS_DEALT, &pctx);
                        continue;
                }
-               if (fix_problem(ctx, PR_1D_CLONE_QUESTION, &pctx)) {
+               if ((ctx->options & E2F_OPT_UNSHARE_BLOCKS) ||
+                    fix_problem(ctx, PR_1D_CLONE_QUESTION, &pctx)) {
                        pctx.errcode = clone_file(ctx, ino, p, block_buf);
                        if (pctx.errcode)
                                fix_problem(ctx, PR_1D_CLONE_ERROR, &pctx);
                        else
                                continue;
                }
-               if (fix_problem(ctx, PR_1D_DELETE_QUESTION, &pctx))
+               /*
+                * Note: When unsharing blocks, we don't prompt to delete
+                * files. If the clone operation fails than the unshare
+                * operation should fail too.
+                */
+               if (!(ctx->options & E2F_OPT_UNSHARE_BLOCKS) &&
+                    fix_problem(ctx, PR_1D_DELETE_QUESTION, &pctx))
                        delete_file(ctx, ino, p, block_buf);
                else
                        ext2fs_unmark_valid(fs);
@@ -680,6 +705,10 @@ static void delete_file(e2fsck_t ctx, ext2_ino_t ino,
                fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx);
        if (ctx->inode_bad_map)
                ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino);
+       if (ctx->inode_reg_map)
+               ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino);
+       ext2fs_unmark_inode_bitmap2(ctx->inode_dir_map, ino);
+       ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino);
        ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(dp->inode.i_mode));
        quota_data_sub(ctx->qctx, &dp->inode, ino,
                       pb.dup_blocks * fs->blocksize);
@@ -771,6 +800,7 @@ static int clone_file_block(ext2_filsys fs,
        e2fsck_t ctx;
        blk64_t c;
        int is_meta = 0;
+       int should_write = 1;
 
        ctx = cs->ctx;
        deferred_dec_badcount(cs);
@@ -778,6 +808,11 @@ static int clone_file_block(ext2_filsys fs,
        if (*block_nr == 0)
                return 0;
 
+       if (ext2fs_has_feature_shared_blocks(ctx->fs->super) &&
+           (ctx->options & E2F_OPT_UNSHARE_BLOCKS) &&
+           (ctx->options & E2F_OPT_NO))
+               should_write = 0;
+
        c = EXT2FS_B2C(fs, blockcnt);
        if (check_if_fs_cluster(ctx, EXT2FS_B2C(fs, *block_nr)))
                is_meta = 1;
@@ -820,6 +855,13 @@ static int clone_file_block(ext2_filsys fs,
                        cs->errcode = retval;
                        return BLOCK_ABORT;
                }
+               if (ext2fs_has_feature_shared_blocks(fs->super)) {
+                       /*
+                        * Update the block stats so we don't get a prompt to fix block
+                        * counts in the final pass.
+                        */
+                       ext2fs_block_alloc_stats2(fs, new_block, +1);
+               }
 cluster_alloc_ok:
                cs->alloc_block = new_block;
 
@@ -843,16 +885,25 @@ cluster_alloc_ok:
                        cs->errcode = retval;
                        return BLOCK_ABORT;
                }
-               retval = io_channel_write_blk64(fs->io, new_block, 1, cs->buf);
-               if (retval) {
-                       cs->errcode = retval;
-                       return BLOCK_ABORT;
+               if (should_write) {
+                       retval = io_channel_write_blk64(fs->io, new_block, 1, cs->buf);
+                       if (retval) {
+                               cs->errcode = retval;
+                               return BLOCK_ABORT;
+                       }
                }
                cs->save_dup_cluster = (is_meta ? NULL : p);
                cs->save_blocknr = *block_nr;
                *block_nr = new_block;
                ext2fs_mark_block_bitmap2(ctx->block_found_map, new_block);
                ext2fs_mark_block_bitmap2(fs->block_map, new_block);
+
+               if (!should_write) {
+                       /* Don't try to change extent information; we want e2fsck to
+                        * return success.
+                        */
+                       return 0;
+               }
                return BLOCK_CHANGED;
        }
        return 0;