config: update config.{guess,sub}

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

diff --git a/e2fsck/e2fsck.c b/e2fsck/e2fsck.c
index 2a84c51..929bd78 100644 (file)
--- a/e2fsck/e2fsck.c
+++ b/e2fsck/e2fsck.c
@@ -1,6 +1,6 @@
 /*
  * e2fsck.c - a consistency checker for the new extended file system.
- * 
+ *
  * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
  *
  * %Begin-Header%
@@ -9,27 +9,40 @@
  * %End-Header%
  */
 
+#include "config.h"
 #include <errno.h>
 
 #include "e2fsck.h"
 #include "problem.h"
 
 /*
- * This function allocates an e2fsck context 
+ * This function allocates an e2fsck context
  */
 errcode_t e2fsck_allocate_context(e2fsck_t *ret)
 {
        e2fsck_t        context;
        errcode_t       retval;
+       char            *time_env;
 
        retval = ext2fs_get_mem(sizeof(struct e2fsck_struct), &context);
        if (retval)
                return retval;
-       
+
        memset(context, 0, sizeof(struct e2fsck_struct));
 
        context->process_inode_size = 256;
        context->ext_attr_ver = 2;
+       context->blocks_per_page = 1;
+       context->htree_slack_percentage = 255;
+
+       time_env = getenv("E2FSCK_TIME");
+       if (time_env)
+               context->now = (time_t) strtoull(time_env, NULL, 0);
+       else {
+               context->now = time(0);
+               if (context->now < 1262322000) /* January 1 2010 */
+                       context->flags |= E2F_FLAG_TIME_INSANE;
+       }
 
        *ret = context;
        return 0;
@@ -41,7 +54,9 @@ errcode_t e2fsck_allocate_context(e2fsck_t *ret)
  */
 errcode_t e2fsck_reset_context(e2fsck_t ctx)
 {
-       ctx->flags = 0;
+       int     i;
+
+       ctx->flags &= E2F_RESET_FLAGS;
        ctx->lost_and_found = 0;
        ctx->bad_lost_and_found = 0;
        if (ctx->inode_used_map) {
@@ -74,9 +89,7 @@ errcode_t e2fsck_reset_context(e2fsck_t ctx)
                ctx->fs->dblist = 0;
        }
        e2fsck_free_dir_info(ctx);
-#ifdef ENABLE_HTREE
        e2fsck_free_dx_dir_info(ctx);
-#endif
        if (ctx->refcount) {
                ea_refcount_free(ctx->refcount);
                ctx->refcount = 0;
@@ -85,6 +98,18 @@ errcode_t e2fsck_reset_context(e2fsck_t ctx)
                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;
+       }
+       if (ctx->ea_block_quota_inodes) {
+               ea_refcount_free(ctx->ea_block_quota_inodes);
+               ctx->ea_block_quota_inodes = 0;
+       }
+       if (ctx->ea_inode_refs) {
+               ea_refcount_free(ctx->ea_inode_refs);
+               ctx->ea_inode_refs = 0;
+       }
        if (ctx->block_dup_map) {
                ext2fs_free_block_bitmap(ctx->block_dup_map);
                ctx->block_dup_map = 0;
@@ -93,6 +118,10 @@ errcode_t e2fsck_reset_context(e2fsck_t ctx)
                ext2fs_free_block_bitmap(ctx->block_ea_map);
                ctx->block_ea_map = 0;
        }
+       if (ctx->block_metadata_map) {
+               ext2fs_free_block_bitmap(ctx->block_metadata_map);
+               ctx->block_metadata_map = 0;
+       }
        if (ctx->inode_bb_map) {
                ext2fs_free_inode_bitmap(ctx->inode_bb_map);
                ctx->inode_bb_map = 0;
@@ -125,6 +154,14 @@ errcode_t e2fsck_reset_context(e2fsck_t ctx)
                ext2fs_free_mem(&ctx->invalid_inode_table_flag);
                ctx->invalid_inode_table_flag = 0;
        }
+       if (ctx->encrypted_dirs) {
+               ext2fs_u32_list_free(ctx->encrypted_dirs);
+               ctx->encrypted_dirs = 0;
+       }
+       if (ctx->inode_count) {
+               ext2fs_free_icount(ctx->inode_count);
+               ctx->inode_count = 0;
+       }
 
        /* Clear statistic counters */
        ctx->fs_directory_count = 0;
@@ -142,11 +179,15 @@ errcode_t e2fsck_reset_context(e2fsck_t ctx)
        ctx->fs_dind_count = 0;
        ctx->fs_tind_count = 0;
        ctx->fs_fragmented = 0;
+       ctx->fs_fragmented_dir = 0;
        ctx->large_files = 0;
 
+       for (i=0; i < MAX_EXTENT_DEPTH_COUNT; i++)
+               ctx->extent_depth_count[i] = 0;
+
        /* Reset the superblock to the user's requested value */
        ctx->superblock = ctx->use_superblock;
-       
+
        return 0;
 }
 
@@ -154,11 +195,33 @@ void e2fsck_free_context(e2fsck_t ctx)
 {
        if (!ctx)
                return;
-       
+
        e2fsck_reset_context(ctx);
        if (ctx->blkid)
                blkid_put_cache(ctx->blkid);
-                       
+
+       if (ctx->profile)
+               profile_release(ctx->profile);
+
+       if (ctx->filesystem_name)
+               ext2fs_free_mem(&ctx->filesystem_name);
+
+       if (ctx->device_name)
+               ext2fs_free_mem(&ctx->device_name);
+
+       if (ctx->log_fn)
+               free(ctx->log_fn);
+
+       if (ctx->logf)
+               fclose(ctx->logf);
+
+       if (ctx->problem_log_fn)
+               free(ctx->problem_log_fn);
+
+       if (ctx->problem_logf) {
+               fputs("</problem_log>\n", ctx->problem_logf);
+               fclose(ctx->problem_logf);
+       }
        ext2fs_free_mem(&ctx);
 }
 
@@ -168,11 +231,9 @@ void e2fsck_free_context(e2fsck_t ctx)
  */
 typedef void (*pass_t)(e2fsck_t ctx);
 
-pass_t e2fsck_passes[] = {
-       e2fsck_pass1, e2fsck_pass2, e2fsck_pass3, e2fsck_pass4,
-       e2fsck_pass5, 0 };
-
-#define E2F_FLAG_RUN_RETURN    (E2F_FLAG_SIGNAL_MASK|E2F_FLAG_RESTART)
+static pass_t e2fsck_passes[] = {
+       e2fsck_pass1, e2fsck_pass1e, e2fsck_pass2, e2fsck_pass3,
+       e2fsck_pass4, e2fsck_pass5, 0 };
 
 int e2fsck_run(e2fsck_t ctx)
 {
@@ -186,16 +247,18 @@ int e2fsck_run(e2fsck_t ctx)
        }
        ctx->flags |= E2F_FLAG_SETJMP_OK;
 #endif
-               
+
        for (i=0; (e2fsck_pass = e2fsck_passes[i]); i++) {
                if (ctx->flags & E2F_FLAG_RUN_RETURN)
                        break;
+               if (e2fsck_mmp_update(ctx->fs))
+                       fatal_error(ctx, 0);
                e2fsck_pass(ctx);
                if (ctx->progress)
                        (void) (ctx->progress)(ctx, 0, 0, 0);
        }
        ctx->flags &= ~E2F_FLAG_SETJMP_OK;
-       
+
        if (ctx->flags & E2F_FLAG_RUN_RETURN)
                return (ctx->flags & E2F_FLAG_RUN_RETURN);
        return 0;