move e2fsck/* to e2fsck.c, one e2fsck_main and jornal exported, small automatic size reduction

30 files changed, 15465 insertions, 17233 deletions

diff --git a/e2fsprogs/Makefile.in b/e2fsprogs/Makefile.in
index e1459e05f..f7dbba30f 100644
--- a/e2fsprogs/Makefile.in
+++ b/e2fsprogs/Makefile.in
@@ -11,37 +11,33 @@ E2FSPROGS_DIR:=$(top_builddir)/e2fsprogs
 E2FSPROGS_CFLAGS := -I$(E2FSPROGS_DIR) -include $(E2FSPROGS_DIR)/e2fsbb.h
 
 BLKID_SRC   := cache.c dev.c devname.c devno.c blkid_getsize.c \
-               probe.c read.c resolve.c save.c tag.c resolve.c
+               probe.c read.c resolve.c save.c tag.c resolve.c
 BLKID_SRCS  := $(patsubst %,blkid/%, $(BLKID_SRC))
 BLKID_OBJS  := $(patsubst %.c,%.o, $(BLKID_SRCS))
 
-E2FSCK_SRC  := badblocks.c dict.c dirinfo.c dx_dirinfo.c e2fsck.c \
-               ea_refcount.c ehandler.c journal.c message.c pass1.c pass1b.c \
-               pass2.c pass3.c pass4.c pass5.c problem.c recovery.c region.c \
-               rehash.c revoke.c super.c swapfs.c util.c
-E2FSCK_SRCS := $(patsubst %,e2fsck/%, $(E2FSCK_SRC))
+E2FSCK_SRCS := e2fsck.c
 E2FSCK_OBJS := $(patsubst %.c,%.o, $(E2FSCK_SRCS))
 
 E2P_SRC     := fgetsetflags.c fgetsetversion.c pf.c iod.c mntopts.c \
-               feature.c ls.c uuid.c pe.c ostype.c ps.c hashstr.c \
-               parse_num.c
+               feature.c ls.c uuid.c pe.c ostype.c ps.c hashstr.c \
+               parse_num.c
 E2P_SRCS    := $(patsubst %,e2p/%, $(E2P_SRC))
 E2P_OBJS    := $(patsubst %.c,%.o, $(E2P_SRCS))
 
 EXT2FS_SRC  := gen_bitmap.c bitops.c ismounted.c mkjournal.c unix_io.c \
-               rw_bitmaps.c initialize.c bitmaps.c block.c \
-               ind_block.c inode.c freefs.c alloc_stats.c closefs.c \
-               openfs.c io_manager.c finddev.c read_bb.c alloc.c badblocks.c \
-               getsize.c getsectsize.c alloc_tables.c read_bb_file.c mkdir.c \
-               bb_inode.c newdir.c alloc_sb.c lookup.c dirblock.c expanddir.c \
-               dir_iterate.c link.c res_gdt.c icount.c get_pathname.c dblist.c \
-               dirhash.c version.c flushb.c unlink.c check_desc.c valid_blk.c \
-               ext_attr.c bmap.c dblist_dir.c ext2fs_inline.c
+               rw_bitmaps.c initialize.c bitmaps.c block.c \
+               ind_block.c inode.c freefs.c alloc_stats.c closefs.c \
+               openfs.c io_manager.c finddev.c read_bb.c alloc.c badblocks.c \
+               getsize.c getsectsize.c alloc_tables.c read_bb_file.c mkdir.c \
+               bb_inode.c newdir.c alloc_sb.c lookup.c dirblock.c expanddir.c \
+               dir_iterate.c link.c res_gdt.c icount.c get_pathname.c dblist.c \
+               dirhash.c version.c flushb.c unlink.c check_desc.c valid_blk.c \
+               ext_attr.c bmap.c dblist_dir.c ext2fs_inline.c
 EXT2FS_SRCS := $(patsubst %,ext2fs/%, $(EXT2FS_SRC))
 EXT2FS_OBJS := $(patsubst %.c,%.o, $(EXT2FS_SRCS))
 
 UUID_SRC    := compare.c gen_uuid.c pack.c parse.c unpack.c unparse.c \
-               uuid_time.c
+               uuid_time.c
 UUID_SRCS   := $(patsubst %,uuid/%, $(UUID_SRC))
 UUID_OBJS   := $(patsubst %.c,%.o, $(UUID_SRCS))
 
diff --git a/e2fsprogs/e2fsck.c b/e2fsprogs/e2fsck.c
index db93ea0ce..74bc9f7b8 100644
--- a/e2fsprogs/e2fsck.c
+++ b/e2fsprogs/e2fsck.c
@@ -1,59 +1,15413 @@
 /*
- * unix.c - The unix-specific code for e2fsck
- * 
- * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
+ * e2fsck
+ *
+ * Copyright (C) 1993, 1994 Theodore Ts'o.  This file may be
+ * redistributed under the terms of the GNU Public License.
  *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
  */
 
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE 1 /* get strnlen() */
+#endif
+#include <sys/types.h>
+#include <inttypes.h>
 #include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <time.h>
 #include <fcntl.h>
 #include <ctype.h>
-#include <time.h>
-#ifdef HAVE_SIGNAL_H
+#include <setjmp.h>
+#include <errno.h>
+#include <getopt.h>
+#include <limits.h>
+#include <stddef.h>
+#include <assert.h>
 #include <signal.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <sys/resource.h>
+#include <sys/param.h>
+#include <sys/mount.h>
+#include <sys/ioctl.h>
+#include <malloc.h>
+#include <termios.h>
+#include <mntent.h>
+#include <dirent.h>
+
+#include "e2fsbb.h"
+
+#include "ext2fs/ext2_fs.h"
+#include "ext2fs/ext2fs.h"
+#include "blkid/blkid.h"
+#include "ext2fs/ext2_ext_attr.h"
+#include "uuid/uuid.h"
+
+#ifdef __GNUC__
+#define _INLINE_ __inline__
+#define EXT2FS_ATTR(x) __attribute__(x)
+#else
+#define _INLINE_
+#define EXT2FS_ATTR(x)
 #endif
-#ifdef HAVE_GETOPT_H
-#include <getopt.h>
+
+/*
+ * Exit codes used by fsck-type programs
+ */
+#define FSCK_OK          0      /* No errors */
+#define FSCK_NONDESTRUCT 1      /* File system errors corrected */
+#define FSCK_REBOOT      2      /* System should be rebooted */
+#define FSCK_UNCORRECTED 4      /* File system errors left uncorrected */
+#define FSCK_ERROR       8      /* Operational error */
+#define FSCK_USAGE       16     /* Usage or syntax error */
+#define FSCK_CANCELED    32     /* Aborted with a signal or ^C */
+#define FSCK_LIBRARY     128    /* Shared library error */
+
+/*
+ * The last ext2fs revision level that this version of e2fsck is able to
+ * support
+ */
+#define E2FSCK_CURRENT_REV      1
+
+/*
+ * The directory information structure; stores directory information
+ * collected in earlier passes, to avoid disk i/o in fetching the
+ * directory information.
+ */
+struct dir_info {
+        ext2_ino_t              ino;    /* Inode number */
+        ext2_ino_t              dotdot; /* Parent according to '..' */
+        ext2_ino_t              parent; /* Parent according to treewalk */
+};
+
+
+/*
+ * The indexed directory information structure; stores information for
+ * directories which contain a hash tree index.
+ */
+struct dx_dir_info {
+        ext2_ino_t              ino;            /* Inode number */
+        int                     numblocks;      /* number of blocks */
+        int                     hashversion;
+        short                   depth;          /* depth of tree */
+        struct dx_dirblock_info *dx_block;      /* Array of size numblocks */
+};
+
+#define DX_DIRBLOCK_ROOT        1
+#define DX_DIRBLOCK_LEAF        2
+#define DX_DIRBLOCK_NODE        3
+#define DX_DIRBLOCK_CORRUPT     4
+#define DX_DIRBLOCK_CLEARED     8
+
+struct dx_dirblock_info {
+        int             type;
+        blk_t           phys;
+        int             flags;
+        blk_t           parent;
+        ext2_dirhash_t  min_hash;
+        ext2_dirhash_t  max_hash;
+        ext2_dirhash_t  node_min_hash;
+        ext2_dirhash_t  node_max_hash;
+};
+
+#define DX_FLAG_REFERENCED      1
+#define DX_FLAG_DUP_REF         2
+#define DX_FLAG_FIRST           4
+#define DX_FLAG_LAST            8
+
+#ifdef RESOURCE_TRACK
+/*
+ * This structure is used for keeping track of how much resources have
+ * been used for a particular pass of e2fsck.
+ */
+struct resource_track {
+        struct timeval time_start;
+        struct timeval user_start;
+        struct timeval system_start;
+        void    *brk_start;
+};
+#endif
+
+/*
+ * E2fsck options
+ */
+#define E2F_OPT_READONLY        0x0001
+#define E2F_OPT_PREEN           0x0002
+#define E2F_OPT_YES             0x0004
+#define E2F_OPT_NO              0x0008
+#define E2F_OPT_TIME            0x0010
+#define E2F_OPT_TIME2           0x0020
+#define E2F_OPT_CHECKBLOCKS     0x0040
+#define E2F_OPT_DEBUG           0x0080
+#define E2F_OPT_FORCE           0x0100
+#define E2F_OPT_WRITECHECK      0x0200
+#define E2F_OPT_COMPRESS_DIRS   0x0400
+
+/*
+ * E2fsck flags
+ */
+#define E2F_FLAG_ABORT          0x0001 /* Abort signaled */
+#define E2F_FLAG_CANCEL         0x0002 /* Cancel signaled */
+#define E2F_FLAG_SIGNAL_MASK    0x0003
+#define E2F_FLAG_RESTART        0x0004 /* Restart signaled */
+
+#define E2F_FLAG_SETJMP_OK      0x0010 /* Setjmp valid for abort */
+
+#define E2F_FLAG_PROG_BAR       0x0020 /* Progress bar on screen */
+#define E2F_FLAG_PROG_SUPPRESS  0x0040 /* Progress suspended */
+#define E2F_FLAG_JOURNAL_INODE  0x0080 /* Create a new ext3 journal inode */
+#define E2F_FLAG_SB_SPECIFIED   0x0100 /* The superblock was explicitly
+                                        * specified by the user */
+#define E2F_FLAG_RESTARTED      0x0200 /* E2fsck has been restarted */
+#define E2F_FLAG_RESIZE_INODE   0x0400 /* Request to recreate resize inode */
+
+/*
+ * Defines for indicating the e2fsck pass number
+ */
+#define E2F_PASS_1      1
+#define E2F_PASS_2      2
+#define E2F_PASS_3      3
+#define E2F_PASS_4      4
+#define E2F_PASS_5      5
+#define E2F_PASS_1B     6
+
+/*
+ * Define the extended attribute refcount structure
+ */
+typedef struct ea_refcount *ext2_refcount_t;
+
+/*
+ * This is the global e2fsck structure.
+ */
+typedef struct e2fsck_struct *e2fsck_t;
+
+struct e2fsck_struct {
+        ext2_filsys fs;
+        const char *program_name;
+        char *filesystem_name;
+        char *device_name;
+        char *io_options;
+        int     flags;          /* E2fsck internal flags */
+        int     options;
+        blk_t   use_superblock; /* sb requested by user */
+        blk_t   superblock;     /* sb used to open fs */
+        int     blocksize;      /* blocksize */
+        blk_t   num_blocks;     /* Total number of blocks */
+        int     mount_flags;
+        blkid_cache blkid;      /* blkid cache */
+
+        jmp_buf abort_loc;
+
+        unsigned long abort_code;
+
+        int (*progress)(e2fsck_t ctx, int pass, unsigned long cur,
+                        unsigned long max);
+
+        ext2fs_inode_bitmap inode_used_map; /* Inodes which are in use */
+        ext2fs_inode_bitmap inode_bad_map; /* Inodes which are bad somehow */
+        ext2fs_inode_bitmap inode_dir_map; /* Inodes which are directories */
+        ext2fs_inode_bitmap inode_bb_map; /* Inodes which are in bad blocks */
+        ext2fs_inode_bitmap inode_imagic_map; /* AFS inodes */
+        ext2fs_inode_bitmap inode_reg_map; /* Inodes which are regular files*/
+
+        ext2fs_block_bitmap block_found_map; /* Blocks which are in use */
+        ext2fs_block_bitmap block_dup_map; /* Blks referenced more than once */
+        ext2fs_block_bitmap block_ea_map; /* Blocks which are used by EA's */
+
+        /*
+         * Inode count arrays
+         */
+        ext2_icount_t   inode_count;
+        ext2_icount_t inode_link_info;
+
+        ext2_refcount_t refcount;
+        ext2_refcount_t refcount_extra;
+
+        /*
+         * Array of flags indicating whether an inode bitmap, block
+         * bitmap, or inode table is invalid
+         */
+        int *invalid_inode_bitmap_flag;
+        int *invalid_block_bitmap_flag;
+        int *invalid_inode_table_flag;
+        int invalid_bitmaps;    /* There are invalid bitmaps/itable */
+
+        /*
+         * Block buffer
+         */
+        char *block_buf;
+
+        /*
+         * For pass1_check_directory and pass1_get_blocks
+         */
+        ext2_ino_t stashed_ino;
+        struct ext2_inode *stashed_inode;
+
+        /*
+         * Location of the lost and found directory
+         */
+        ext2_ino_t lost_and_found;
+        int bad_lost_and_found;
+
+        /*
+         * Directory information
+         */
+        int             dir_info_count;
+        int             dir_info_size;
+        struct dir_info *dir_info;
+
+        /*
+         * Indexed directory information
+         */
+        int             dx_dir_info_count;
+        int             dx_dir_info_size;
+        struct dx_dir_info *dx_dir_info;
+
+        /*
+         * Directories to hash
+         */
+        ext2_u32_list   dirs_to_hash;
+
+        /*
+         * Tuning parameters
+         */
+        int process_inode_size;
+        int inode_buffer_blocks;
+
+        /*
+         * ext3 journal support
+         */
+        io_channel      journal_io;
+        char    *journal_name;
+
+#ifdef RESOURCE_TRACK
+        /*
+         * For timing purposes
+         */
+        struct resource_track   global_rtrack;
+#endif
+
+        /*
+         * How we display the progress update (for unix)
+         */
+        int progress_fd;
+        int progress_pos;
+        int progress_last_percent;
+        unsigned int progress_last_time;
+        int interactive;        /* Are we connected directly to a tty? */
+        char start_meta[2], stop_meta[2];
+
+        /* File counts */
+        int fs_directory_count;
+        int fs_regular_count;
+        int fs_blockdev_count;
+        int fs_chardev_count;
+        int fs_links_count;
+        int fs_symlinks_count;
+        int fs_fast_symlinks_count;
+        int fs_fifo_count;
+        int fs_total_count;
+        int fs_badblocks_count;
+        int fs_sockets_count;
+        int fs_ind_count;
+        int fs_dind_count;
+        int fs_tind_count;
+        int fs_fragmented;
+        int large_files;
+        int fs_ext_attr_inodes;
+        int fs_ext_attr_blocks;
+
+        int ext_attr_ver;
+
+        /*
+         * For the use of callers of the e2fsck functions; not used by
+         * e2fsck functions themselves.
+         */
+        void *priv_data;
+};
+
+/* Used by the region allocation code */
+typedef __u32 region_addr_t;
+typedef struct region_struct *region_t;
+
+/*
+ * Procedure declarations
+ */
+
+static void e2fsck_pass1(e2fsck_t ctx);
+static void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf);
+static void e2fsck_pass2(e2fsck_t ctx);
+static void e2fsck_pass3(e2fsck_t ctx);
+static void e2fsck_pass4(e2fsck_t ctx);
+static void e2fsck_pass5(e2fsck_t ctx);
+
+/* e2fsck.c */
+static errcode_t e2fsck_allocate_context(e2fsck_t *ret);
+static errcode_t e2fsck_reset_context(e2fsck_t ctx);
+static void e2fsck_free_context(e2fsck_t ctx);
+static int e2fsck_run(e2fsck_t ctx);
+
+
+/* badblock.c */
+static void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
+                                 int replace_bad_blocks);
+
+/* dirinfo.c */
+static void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent);
+static struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino);
+static void e2fsck_free_dir_info(e2fsck_t ctx);
+static int e2fsck_get_num_dirinfo(e2fsck_t ctx);
+static struct dir_info *e2fsck_dir_info_iter(e2fsck_t ctx, int *control);
+
+/* dx_dirinfo.c */
+static void e2fsck_add_dx_dir(e2fsck_t ctx, ext2_ino_t ino, int num_blocks);
+static struct dx_dir_info *e2fsck_get_dx_dir_info(e2fsck_t ctx, ext2_ino_t ino);
+static void e2fsck_free_dx_dir_info(e2fsck_t ctx);
+static struct dx_dir_info *e2fsck_dx_dir_info_iter(e2fsck_t ctx, int *control);
+
+/* ea_refcount.c */
+static errcode_t ea_refcount_create(int size, ext2_refcount_t *ret);
+static void ea_refcount_free(ext2_refcount_t refcount);
+static errcode_t ea_refcount_increment(ext2_refcount_t refcount,
+                                       blk_t blk, int *ret);
+static errcode_t ea_refcount_decrement(ext2_refcount_t refcount,
+                                       blk_t blk, int *ret);
+static errcode_t ea_refcount_store(ext2_refcount_t refcount,
+                                   blk_t blk, int count);
+static void ea_refcount_intr_begin(ext2_refcount_t refcount);
+static blk_t ea_refcount_intr_next(ext2_refcount_t refcount, int *ret);
+
+/* ehandler.c */
+static const char *ehandler_operation(const char *op);
+static void ehandler_init(io_channel channel);
+
+/* journal.c */
+static int e2fsck_check_ext3_journal(e2fsck_t ctx);
+static int e2fsck_run_ext3_journal(e2fsck_t ctx);
+static void e2fsck_move_ext3_journal(e2fsck_t ctx);
+
+/* pass1.c */
+static void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool);
+static int e2fsck_pass1_check_device_inode(ext2_filsys fs,
+                                           struct ext2_inode *inode);
+static int e2fsck_pass1_check_symlink(ext2_filsys fs,
+                                      struct ext2_inode *inode, char *buf);
+
+/* pass2.c */
+static int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir,
+                                    ext2_ino_t ino, char *buf);
+
+/* pass3.c */
+static int e2fsck_reconnect_file(e2fsck_t ctx, ext2_ino_t inode);
+static errcode_t e2fsck_expand_directory(e2fsck_t ctx, ext2_ino_t dir,
+                                         int num, int gauranteed_size);
+static ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix);
+static errcode_t e2fsck_adjust_inode_count(e2fsck_t ctx, ext2_ino_t ino,
+                                           int adj);
+
+
+/* region.c */
+static region_t region_create(region_addr_t min, region_addr_t max);
+static void region_free(region_t region);
+static int region_allocate(region_t region, region_addr_t start, int n);
+
+/* rehash.c */
+static errcode_t e2fsck_rehash_dir(e2fsck_t ctx, ext2_ino_t ino);
+static void e2fsck_rehash_directories(e2fsck_t ctx);
+
+/* super.c */
+static void check_super_block(e2fsck_t ctx);
+static errcode_t e2fsck_get_device_size(e2fsck_t ctx);
+
+#ifdef ENABLE_SWAPFS
+/* swapfs.c */
+static void swap_filesys(e2fsck_t ctx);
+#endif
+
+/* util.c */
+static void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size,
+                                    const char *description);
+static int ask(e2fsck_t ctx, const char * string, int def);
+static int ask_yn(const char * string, int def);
+static void e2fsck_read_bitmaps(e2fsck_t ctx);
+static void e2fsck_write_bitmaps(e2fsck_t ctx);
+static void preenhalt(e2fsck_t ctx);
+static char *string_copy(e2fsck_t ctx, const char *str, int len);
+#ifdef RESOURCE_TRACK
+static void print_resource_track(const char *desc,
+                                 struct resource_track *track);
+static void init_resource_track(struct resource_track *track);
+#endif
+static void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino,
+                              struct ext2_inode * inode, const char * proc);
+static void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino,
+                               struct ext2_inode * inode, const char * proc);
+#ifdef MTRACE
+static void mtrace_print(char *mesg);
+#endif
+static blk_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs,
+                           const char *name, io_manager manager);
+static int ext2_file_type(unsigned int mode);
+
+/* unix.c */
+static void e2fsck_clear_progbar(e2fsck_t ctx);
+static int e2fsck_simple_progress(e2fsck_t ctx, const char *label,
+                                  float percent, unsigned int dpynum);
+/*
+ * problem.h --- e2fsck problem error codes
+ */
+
+typedef __u32 problem_t;
+
+struct problem_context {
+        errcode_t       errcode;
+        ext2_ino_t ino, ino2, dir;
+        struct ext2_inode *inode;
+        struct ext2_dir_entry *dirent;
+        blk_t   blk, blk2;
+        e2_blkcnt_t     blkcount;
+        int             group;
+        __u64   num;
+        const char *str;
+};
+
+/*
+ * We define a set of "latch groups"; these are problems which are
+ * handled as a set.  The user answers once for a particular latch
+ * group.
+ */
+#define PR_LATCH_MASK   0x0ff0  /* Latch mask */
+#define PR_LATCH_BLOCK  0x0010  /* Latch for illegal blocks (pass 1) */
+#define PR_LATCH_BBLOCK 0x0020  /* Latch for bad block inode blocks (pass 1) */
+#define PR_LATCH_IBITMAP 0x0030 /* Latch for pass 5 inode bitmap proc. */
+#define PR_LATCH_BBITMAP 0x0040 /* Latch for pass 5 inode bitmap proc. */
+#define PR_LATCH_RELOC  0x0050  /* Latch for superblock relocate hint */
+#define PR_LATCH_DBLOCK 0x0060  /* Latch for pass 1b dup block headers */
+#define PR_LATCH_LOW_DTIME 0x0070 /* Latch for pass1 orphaned list refugees */
+#define PR_LATCH_TOOBIG 0x0080  /* Latch for file to big errors */
+#define PR_LATCH_OPTIMIZE_DIR 0x0090 /* Latch for optimize directories */
+
+#define PR_LATCH(x)     ((((x) & PR_LATCH_MASK) >> 4) - 1)
+
+/*
+ * Latch group descriptor flags
+ */
+#define PRL_YES         0x0001  /* Answer yes */
+#define PRL_NO          0x0002  /* Answer no */
+#define PRL_LATCHED     0x0004  /* The latch group is latched */
+#define PRL_SUPPRESS    0x0008  /* Suppress all latch group questions */
+
+#define PRL_VARIABLE    0x000f  /* All the flags that need to be reset */
+
+/*
+ * Pre-Pass 1 errors
+ */
+
+/* Block bitmap not in group */
+#define PR_0_BB_NOT_GROUP       0x000001
+
+/* Inode bitmap not in group */
+#define PR_0_IB_NOT_GROUP       0x000002
+
+/* Inode table not in group */
+#define PR_0_ITABLE_NOT_GROUP   0x000003
+
+/* Superblock corrupt */
+#define PR_0_SB_CORRUPT         0x000004
+
+/* Filesystem size is wrong */
+#define PR_0_FS_SIZE_WRONG      0x000005
+
+/* Fragments not supported */
+#define PR_0_NO_FRAGMENTS       0x000006
+
+/* Bad blocks_per_group */
+#define PR_0_BLOCKS_PER_GROUP   0x000007
+
+/* Bad first_data_block */
+#define PR_0_FIRST_DATA_BLOCK   0x000008
+
+/* Adding UUID to filesystem */
+#define PR_0_ADD_UUID           0x000009
+
+/* Relocate hint */
+#define PR_0_RELOCATE_HINT      0x00000A
+
+/* Miscellaneous superblock corruption */
+#define PR_0_MISC_CORRUPT_SUPER 0x00000B
+
+/* Error determing physical device size of filesystem */
+#define PR_0_GETSIZE_ERROR      0x00000C
+
+/* Inode count in the superblock incorrect */
+#define PR_0_INODE_COUNT_WRONG  0x00000D
+
+/* The Hurd does not support the filetype feature */
+#define PR_0_HURD_CLEAR_FILETYPE 0x00000E
+
+/* Journal inode is invalid */
+#define PR_0_JOURNAL_BAD_INODE  0x00000F
+
+/* The external journal has multiple filesystems (which we can't handle yet) */
+#define PR_0_JOURNAL_UNSUPP_MULTIFS 0x000010
+
+/* Can't find external journal */
+#define PR_0_CANT_FIND_JOURNAL  0x000011
+
+/* External journal has bad superblock */
+#define PR_0_EXT_JOURNAL_BAD_SUPER 0x000012
+
+/* Superblock has a bad journal UUID */
+#define PR_0_JOURNAL_BAD_UUID   0x000013
+
+/* Journal has an unknown superblock type */
+#define PR_0_JOURNAL_UNSUPP_SUPER 0x000014
+
+/* Journal superblock is corrupt */
+#define PR_0_JOURNAL_BAD_SUPER  0x000015
+
+/* Journal superblock is corrupt */
+#define PR_0_JOURNAL_HAS_JOURNAL 0x000016
+
+/* Superblock has recovery flag set but no journal */
+#define PR_0_JOURNAL_RECOVER_SET 0x000017
+
+/* Journal has data, but recovery flag is clear */
+#define PR_0_JOURNAL_RECOVERY_CLEAR 0x000018
+
+/* Ask if we should clear the journal */
+#define PR_0_JOURNAL_RESET_JOURNAL 0x000019
+
+/* Filesystem revision is 0, but feature flags are set */
+#define PR_0_FS_REV_LEVEL       0x00001A
+
+/* Clearing orphan inode */
+#define PR_0_ORPHAN_CLEAR_INODE                 0x000020
+
+/* Illegal block found in orphaned inode */
+#define PR_0_ORPHAN_ILLEGAL_BLOCK_NUM           0x000021
+
+/* Already cleared block found in orphaned inode */
+#define PR_0_ORPHAN_ALREADY_CLEARED_BLOCK       0x000022
+
+/* Illegal orphan inode in superblock */
+#define PR_0_ORPHAN_ILLEGAL_HEAD_INODE          0x000023
+
+/* Illegal inode in orphaned inode list */
+#define PR_0_ORPHAN_ILLEGAL_INODE               0x000024
+
+/* Journal has unsupported read-only feature - abort */
+#define PR_0_JOURNAL_UNSUPP_ROCOMPAT            0x000025
+
+/* Journal has unsupported incompatible feature - abort */
+#define PR_0_JOURNAL_UNSUPP_INCOMPAT            0x000026
+
+/* Journal has unsupported version number */
+#define PR_0_JOURNAL_UNSUPP_VERSION             0x000027
+
+/* Moving journal to hidden file */
+#define PR_0_MOVE_JOURNAL                       0x000028
+
+/* Error moving journal */
+#define PR_0_ERR_MOVE_JOURNAL                   0x000029
+
+/* Clearing V2 journal superblock */
+#define PR_0_CLEAR_V2_JOURNAL                   0x00002A
+
+/* Run journal anyway */
+#define PR_0_JOURNAL_RUN                        0x00002B
+
+/* Run journal anyway by default */
+#define PR_0_JOURNAL_RUN_DEFAULT                0x00002C
+
+/* Backup journal inode blocks */
+#define PR_0_BACKUP_JNL                         0x00002D
+
+/* Reserved blocks w/o resize_inode */
+#define PR_0_NONZERO_RESERVED_GDT_BLOCKS        0x00002E
+
+/* Resize_inode not enabled, but resize inode is non-zero */
+#define PR_0_CLEAR_RESIZE_INODE                 0x00002F
+
+/* Resize inode invalid */
+#define PR_0_RESIZE_INODE_INVALID               0x000030
+
+/*
+ * Pass 1 errors
+ */
+
+/* Pass 1: Checking inodes, blocks, and sizes */
+#define PR_1_PASS_HEADER                0x010000
+
+/* Root directory is not an inode */
+#define PR_1_ROOT_NO_DIR                0x010001
+
+/* Root directory has dtime set */
+#define PR_1_ROOT_DTIME                 0x010002
+
+/* Reserved inode has bad mode */
+#define PR_1_RESERVED_BAD_MODE          0x010003
+
+/* Deleted inode has zero dtime */
+#define PR_1_ZERO_DTIME                 0x010004
+
+/* Inode in use, but dtime set */
+#define PR_1_SET_DTIME                  0x010005
+
+/* Zero-length directory */
+#define PR_1_ZERO_LENGTH_DIR            0x010006
+
+/* Block bitmap conflicts with some other fs block */
+#define PR_1_BB_CONFLICT                0x010007
+
+/* Inode bitmap conflicts with some other fs block */
+#define PR_1_IB_CONFLICT                0x010008
+
+/* Inode table conflicts with some other fs block */
+#define PR_1_ITABLE_CONFLICT            0x010009
+
+/* Block bitmap is on a bad block */
+#define PR_1_BB_BAD_BLOCK               0x01000A
+
+/* Inode bitmap is on a bad block */
+#define PR_1_IB_BAD_BLOCK               0x01000B
+
+/* Inode has incorrect i_size */
+#define PR_1_BAD_I_SIZE                 0x01000C
+
+/* Inode has incorrect i_blocks */
+#define PR_1_BAD_I_BLOCKS               0x01000D
+
+/* Illegal block number in inode */
+#define PR_1_ILLEGAL_BLOCK_NUM          0x01000E
+
+/* Block number overlaps fs metadata */
+#define PR_1_BLOCK_OVERLAPS_METADATA    0x01000F
+
+/* Inode has illegal blocks (latch question) */
+#define PR_1_INODE_BLOCK_LATCH          0x010010
+
+/* Too many bad blocks in inode */
+#define PR_1_TOO_MANY_BAD_BLOCKS        0x010011
+
+/* Illegal block number in bad block inode */
+#define PR_1_BB_ILLEGAL_BLOCK_NUM       0x010012
+
+/* Bad block inode has illegal blocks (latch question) */
+#define PR_1_INODE_BBLOCK_LATCH         0x010013
+
+/* Duplicate or bad blocks in use! */
+#define PR_1_DUP_BLOCKS_PREENSTOP       0x010014
+
+/* Bad block used as bad block indirect block */
+#define PR_1_BBINODE_BAD_METABLOCK      0x010015
+
+/* Inconsistency can't be fixed prompt */
+#define PR_1_BBINODE_BAD_METABLOCK_PROMPT 0x010016
+
+/* Bad primary block */
+#define PR_1_BAD_PRIMARY_BLOCK          0x010017
+
+/* Bad primary block prompt */
+#define PR_1_BAD_PRIMARY_BLOCK_PROMPT   0x010018
+
+/* Bad primary superblock */
+#define PR_1_BAD_PRIMARY_SUPERBLOCK     0x010019
+
+/* Bad primary block group descriptors */
+#define PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR 0x01001A
+
+/* Bad superblock in group */
+#define PR_1_BAD_SUPERBLOCK             0x01001B
+
+/* Bad block group descriptors in group */
+#define PR_1_BAD_GROUP_DESCRIPTORS      0x01001C
+
+/* Block claimed for no reason */
+#define PR_1_PROGERR_CLAIMED_BLOCK      0x01001D
+
+/* Error allocating blocks for relocating metadata */
+#define PR_1_RELOC_BLOCK_ALLOCATE       0x01001E
+
+/* Error allocating block buffer during relocation process */
+#define PR_1_RELOC_MEMORY_ALLOCATE      0x01001F
+
+/* Relocating metadata group information from X to Y */
+#define PR_1_RELOC_FROM_TO              0x010020
+
+/* Relocating metatdata group information to X */
+#define PR_1_RELOC_TO                   0x010021
+
+/* Block read error during relocation process */
+#define PR_1_RELOC_READ_ERR             0x010022
+
+/* Block write error during relocation process */
+#define PR_1_RELOC_WRITE_ERR            0x010023
+
+/* Error allocating inode bitmap */
+#define PR_1_ALLOCATE_IBITMAP_ERROR     0x010024
+
+/* Error allocating block bitmap */
+#define PR_1_ALLOCATE_BBITMAP_ERROR     0x010025
+
+/* Error allocating icount structure */
+#define PR_1_ALLOCATE_ICOUNT            0x010026
+
+/* Error allocating dbcount */
+#define PR_1_ALLOCATE_DBCOUNT           0x010027
+
+/* Error while scanning inodes */
+#define PR_1_ISCAN_ERROR                0x010028
+
+/* Error while iterating over blocks */
+#define PR_1_BLOCK_ITERATE              0x010029
+
+/* Error while storing inode count information */
+#define PR_1_ICOUNT_STORE               0x01002A
+
+/* Error while storing directory block information */
+#define PR_1_ADD_DBLOCK                 0x01002B
+
+/* Error while reading inode (for clearing) */
+#define PR_1_READ_INODE                 0x01002C
+
+/* Suppress messages prompt */
+#define PR_1_SUPPRESS_MESSAGES          0x01002D
+
+/* Imagic flag set on an inode when filesystem doesn't support it */
+#define PR_1_SET_IMAGIC                 0x01002F
+
+/* Immutable flag set on a device or socket inode */
+#define PR_1_SET_IMMUTABLE              0x010030
+
+/* Compression flag set on a non-compressed filesystem */
+#define PR_1_COMPR_SET                  0x010031
+
+/* Non-zero size on on device, fifo or socket inode */
+#define PR_1_SET_NONZSIZE               0x010032
+
+/* Filesystem revision is 0, but feature flags are set */
+#define PR_1_FS_REV_LEVEL               0x010033
+
+/* Journal inode not in use, needs clearing */
+#define PR_1_JOURNAL_INODE_NOT_CLEAR    0x010034
+
+/* Journal inode has wrong mode */
+#define PR_1_JOURNAL_BAD_MODE           0x010035
+
+/* Inode that was part of orphan linked list */
+#define PR_1_LOW_DTIME                  0x010036
+
+/* Latch question which asks how to deal with low dtime inodes */
+#define PR_1_ORPHAN_LIST_REFUGEES       0x010037
+
+/* Error allocating refcount structure */
+#define PR_1_ALLOCATE_REFCOUNT          0x010038
+
+/* Error reading Extended Attribute block */
+#define PR_1_READ_EA_BLOCK              0x010039
+
+/* Invalid Extended Attribute block */
+#define PR_1_BAD_EA_BLOCK               0x01003A
+
+/* Error reading Extended Attribute block while fixing refcount -- abort */
+#define PR_1_EXTATTR_READ_ABORT         0x01003B
+
+/* Extended attribute reference count incorrect */
+#define PR_1_EXTATTR_REFCOUNT           0x01003C
+
+/* Error writing Extended Attribute block while fixing refcount */
+#define PR_1_EXTATTR_WRITE              0x01003D
+
+/* Multiple EA blocks not supported */
+#define PR_1_EA_MULTI_BLOCK             0x01003E
+
+/* Error allocating EA region allocation structure */
+#define PR_1_EA_ALLOC_REGION            0x01003F
+
+/* Error EA allocation collision */
+#define PR_1_EA_ALLOC_COLLISION         0x010040
+
+/* Bad extended attribute name */
+#define PR_1_EA_BAD_NAME                0x010041
+
+/* Bad extended attribute value */
+#define PR_1_EA_BAD_VALUE               0x010042
+
+/* Inode too big (latch question) */
+#define PR_1_INODE_TOOBIG               0x010043
+
+/* Directory too big */
+#define PR_1_TOOBIG_DIR                 0x010044
+
+/* Regular file too big */
+#define PR_1_TOOBIG_REG                 0x010045
+
+/* Symlink too big */
+#define PR_1_TOOBIG_SYMLINK             0x010046
+
+/* INDEX_FL flag set on a non-HTREE filesystem */
+#define PR_1_HTREE_SET                  0x010047
+
+/* INDEX_FL flag set on a non-directory */
+#define PR_1_HTREE_NODIR                0x010048
+
+/* Invalid root node in HTREE directory */
+#define PR_1_HTREE_BADROOT              0x010049
+
+/* Unsupported hash version in HTREE directory */
+#define PR_1_HTREE_HASHV                0x01004A
+
+/* Incompatible flag in HTREE root node */
+#define PR_1_HTREE_INCOMPAT             0x01004B
+
+/* HTREE too deep */
+#define PR_1_HTREE_DEPTH                0x01004C
+
+/* Bad block has indirect block that conflicts with filesystem block */
+#define PR_1_BB_FS_BLOCK                0x01004D
+
+/* Resize inode failed */
+#define PR_1_RESIZE_INODE_CREATE        0x01004E
+
+/* inode->i_size is too long */
+#define PR_1_EXTRA_ISIZE                0x01004F
+
+/* attribute name is too long */
+#define PR_1_ATTR_NAME_LEN              0x010050
+
+/* wrong EA value offset */
+#define PR_1_ATTR_VALUE_OFFSET          0x010051
+
+/* wrong EA blocknumber */
+#define PR_1_ATTR_VALUE_BLOCK           0x010052
+
+/* wrong EA value size */
+#define PR_1_ATTR_VALUE_SIZE            0x010053
+
+/* wrong EA hash value */
+#define PR_1_ATTR_HASH                  0x010054
+
+/*
+ * Pass 1b errors
+ */
+
+/* Pass 1B: Rescan for duplicate/bad blocks */
+#define PR_1B_PASS_HEADER       0x011000
+
+/* Duplicate/bad block(s) header */
+#define PR_1B_DUP_BLOCK_HEADER  0x011001
+
+/* Duplicate/bad block(s) in inode */
+#define PR_1B_DUP_BLOCK         0x011002
+
+/* Duplicate/bad block(s) end */
+#define PR_1B_DUP_BLOCK_END     0x011003
+
+/* Error while scanning inodes */
+#define PR_1B_ISCAN_ERROR       0x011004
+
+/* Error allocating inode bitmap */
+#define PR_1B_ALLOCATE_IBITMAP_ERROR 0x011005
+
+/* Error while iterating over blocks */
+#define PR_1B_BLOCK_ITERATE     0x0110006
+
+/* Error adjusting EA refcount */
+#define PR_1B_ADJ_EA_REFCOUNT   0x0110007
+
+
+/* Pass 1C: Scan directories for inodes with dup blocks. */
+#define PR_1C_PASS_HEADER       0x012000
+
+
+/* Pass 1D: Reconciling duplicate blocks */
+#define PR_1D_PASS_HEADER       0x013000
+
+/* File has duplicate blocks */
+#define PR_1D_DUP_FILE          0x013001
+
+/* List of files sharing duplicate blocks */
+#define PR_1D_DUP_FILE_LIST     0x013002
+
+/* File sharing blocks with filesystem metadata  */
+#define PR_1D_SHARE_METADATA    0x013003
+
+/* Report of how many duplicate/bad inodes */
+#define PR_1D_NUM_DUP_INODES    0x013004
+
+/* Duplicated blocks already reassigned or cloned. */
+#define PR_1D_DUP_BLOCKS_DEALT  0x013005
+
+/* Clone duplicate/bad blocks? */
+#define PR_1D_CLONE_QUESTION    0x013006
+
+/* Delete file? */
+#define PR_1D_DELETE_QUESTION   0x013007
+
+/* Couldn't clone file (error) */
+#define PR_1D_CLONE_ERROR       0x013008
+
+/*
+ * Pass 2 errors
+ */
+
+/* Pass 2: Checking directory structure */
+#define PR_2_PASS_HEADER        0x020000
+
+/* Bad inode number for '.' */
+#define PR_2_BAD_INODE_DOT      0x020001
+
+/* Directory entry has bad inode number */
+#define PR_2_BAD_INO            0x020002
+
+/* Directory entry has deleted or unused inode */
+#define PR_2_UNUSED_INODE       0x020003
+
+/* Directry entry is link to '.' */
+#define PR_2_LINK_DOT           0x020004
+
+/* Directory entry points to inode now located in a bad block */
+#define PR_2_BB_INODE           0x020005
+
+/* Directory entry contains a link to a directory */
+#define PR_2_LINK_DIR           0x020006
+
+/* Directory entry contains a link to the root directry */
+#define PR_2_LINK_ROOT          0x020007
+
+/* Directory entry has illegal characters in its name */
+#define PR_2_BAD_NAME           0x020008
+
+/* Missing '.' in directory inode */
+#define PR_2_MISSING_DOT        0x020009
+
+/* Missing '..' in directory inode */
+#define PR_2_MISSING_DOT_DOT    0x02000A
+
+/* First entry in directory inode doesn't contain '.' */
+#define PR_2_1ST_NOT_DOT        0x02000B
+
+/* Second entry in directory inode doesn't contain '..' */
+#define PR_2_2ND_NOT_DOT_DOT    0x02000C
+
+/* i_faddr should be zero */
+#define PR_2_FADDR_ZERO         0x02000D
+
+/* i_file_acl should be zero */
+#define PR_2_FILE_ACL_ZERO      0x02000E
+
+/* i_dir_acl should be zero */
+#define PR_2_DIR_ACL_ZERO       0x02000F
+
+/* i_frag should be zero */
+#define PR_2_FRAG_ZERO          0x020010
+
+/* i_fsize should be zero */
+#define PR_2_FSIZE_ZERO         0x020011
+
+/* inode has bad mode */
+#define PR_2_BAD_MODE           0x020012
+
+/* directory corrupted */
+#define PR_2_DIR_CORRUPTED      0x020013
+
+/* filename too long */
+#define PR_2_FILENAME_LONG      0x020014
+
+/* Directory inode has a missing block (hole) */
+#define PR_2_DIRECTORY_HOLE     0x020015
+
+/* '.' is not NULL terminated */
+#define PR_2_DOT_NULL_TERM      0x020016
+
+/* '..' is not NULL terminated */
+#define PR_2_DOT_DOT_NULL_TERM  0x020017
+
+/* Illegal character device in inode */
+#define PR_2_BAD_CHAR_DEV       0x020018
+
+/* Illegal block device in inode */
+#define PR_2_BAD_BLOCK_DEV      0x020019
+
+/* Duplicate '.' entry */
+#define PR_2_DUP_DOT            0x02001A
+
+/* Duplicate '..' entry */
+#define PR_2_DUP_DOT_DOT        0x02001B
+
+/* Internal error: couldn't find dir_info */
+#define PR_2_NO_DIRINFO         0x02001C
+
+/* Final rec_len is wrong */
+#define PR_2_FINAL_RECLEN       0x02001D
+
+/* Error allocating icount structure */
+#define PR_2_ALLOCATE_ICOUNT    0x02001E
+
+/* Error iterating over directory blocks */
+#define PR_2_DBLIST_ITERATE     0x02001F
+
+/* Error reading directory block */
+#define PR_2_READ_DIRBLOCK      0x020020
+
+/* Error writing directory block */
+#define PR_2_WRITE_DIRBLOCK     0x020021
+
+/* Error allocating new directory block */
+#define PR_2_ALLOC_DIRBOCK      0x020022
+
+/* Error deallocating inode */
+#define PR_2_DEALLOC_INODE      0x020023
+
+/* Directory entry for '.' is big.  Split? */
+#define PR_2_SPLIT_DOT          0x020024
+
+/* Illegal FIFO */
+#define PR_2_BAD_FIFO           0x020025
+
+/* Illegal socket */
+#define PR_2_BAD_SOCKET         0x020026
+
+/* Directory filetype not set */
+#define PR_2_SET_FILETYPE       0x020027
+
+/* Directory filetype incorrect */
+#define PR_2_BAD_FILETYPE       0x020028
+
+/* Directory filetype set when it shouldn't be */
+#define PR_2_CLEAR_FILETYPE     0x020029
+
+/* Directory filename can't be zero-length  */
+#define PR_2_NULL_NAME          0x020030
+
+/* Invalid symlink */
+#define PR_2_INVALID_SYMLINK    0x020031
+
+/* i_file_acl (extended attribute) is bad */
+#define PR_2_FILE_ACL_BAD       0x020032
+
+/* Filesystem contains large files, but has no such flag in sb */
+#define PR_2_FEATURE_LARGE_FILES 0x020033
+
+/* Node in HTREE directory not referenced */
+#define PR_2_HTREE_NOTREF       0x020034
+
+/* Node in HTREE directory referenced twice */
+#define PR_2_HTREE_DUPREF       0x020035
+
+/* Node in HTREE directory has bad min hash */
+#define PR_2_HTREE_MIN_HASH     0x020036
+
+/* Node in HTREE directory has bad max hash */
+#define PR_2_HTREE_MAX_HASH     0x020037
+
+/* Clear invalid HTREE directory */
+#define PR_2_HTREE_CLEAR        0x020038
+
+/* Clear the htree flag forcibly */
+/* #define PR_2_HTREE_FCLR      0x020039 */
+
+/* Bad block in htree interior node */
+#define PR_2_HTREE_BADBLK       0x02003A
+
+/* Error adjusting EA refcount */
+#define PR_2_ADJ_EA_REFCOUNT    0x02003B
+
+/* Invalid HTREE root node */
+#define PR_2_HTREE_BAD_ROOT     0x02003C
+
+/* Invalid HTREE limit */
+#define PR_2_HTREE_BAD_LIMIT    0x02003D
+
+/* Invalid HTREE count */
+#define PR_2_HTREE_BAD_COUNT    0x02003E
+
+/* HTREE interior node has out-of-order hashes in table */
+#define PR_2_HTREE_HASH_ORDER   0x02003F
+
+/* Node in HTREE directory has bad depth */
+#define PR_2_HTREE_BAD_DEPTH    0x020040
+
+/* Duplicate directory entry found */
+#define PR_2_DUPLICATE_DIRENT   0x020041
+
+/* Non-unique filename found */
+#define PR_2_NON_UNIQUE_FILE    0x020042
+
+/* Duplicate directory entry found */
+#define PR_2_REPORT_DUP_DIRENT  0x020043
+
+/*
+ * Pass 3 errors
+ */
+
+/* Pass 3: Checking directory connectivity */
+#define PR_3_PASS_HEADER                0x030000
+
+/* Root inode not allocated */
+#define PR_3_NO_ROOT_INODE              0x030001
+
+/* No room in lost+found */
+#define PR_3_EXPAND_LF_DIR              0x030002
+
+/* Unconnected directory inode */
+#define PR_3_UNCONNECTED_DIR            0x030003
+
+/* /lost+found not found */
+#define PR_3_NO_LF_DIR                  0x030004
+
+/* .. entry is incorrect */
+#define PR_3_BAD_DOT_DOT                0x030005
+
+/* Bad or non-existent /lost+found.  Cannot reconnect */
+#define PR_3_NO_LPF                     0x030006
+
+/* Could not expand /lost+found */
+#define PR_3_CANT_EXPAND_LPF            0x030007
+
+/* Could not reconnect inode */
+#define PR_3_CANT_RECONNECT             0x030008
+
+/* Error while trying to find /lost+found */
+#define PR_3_ERR_FIND_LPF               0x030009
+
+/* Error in ext2fs_new_block while creating /lost+found */
+#define PR_3_ERR_LPF_NEW_BLOCK          0x03000A
+
+/* Error in ext2fs_new_inode while creating /lost+found */
+#define PR_3_ERR_LPF_NEW_INODE          0x03000B
+
+/* Error in ext2fs_new_dir_block while creating /lost+found */
+#define PR_3_ERR_LPF_NEW_DIR_BLOCK      0x03000C
+
+/* Error while writing directory block for /lost+found */
+#define PR_3_ERR_LPF_WRITE_BLOCK        0x03000D
+
+/* Error while adjusting inode count */
+#define PR_3_ADJUST_INODE               0x03000E
+
+/* Couldn't fix parent directory -- error */
+#define PR_3_FIX_PARENT_ERR             0x03000F
+
+/* Couldn't fix parent directory -- couldn't find it */
+#define PR_3_FIX_PARENT_NOFIND          0x030010
+
+/* Error allocating inode bitmap */
+#define PR_3_ALLOCATE_IBITMAP_ERROR     0x030011
+
+/* Error creating root directory */
+#define PR_3_CREATE_ROOT_ERROR          0x030012
+
+/* Error creating lost and found directory */
+#define PR_3_CREATE_LPF_ERROR           0x030013
+
+/* Root inode is not directory; aborting */
+#define PR_3_ROOT_NOT_DIR_ABORT         0x030014
+
+/* Cannot proceed without a root inode. */
+#define PR_3_NO_ROOT_INODE_ABORT        0x030015
+
+/* Internal error: couldn't find dir_info */
+#define PR_3_NO_DIRINFO                 0x030016
+
+/* Lost+found is not a directory */
+#define PR_3_LPF_NOTDIR                 0x030017
+
+/*
+ * Pass 3a --- rehashing diretories
+ */
+/* Pass 3a: Reindexing directories */
+#define PR_3A_PASS_HEADER               0x031000
+
+/* Error iterating over directories */
+#define PR_3A_OPTIMIZE_ITER             0x031001
+
+/* Error rehash directory */
+#define PR_3A_OPTIMIZE_DIR_ERR          0x031002
+
+/* Rehashing dir header */
+#define PR_3A_OPTIMIZE_DIR_HEADER               0x031003
+
+/* Rehashing directory %d */
+#define PR_3A_OPTIMIZE_DIR              0x031004
+
+/* Rehashing dir end */
+#define PR_3A_OPTIMIZE_DIR_END          0x031005
+
+/*
+ * Pass 4 errors
+ */
+
+/* Pass 4: Checking reference counts */
+#define PR_4_PASS_HEADER        0x040000
+
+/* Unattached zero-length inode */
+#define PR_4_ZERO_LEN_INODE     0x040001
+
+/* Unattached inode */
+#define PR_4_UNATTACHED_INODE   0x040002
+
+/* Inode ref count wrong */
+#define PR_4_BAD_REF_COUNT      0x040003
+
+/* Inconsistent inode count information cached */
+#define PR_4_INCONSISTENT_COUNT 0x040004
+
+/*
+ * Pass 5 errors
+ */
+
+/* Pass 5: Checking group summary information */
+#define PR_5_PASS_HEADER                0x050000
+
+/* Padding at end of inode bitmap is not set. */
+#define PR_5_INODE_BMAP_PADDING         0x050001
+
+/* Padding at end of block bitmap is not set. */
+#define PR_5_BLOCK_BMAP_PADDING         0x050002
+
+/* Block bitmap differences header */
+#define PR_5_BLOCK_BITMAP_HEADER        0x050003
+
+/* Block not used, but marked in bitmap */
+#define PR_5_BLOCK_UNUSED               0x050004
+
+/* Block used, but not marked used in bitmap */
+#define PR_5_BLOCK_USED                 0x050005
+
+/* Block bitmap differences end */
+#define PR_5_BLOCK_BITMAP_END           0x050006
+
+/* Inode bitmap differences header */
+#define PR_5_INODE_BITMAP_HEADER        0x050007
+
+/* Inode not used, but marked in bitmap */
+#define PR_5_INODE_UNUSED               0x050008
+
+/* Inode used, but not marked used in bitmap */
+#define PR_5_INODE_USED                 0x050009
+
+/* Inode bitmap differences end */
+#define PR_5_INODE_BITMAP_END           0x05000A
+
+/* Free inodes count for group wrong */
+#define PR_5_FREE_INODE_COUNT_GROUP     0x05000B
+
+/* Directories count for group wrong */
+#define PR_5_FREE_DIR_COUNT_GROUP       0x05000C
+
+/* Free inodes count wrong */
+#define PR_5_FREE_INODE_COUNT   0x05000D
+
+/* Free blocks count for group wrong */
+#define PR_5_FREE_BLOCK_COUNT_GROUP     0x05000E
+
+/* Free blocks count wrong */
+#define PR_5_FREE_BLOCK_COUNT           0x05000F
+
+/* Programming error: bitmap endpoints don't match */
+#define PR_5_BMAP_ENDPOINTS             0x050010
+
+/* Internal error: fudging end of bitmap */
+#define PR_5_FUDGE_BITMAP_ERROR         0x050011
+
+/* Error copying in replacement inode bitmap */
+#define PR_5_COPY_IBITMAP_ERROR         0x050012
+
+/* Error copying in replacement block bitmap */
+#define PR_5_COPY_BBITMAP_ERROR         0x050013
+
+/* Block range not used, but marked in bitmap */
+#define PR_5_BLOCK_RANGE_UNUSED         0x050014
+
+/* Block range used, but not marked used in bitmap */
+#define PR_5_BLOCK_RANGE_USED           0x050015
+
+/* Inode range not used, but marked in bitmap */
+#define PR_5_INODE_RANGE_UNUSED         0x050016
+
+/* Inode rangeused, but not marked used in bitmap */
+#define PR_5_INODE_RANGE_USED           0x050017
+
+/*
+ * Function declarations
+ */
+static int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx);
+static int end_problem_latch(e2fsck_t ctx, int mask);
+static int set_latch_flags(int mask, int setflags, int clearflags);
+static void clear_problem_context(struct problem_context *ctx);
+
+/* message.c */
+static void print_e2fsck_message(e2fsck_t ctx, const char *msg,
+                          struct problem_context *pctx, int first);
+
+/*
+ * Dictionary Abstract Data Type
+ * Copyright (C) 1997 Kaz Kylheku <kaz@ashi.footprints.net>
+ *
+ * Free Software License:
+ *
+ * All rights are reserved by the author, with the following exceptions:
+ * Permission is granted to freely reproduce and distribute this software,
+ * possibly in exchange for a fee, provided that this copyright notice appears
+ * intact. Permission is also granted to adapt this software to produce
+ * derivative works, as long as the modified versions carry this copyright
+ * notice and additional notices stating that the work has been modified.
+ * This source code may be translated into executable form and incorporated
+ * into proprietary software; there is no requirement for such software to
+ * contain a copyright notice related to this source.
+ *
+ * $Id: dict.h,v 1.22.2.6 2000/11/13 01:36:44 kaz Exp $
+ * $Name: kazlib_1_20 $
+ */
+
+#ifndef DICT_H
+#define DICT_H
+
+/*
+ * Blurb for inclusion into C++ translation units
+ */
+
+typedef unsigned long dictcount_t;
+#define DICTCOUNT_T_MAX ULONG_MAX
+
+/*
+ * The dictionary is implemented as a red-black tree
+ */
+
+typedef enum { dnode_red, dnode_black } dnode_color_t;
+
+typedef struct dnode_t {
+    struct dnode_t *dict_left;
+    struct dnode_t *dict_right;
+    struct dnode_t *dict_parent;
+    dnode_color_t dict_color;
+    const void *dict_key;
+    void *dict_data;
+} dnode_t;
+
+typedef int (*dict_comp_t)(const void *, const void *);
+typedef dnode_t *(*dnode_alloc_t)(void *);
+typedef void (*dnode_free_t)(dnode_t *, void *);
+
+typedef struct dict_t {
+    dnode_t dict_nilnode;
+    dictcount_t dict_nodecount;
+    dictcount_t dict_maxcount;
+    dict_comp_t dict_compare;
+    dnode_alloc_t dict_allocnode;
+    dnode_free_t dict_freenode;
+    void *dict_context;
+    int dict_dupes;
+} dict_t;
+
+typedef void (*dnode_process_t)(dict_t *, dnode_t *, void *);
+
+typedef struct dict_load_t {
+    dict_t *dict_dictptr;
+    dnode_t dict_nilnode;
+} dict_load_t;
+
+static void dict_set_allocator(dict_t *, dnode_alloc_t, dnode_free_t, void *);
+static void dict_free_nodes(dict_t *);
+static dict_t *dict_init(dict_t *, dictcount_t, dict_comp_t);
+static dnode_t *dict_lookup(dict_t *, const void *);
+static void dict_insert(dict_t *, dnode_t *, const void *);
+static int dict_alloc_insert(dict_t *, const void *, void *);
+static dnode_t *dict_first(dict_t *);
+static dnode_t *dict_next(dict_t *, dnode_t *);
+static dictcount_t dict_count(dict_t *);
+static dnode_t *dnode_init(dnode_t *, void *);
+static void *dnode_get(dnode_t *);
+static const void *dnode_getkey(dnode_t *);
+
+#define dict_count(D) ((D)->dict_nodecount)
+#define dnode_get(N) ((N)->dict_data)
+#define dnode_getkey(N) ((N)->dict_key)
+
+#endif
+
+/*
+ * Compatibility header file for e2fsck which should be included
+ * instead of linux/jfs.h
+ *
+ * Copyright (C) 2000 Stephen C. Tweedie
+ */
+
+/*
+ * Pull in the definition of the e2fsck context structure
+ */
+
+
+struct buffer_head {
+        char            b_data[8192];
+        e2fsck_t        b_ctx;
+        io_channel      b_io;
+        int             b_size;
+        blk_t           b_blocknr;
+        int             b_dirty;
+        int             b_uptodate;
+        int             b_err;
+};
+
+struct inode {
+        e2fsck_t        i_ctx;
+        ext2_ino_t      i_ino;
+        struct ext2_inode i_ext2;
+};
+
+struct kdev_s {
+        e2fsck_t        k_ctx;
+        int             k_dev;
+};
+
+#define K_DEV_FS        1
+#define K_DEV_JOURNAL   2
+
+typedef struct kdev_s *kdev_t;
+
+#define lock_buffer(bh) do {} while(0)
+#define unlock_buffer(bh) do {} while(0)
+#define buffer_req(bh) 1
+#define do_readahead(journal, start) do {} while(0)
+
+static e2fsck_t e2fsck_global_ctx;  /* Try your very best not to use this! */
+
+typedef struct {
+        int     object_length;
+} kmem_cache_t;
+
+#define kmem_cache_alloc(cache,flags) malloc((cache)->object_length)
+#define kmem_cache_free(cache,obj) free(obj)
+#define kmem_cache_create(name,len,a,b,c,d) do_cache_create(len)
+#define kmem_cache_destroy(cache) do_cache_destroy(cache)
+#define kmalloc(len,flags) malloc(len)
+#define kfree(p) free(p)
+
+/*
+ * We use the standard libext2fs portability tricks for inline
+ * functions.
+ */
+
+static _INLINE_ kmem_cache_t * do_cache_create(int len)
+{
+        kmem_cache_t *new_cache;
+        new_cache = malloc(sizeof(*new_cache));
+        if (new_cache)
+                new_cache->object_length = len;
+        return new_cache;
+}
+
+static _INLINE_ void do_cache_destroy(kmem_cache_t *cache)
+{
+        free(cache);
+}
+
+/*
+ * Now pull in the real linux/jfs.h definitions.
+ */
+#include "ext2fs/kernel-jbd.h"
+
+/*
+ * Kernel compatibility functions are defined in journal.c
+ */
+static int journal_bmap(journal_t *journal, blk_t block, unsigned long *phys);
+static struct buffer_head *getblk(kdev_t ctx, blk_t blocknr, int blocksize);
+static void sync_blockdev(kdev_t kdev);
+static void ll_rw_block(int rw, int dummy, struct buffer_head *bh[]);
+static void mark_buffer_dirty(struct buffer_head *bh);
+static void mark_buffer_uptodate(struct buffer_head *bh, int val);
+static void brelse(struct buffer_head *bh);
+static int buffer_uptodate(struct buffer_head *bh);
+static void wait_on_buffer(struct buffer_head *bh);
+
+/*
+ * Define newer 2.5 interfaces
+ */
+#define __getblk(dev, blocknr, blocksize) getblk(dev, blocknr, blocksize)
+#define set_buffer_uptodate(bh) mark_buffer_uptodate(bh, 1)
+
+/*
+ * badblocks.c --- replace/append bad blocks to the bad block inode
+ *
+ * Copyright (C) 1993, 1994 Theodore Ts'o.  This file may be
+ * redistributed under the terms of the GNU Public License.
+ */
+
+static int check_bb_inode_blocks(ext2_filsys fs, blk_t *block_nr, int blockcnt,
+                                 void *priv_data);
+
+
+static void invalid_block(ext2_filsys fs EXT2FS_ATTR((unused)), blk_t blk)
+{
+        printf(_("Bad block %u out of range; ignored.\n"), blk);
+        return;
+}
+
+void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
+                          int replace_bad_blocks)
+{
+        ext2_filsys fs = ctx->fs;
+        errcode_t       retval;
+        badblocks_list  bb_list = 0;
+        FILE            *f;
+        char            buf[1024];
+
+        e2fsck_read_bitmaps(ctx);
+
+        /*
+         * Make sure the bad block inode is sane.  If there are any
+         * illegal blocks, clear them.
+         */
+        retval = ext2fs_block_iterate(fs, EXT2_BAD_INO, 0, 0,
+                                      check_bb_inode_blocks, 0);
+        if (retval) {
+                com_err("ext2fs_block_iterate", retval,
+                        _("while sanity checking the bad blocks inode"));
+                goto fatal;
+        }
+
+        /*
+         * If we're appending to the bad blocks inode, read in the
+         * current bad blocks.
+         */
+        if (!replace_bad_blocks) {
+                retval = ext2fs_read_bb_inode(fs, &bb_list);
+                if (retval) {
+                        com_err("ext2fs_read_bb_inode", retval,
+                                _("while reading the bad blocks inode"));
+                        goto fatal;
+                }
+        }
+
+        /*
+         * Now read in the bad blocks from the file; if
+         * bad_blocks_file is null, then try to run the badblocks
+         * command.
+         */
+        if (bad_blocks_file) {
+                f = fopen(bad_blocks_file, "r");
+                if (!f) {
+                        com_err("read_bad_blocks_file", errno,
+                                _("while trying to open %s"), bad_blocks_file);
+                        goto fatal;
+                }
+        } else {
+                sprintf(buf, "badblocks -b %d %s%s%s %d", fs->blocksize,
+                        (ctx->options & E2F_OPT_PREEN) ? "" : "-s ",
+                        (ctx->options & E2F_OPT_WRITECHECK) ? "-n " : "",
+                        fs->device_name, fs->super->s_blocks_count);
+                f = popen(buf, "r");
+                if (!f) {
+                        com_err("read_bad_blocks_file", errno,
+                                _("while trying popen '%s'"), buf);
+                        goto fatal;
+                }
+        }
+        retval = ext2fs_read_bb_FILE(fs, f, &bb_list, invalid_block);
+        if (bad_blocks_file)
+                fclose(f);
+        else
+                pclose(f);
+        if (retval) {
+                com_err("ext2fs_read_bb_FILE", retval,
+                        _("while reading in list of bad blocks from file"));
+                goto fatal;
+        }
+
+        /*
+         * Finally, update the bad blocks from the bad_block_map
+         */
+        retval = ext2fs_update_bb_inode(fs, bb_list);
+        if (retval) {
+                com_err("ext2fs_update_bb_inode", retval,
+                        _("while updating bad block inode"));
+                goto fatal;
+        }
+
+        ext2fs_badblocks_list_free(bb_list);
+        return;
+
+fatal:
+        ctx->flags |= E2F_FLAG_ABORT;
+        return;
+
+}
+
+static int check_bb_inode_blocks(ext2_filsys fs,
+                                 blk_t *block_nr,
+                                 int blockcnt EXT2FS_ATTR((unused)),
+                                 void *priv_data EXT2FS_ATTR((unused)))
+{
+        if (!*block_nr)
+                return 0;
+
+        /*
+         * If the block number is outrageous, clear it and ignore it.
+         */
+        if (*block_nr >= fs->super->s_blocks_count ||
+            *block_nr < fs->super->s_first_data_block) {
+                printf(_("Warning illegal block %u found in bad block inode.  Cleared.\n"), *block_nr);
+                *block_nr = 0;
+                return BLOCK_CHANGED;
+        }
+
+        return 0;
+}
+
+/*
+ * Dictionary Abstract Data Type
+ * Copyright (C) 1997 Kaz Kylheku <kaz@ashi.footprints.net>
+ *
+ * Free Software License:
+ *
+ * All rights are reserved by the author, with the following exceptions:
+ * Permission is granted to freely reproduce and distribute this software,
+ * possibly in exchange for a fee, provided that this copyright notice appears
+ * intact. Permission is also granted to adapt this software to produce
+ * derivative works, as long as the modified versions carry this copyright
+ * notice and additional notices stating that the work has been modified.
+ * This source code may be translated into executable form and incorporated
+ * into proprietary software; there is no requirement for such software to
+ * contain a copyright notice related to this source.
+ *
+ * $Id: dict.c,v 1.40.2.7 2000/11/13 01:36:44 kaz Exp $
+ * $Name: kazlib_1_20 $
+ */
+
+
+/*
+ * These macros provide short convenient names for structure members,
+ * which are embellished with dict_ prefixes so that they are
+ * properly confined to the documented namespace. It's legal for a
+ * program which uses dict to define, for instance, a macro called ``parent''.
+ * Such a macro would interfere with the dnode_t struct definition.
+ * In general, highly portable and reusable C modules which expose their
+ * structures need to confine structure member names to well-defined spaces.
+ * The resulting identifiers aren't necessarily convenient to use, nor
+ * readable, in the implementation, however!
+ */
+
+#define left dict_left
+#define right dict_right
+#define parent dict_parent
+#define color dict_color
+#define key dict_key
+#define data dict_data
+
+#define nilnode dict_nilnode
+#define nodecount dict_nodecount
+#define maxcount dict_maxcount
+#define compare dict_compare
+#define allocnode dict_allocnode
+#define freenode dict_freenode
+#define context dict_context
+#define dupes dict_dupes
+
+#define dictptr dict_dictptr
+
+#define dict_root(D) ((D)->nilnode.left)
+#define dict_nil(D) (&(D)->nilnode)
+#define DICT_DEPTH_MAX 64
+
+static dnode_t *dnode_alloc(void *context);
+static void dnode_free(dnode_t *node, void *context);
+
+/*
+ * Perform a ``left rotation'' adjustment on the tree.  The given node P and
+ * its right child C are rearranged so that the P instead becomes the left
+ * child of C.   The left subtree of C is inherited as the new right subtree
+ * for P.  The ordering of the keys within the tree is thus preserved.
+ */
+
+static void rotate_left(dnode_t *upper)
+{
+    dnode_t *lower, *lowleft, *upparent;
+
+    lower = upper->right;
+    upper->right = lowleft = lower->left;
+    lowleft->parent = upper;
+
+    lower->parent = upparent = upper->parent;
+
+    /* don't need to check for root node here because root->parent is
+       the sentinel nil node, and root->parent->left points back to root */
+
+    if (upper == upparent->left) {
+        upparent->left = lower;
+    } else {
+        assert (upper == upparent->right);
+        upparent->right = lower;
+    }
+
+    lower->left = upper;
+    upper->parent = lower;
+}
+
+/*
+ * This operation is the ``mirror'' image of rotate_left. It is
+ * the same procedure, but with left and right interchanged.
+ */
+
+static void rotate_right(dnode_t *upper)
+{
+    dnode_t *lower, *lowright, *upparent;
+
+    lower = upper->left;
+    upper->left = lowright = lower->right;
+    lowright->parent = upper;
+
+    lower->parent = upparent = upper->parent;
+
+    if (upper == upparent->right) {
+        upparent->right = lower;
+    } else {
+        assert (upper == upparent->left);
+        upparent->left = lower;
+    }
+
+    lower->right = upper;
+    upper->parent = lower;
+}
+
+/*
+ * Do a postorder traversal of the tree rooted at the specified
+ * node and free everything under it.  Used by dict_free().
+ */
+
+static void free_nodes(dict_t *dict, dnode_t *node, dnode_t *nil)
+{
+    if (node == nil)
+        return;
+    free_nodes(dict, node->left, nil);
+    free_nodes(dict, node->right, nil);
+    dict->freenode(node, dict->context);
+}
+
+/*
+ * Verify that the tree contains the given node. This is done by
+ * traversing all of the nodes and comparing their pointers to the
+ * given pointer. Returns 1 if the node is found, otherwise
+ * returns zero. It is intended for debugging purposes.
+ */
+
+static int verify_dict_has_node(dnode_t *nil, dnode_t *root, dnode_t *node)
+{
+    if (root != nil) {
+        return root == node
+                || verify_dict_has_node(nil, root->left, node)
+                || verify_dict_has_node(nil, root->right, node);
+    }
+    return 0;
+}
+
+
+/*
+ * Select a different set of node allocator routines.
+ */
+
+void dict_set_allocator(dict_t *dict, dnode_alloc_t al,
+        dnode_free_t fr, void *context)
+{
+    assert (dict_count(dict) == 0);
+    assert ((al == NULL && fr == NULL) || (al != NULL && fr != NULL));
+
+    dict->allocnode = al ? al : dnode_alloc;
+    dict->freenode = fr ? fr : dnode_free;
+    dict->context = context;
+}
+
+/*
+ * Free all the nodes in the dictionary by using the dictionary's
+ * installed free routine. The dictionary is emptied.
+ */
+
+void dict_free_nodes(dict_t *dict)
+{
+    dnode_t *nil = dict_nil(dict), *root = dict_root(dict);
+    free_nodes(dict, root, nil);
+    dict->nodecount = 0;
+    dict->nilnode.left = &dict->nilnode;
+    dict->nilnode.right = &dict->nilnode;
+}
+
+/*
+ * Initialize a user-supplied dictionary object.
+ */
+
+dict_t *dict_init(dict_t *dict, dictcount_t maxcount, dict_comp_t comp)
+{
+    dict->compare = comp;
+    dict->allocnode = dnode_alloc;
+    dict->freenode = dnode_free;
+    dict->context = NULL;
+    dict->nodecount = 0;
+    dict->maxcount = maxcount;
+    dict->nilnode.left = &dict->nilnode;
+    dict->nilnode.right = &dict->nilnode;
+    dict->nilnode.parent = &dict->nilnode;
+    dict->nilnode.color = dnode_black;
+    dict->dupes = 0;
+    return dict;
+}
+
+/*
+ * Locate a node in the dictionary having the given key.
+ * If the node is not found, a null a pointer is returned (rather than
+ * a pointer that dictionary's nil sentinel node), otherwise a pointer to the
+ * located node is returned.
+ */
+
+dnode_t *dict_lookup(dict_t *dict, const void *key)
+{
+    dnode_t *root = dict_root(dict);
+    dnode_t *nil = dict_nil(dict);
+    dnode_t *saved;
+    int result;
+
+    /* simple binary search adapted for trees that contain duplicate keys */
+
+    while (root != nil) {
+        result = dict->compare(key, root->key);
+        if (result < 0)
+            root = root->left;
+        else if (result > 0)
+            root = root->right;
+        else {
+            if (!dict->dupes) { /* no duplicates, return match          */
+                return root;
+            } else {            /* could be dupes, find leftmost one    */
+                do {
+                    saved = root;
+                    root = root->left;
+                    while (root != nil && dict->compare(key, root->key))
+                        root = root->right;
+                } while (root != nil);
+                return saved;
+            }
+        }
+    }
+
+    return NULL;
+}
+
+/*
+ * Insert a node into the dictionary. The node should have been
+ * initialized with a data field. All other fields are ignored.
+ * The behavior is undefined if the user attempts to insert into
+ * a dictionary that is already full (for which the dict_isfull()
+ * function returns true).
+ */
+
+void dict_insert(dict_t *dict, dnode_t *node, const void *key)
+{
+    dnode_t *where = dict_root(dict), *nil = dict_nil(dict);
+    dnode_t *parent = nil, *uncle, *grandpa;
+    int result = -1;
+
+    node->key = key;
+
+    /* basic binary tree insert */
+
+    while (where != nil) {
+        parent = where;
+        result = dict->compare(key, where->key);
+        /* trap attempts at duplicate key insertion unless it's explicitly allowed */
+        assert (dict->dupes || result != 0);
+        if (result < 0)
+            where = where->left;
+        else
+            where = where->right;
+    }
+
+    assert (where == nil);
+
+    if (result < 0)
+        parent->left = node;
+    else
+        parent->right = node;
+
+    node->parent = parent;
+    node->left = nil;
+    node->right = nil;
+
+    dict->nodecount++;
+
+    /* red black adjustments */
+
+    node->color = dnode_red;
+
+    while (parent->color == dnode_red) {
+        grandpa = parent->parent;
+        if (parent == grandpa->left) {
+            uncle = grandpa->right;
+            if (uncle->color == dnode_red) {    /* red parent, red uncle */
+                parent->color = dnode_black;
+                uncle->color = dnode_black;
+                grandpa->color = dnode_red;
+                node = grandpa;
+                parent = grandpa->parent;
+            } else {                            /* red parent, black uncle */
+                if (node == parent->right) {
+                    rotate_left(parent);
+                    parent = node;
+                    assert (grandpa == parent->parent);
+                    /* rotation between parent and child preserves grandpa */
+                }
+                parent->color = dnode_black;
+                grandpa->color = dnode_red;
+                rotate_right(grandpa);
+                break;
+            }
+        } else {        /* symmetric cases: parent == parent->parent->right */
+            uncle = grandpa->left;
+            if (uncle->color == dnode_red) {
+                parent->color = dnode_black;
+                uncle->color = dnode_black;
+                grandpa->color = dnode_red;
+                node = grandpa;
+                parent = grandpa->parent;
+            } else {
+                if (node == parent->left) {
+                    rotate_right(parent);
+                    parent = node;
+                    assert (grandpa == parent->parent);
+                }
+                parent->color = dnode_black;
+                grandpa->color = dnode_red;
+                rotate_left(grandpa);
+                break;
+            }
+        }
+    }
+
+    dict_root(dict)->color = dnode_black;
+
+}
+
+/*
+ * Allocate a node using the dictionary's allocator routine, give it
+ * the data item.
+ */
+
+int dict_alloc_insert(dict_t *dict, const void *key, void *data)
+{
+    dnode_t *node = dict->allocnode(dict->context);
+
+    if (node) {
+        dnode_init(node, data);
+        dict_insert(dict, node, key);
+        return 1;
+    }
+    return 0;
+}
+
+/*
+ * Return the node with the lowest (leftmost) key. If the dictionary is empty
+ * (that is, dict_isempty(dict) returns 1) a null pointer is returned.
+ */
+
+dnode_t *dict_first(dict_t *dict)
+{
+    dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *left;
+
+    if (root != nil)
+        while ((left = root->left) != nil)
+            root = left;
+
+    return (root == nil) ? NULL : root;
+}
+
+/*
+ * Return the given node's successor node---the node which has the
+ * next key in the the left to right ordering. If the node has
+ * no successor, a null pointer is returned rather than a pointer to
+ * the nil node.
+ */
+
+dnode_t *dict_next(dict_t *dict, dnode_t *curr)
+{
+    dnode_t *nil = dict_nil(dict), *parent, *left;
+
+    if (curr->right != nil) {
+        curr = curr->right;
+        while ((left = curr->left) != nil)
+            curr = left;
+        return curr;
+    }
+
+    parent = curr->parent;
+
+    while (parent != nil && curr == parent->right) {
+        curr = parent;
+        parent = curr->parent;
+    }
+
+    return (parent == nil) ? NULL : parent;
+}
+
+#undef dict_count
+#undef dnode_get
+#undef dnode_getkey
+
+dictcount_t dict_count(dict_t *dict)
+{
+    return dict->nodecount;
+}
+
+static dnode_t *dnode_alloc(void *context EXT2FS_ATTR((unused)))
+{
+    return malloc(sizeof *dnode_alloc(NULL));
+}
+
+static void dnode_free(dnode_t *node, void *context EXT2FS_ATTR((unused)))
+{
+    free(node);
+}
+
+dnode_t *dnode_init(dnode_t *dnode, void *data)
+{
+    dnode->data = data;
+    dnode->parent = NULL;
+    dnode->left = NULL;
+    dnode->right = NULL;
+    return dnode;
+}
+
+void *dnode_get(dnode_t *dnode)
+{
+    return dnode->data;
+}
+
+const void *dnode_getkey(dnode_t *dnode)
+{
+    return dnode->key;
+}
+
+#undef left
+#undef right
+#undef parent
+#undef color
+#undef key
+#undef data
+
+#undef nilnode
+#undef nodecount
+#undef maxcount
+#undef compare
+#undef allocnode
+#undef freenode
+#undef context
+#undef dupes
+
+#undef dictptr
+
+
+/*
+ * dirinfo.c --- maintains the directory information table for e2fsck.
+ *
+ * Copyright (C) 1993 Theodore Ts'o.  This file may be redistributed
+ * under the terms of the GNU Public License.
+ */
+
+/*
+ * This subroutine is called during pass1 to create a directory info
+ * entry.  During pass1, the passed-in parent is 0; it will get filled
+ * in during pass2.
+ */
+void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent)
+{
+        struct dir_info *dir;
+        int             i, j;
+        ext2_ino_t      num_dirs;
+        errcode_t       retval;
+        unsigned long   old_size;
+
+#if 0
+        printf("add_dir_info for inode %lu...\n", ino);
+#endif
+        if (!ctx->dir_info) {
+                ctx->dir_info_count = 0;
+                retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs);
+                if (retval)
+                        num_dirs = 1024;        /* Guess */
+                ctx->dir_info_size = num_dirs + 10;
+                ctx->dir_info  = (struct dir_info *)
+                        e2fsck_allocate_memory(ctx, ctx->dir_info_size
+                                               * sizeof (struct dir_info),
+                                               "directory map");
+        }
+
+        if (ctx->dir_info_count >= ctx->dir_info_size) {
+                old_size = ctx->dir_info_size * sizeof(struct dir_info);
+                ctx->dir_info_size += 10;
+                retval = ext2fs_resize_mem(old_size, ctx->dir_info_size *
+                                           sizeof(struct dir_info),
+                                           &ctx->dir_info);
+                if (retval) {
+                        ctx->dir_info_size -= 10;
+                        return;
+                }
+        }
+
+        /*
+         * Normally, add_dir_info is called with each inode in
+         * sequential order; but once in a while (like when pass 3
+         * needs to recreate the root directory or lost+found
+         * directory) it is called out of order.  In those cases, we
+         * need to move the dir_info entries down to make room, since
+         * the dir_info array needs to be sorted by inode number for
+         * get_dir_info()'s sake.
+         */
+        if (ctx->dir_info_count &&
+            ctx->dir_info[ctx->dir_info_count-1].ino >= ino) {
+                for (i = ctx->dir_info_count-1; i > 0; i--)
+                        if (ctx->dir_info[i-1].ino < ino)
+                                break;
+                dir = &ctx->dir_info[i];
+                if (dir->ino != ino)
+                        for (j = ctx->dir_info_count++; j > i; j--)
+                                ctx->dir_info[j] = ctx->dir_info[j-1];
+        } else
+                dir = &ctx->dir_info[ctx->dir_info_count++];
+
+        dir->ino = ino;
+        dir->dotdot = parent;
+        dir->parent = parent;
+}
+
+/*
+ * get_dir_info() --- given an inode number, try to find the directory
+ * information entry for it.
+ */
+struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino)
+{
+        int     low, high, mid;
+
+        low = 0;
+        high = ctx->dir_info_count-1;
+        if (!ctx->dir_info)
+                return 0;
+        if (ino == ctx->dir_info[low].ino)
+                return &ctx->dir_info[low];
+        if  (ino == ctx->dir_info[high].ino)
+                return &ctx->dir_info[high];
+
+        while (low < high) {
+                mid = (low+high)/2;
+                if (mid == low || mid == high)
+                        break;
+                if (ino == ctx->dir_info[mid].ino)
+                        return &ctx->dir_info[mid];
+                if (ino < ctx->dir_info[mid].ino)
+                        high = mid;
+                else
+                        low = mid;
+        }
+        return 0;
+}
+
+/*
+ * Free the dir_info structure when it isn't needed any more.
+ */
+void e2fsck_free_dir_info(e2fsck_t ctx)
+{
+        if (ctx->dir_info) {
+                ext2fs_free_mem(&ctx->dir_info);
+                ctx->dir_info = 0;
+        }
+        ctx->dir_info_size = 0;
+        ctx->dir_info_count = 0;
+}
+
+/*
+ * Return the count of number of directories in the dir_info structure
+ */
+int e2fsck_get_num_dirinfo(e2fsck_t ctx)
+{
+        return ctx->dir_info_count;
+}
+
+/*
+ * A simple interator function
+ */
+struct dir_info *e2fsck_dir_info_iter(e2fsck_t ctx, int *control)
+{
+        if (*control >= ctx->dir_info_count)
+                return 0;
+
+        return(ctx->dir_info + (*control)++);
+}
+/*
+ * dirinfo.c --- maintains the directory information table for e2fsck.
+ *
+ * Copyright (C) 1993 Theodore Ts'o.  This file may be redistributed
+ * under the terms of the GNU Public License.
+ */
+
+#ifdef ENABLE_HTREE
+
+/*
+ * This subroutine is called during pass1 to create a directory info
+ * entry.  During pass1, the passed-in parent is 0; it will get filled
+ * in during pass2.
+ */
+void e2fsck_add_dx_dir(e2fsck_t ctx, ext2_ino_t ino, int num_blocks)
+{
+        struct dx_dir_info *dir;
+        int             i, j;
+        errcode_t       retval;
+        unsigned long   old_size;
+
+#if 0
+        printf("add_dx_dir_info for inode %lu...\n", ino);
+#endif
+        if (!ctx->dx_dir_info) {
+                ctx->dx_dir_info_count = 0;
+                ctx->dx_dir_info_size = 100; /* Guess */
+                ctx->dx_dir_info  = (struct dx_dir_info *)
+                        e2fsck_allocate_memory(ctx, ctx->dx_dir_info_size
+                                               * sizeof (struct dx_dir_info),
+                                               "directory map");
+        }
+
+        if (ctx->dx_dir_info_count >= ctx->dx_dir_info_size) {
+                old_size = ctx->dx_dir_info_size * sizeof(struct dx_dir_info);
+                ctx->dx_dir_info_size += 10;
+                retval = ext2fs_resize_mem(old_size, ctx->dx_dir_info_size *
+                                           sizeof(struct dx_dir_info),
+                                           &ctx->dx_dir_info);
+                if (retval) {
+                        ctx->dx_dir_info_size -= 10;
+                        return;
+                }
+        }
+
+        /*
+         * Normally, add_dx_dir_info is called with each inode in
+         * sequential order; but once in a while (like when pass 3
+         * needs to recreate the root directory or lost+found
+         * directory) it is called out of order.  In those cases, we
+         * need to move the dx_dir_info entries down to make room, since
+         * the dx_dir_info array needs to be sorted by inode number for
+         * get_dx_dir_info()'s sake.
+         */
+        if (ctx->dx_dir_info_count &&
+            ctx->dx_dir_info[ctx->dx_dir_info_count-1].ino >= ino) {
+                for (i = ctx->dx_dir_info_count-1; i > 0; i--)
+                        if (ctx->dx_dir_info[i-1].ino < ino)
+                                break;
+                dir = &ctx->dx_dir_info[i];
+                if (dir->ino != ino)
+                        for (j = ctx->dx_dir_info_count++; j > i; j--)
+                                ctx->dx_dir_info[j] = ctx->dx_dir_info[j-1];
+        } else
+                dir = &ctx->dx_dir_info[ctx->dx_dir_info_count++];
+
+        dir->ino = ino;
+        dir->numblocks = num_blocks;
+        dir->hashversion = 0;
+        dir->dx_block = e2fsck_allocate_memory(ctx, num_blocks
+                                       * sizeof (struct dx_dirblock_info),
+                                       "dx_block info array");
+
+}
+
+/*
+ * get_dx_dir_info() --- given an inode number, try to find the directory
+ * information entry for it.
+ */
+struct dx_dir_info *e2fsck_get_dx_dir_info(e2fsck_t ctx, ext2_ino_t ino)
+{
+        int     low, high, mid;
+
+        low = 0;
+        high = ctx->dx_dir_info_count-1;
+        if (!ctx->dx_dir_info)
+                return 0;
+        if (ino == ctx->dx_dir_info[low].ino)
+                return &ctx->dx_dir_info[low];
+        if  (ino == ctx->dx_dir_info[high].ino)
+                return &ctx->dx_dir_info[high];
+
+        while (low < high) {
+                mid = (low+high)/2;
+                if (mid == low || mid == high)
+                        break;
+                if (ino == ctx->dx_dir_info[mid].ino)
+                        return &ctx->dx_dir_info[mid];
+                if (ino < ctx->dx_dir_info[mid].ino)
+                        high = mid;
+                else
+                        low = mid;
+        }
+        return 0;
+}
+
+/*
+ * Free the dx_dir_info structure when it isn't needed any more.
+ */
+void e2fsck_free_dx_dir_info(e2fsck_t ctx)
+{
+        int     i;
+        struct dx_dir_info *dir;
+
+        if (ctx->dx_dir_info) {
+                dir = ctx->dx_dir_info;
+                for (i=0; i < ctx->dx_dir_info_count; i++) {
+                        if (dir->dx_block) {
+                                ext2fs_free_mem(&dir->dx_block);
+                                dir->dx_block = 0;
+                        }
+                }
+                ext2fs_free_mem(&ctx->dx_dir_info);
+                ctx->dx_dir_info = 0;
+        }
+        ctx->dx_dir_info_size = 0;
+        ctx->dx_dir_info_count = 0;
+}
+
+/*
+ * A simple interator function
+ */
+struct dx_dir_info *e2fsck_dx_dir_info_iter(e2fsck_t ctx, int *control)
+{
+        if (*control >= ctx->dx_dir_info_count)
+                return 0;
+
+        return(ctx->dx_dir_info + (*control)++);
+}
+
+#endif /* ENABLE_HTREE */
+/*
+ * e2fsck.c - a consistency checker for the new extended file system.
+ *
+ * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ */
+
+/*
+ * This function allocates an e2fsck context
+ */
+errcode_t e2fsck_allocate_context(e2fsck_t *ret)
+{
+        e2fsck_t        context;
+        errcode_t       retval;
+
+        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;
+
+        *ret = context;
+        return 0;
+}
+
+/*
+ * This function resets an e2fsck context; it is called when e2fsck
+ * needs to be restarted.
+ */
+errcode_t e2fsck_reset_context(e2fsck_t ctx)
+{
+        ctx->flags = 0;
+        ctx->lost_and_found = 0;
+        ctx->bad_lost_and_found = 0;
+        if (ctx->inode_used_map) {
+                ext2fs_free_inode_bitmap(ctx->inode_used_map);
+                ctx->inode_used_map = 0;
+        }
+        if (ctx->inode_dir_map) {
+                ext2fs_free_inode_bitmap(ctx->inode_dir_map);
+                ctx->inode_dir_map = 0;
+        }
+        if (ctx->inode_reg_map) {
+                ext2fs_free_inode_bitmap(ctx->inode_reg_map);
+                ctx->inode_reg_map = 0;
+        }
+        if (ctx->block_found_map) {
+                ext2fs_free_block_bitmap(ctx->block_found_map);
+                ctx->block_found_map = 0;
+        }
+        if (ctx->inode_link_info) {
+                ext2fs_free_icount(ctx->inode_link_info);
+                ctx->inode_link_info = 0;
+        }
+        if (ctx->journal_io) {
+                if (ctx->fs && ctx->fs->io != ctx->journal_io)
+                        io_channel_close(ctx->journal_io);
+                ctx->journal_io = 0;
+        }
+        if (ctx->fs && ctx->fs->dblist) {
+                ext2fs_free_dblist(ctx->fs->dblist);
+                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;
+        }
+        if (ctx->refcount_extra) {
+                ea_refcount_free(ctx->refcount_extra);
+                ctx->refcount_extra = 0;
+        }
+        if (ctx->block_dup_map) {
+                ext2fs_free_block_bitmap(ctx->block_dup_map);
+                ctx->block_dup_map = 0;
+        }
+        if (ctx->block_ea_map) {
+                ext2fs_free_block_bitmap(ctx->block_ea_map);
+                ctx->block_ea_map = 0;
+        }
+        if (ctx->inode_bb_map) {
+                ext2fs_free_inode_bitmap(ctx->inode_bb_map);
+                ctx->inode_bb_map = 0;
+        }
+        if (ctx->inode_bad_map) {
+                ext2fs_free_inode_bitmap(ctx->inode_bad_map);
+                ctx->inode_bad_map = 0;
+        }
+        if (ctx->inode_imagic_map) {
+                ext2fs_free_inode_bitmap(ctx->inode_imagic_map);
+                ctx->inode_imagic_map = 0;
+        }
+        if (ctx->dirs_to_hash) {
+                ext2fs_u32_list_free(ctx->dirs_to_hash);
+                ctx->dirs_to_hash = 0;
+        }
+
+        /*
+         * Clear the array of invalid meta-data flags
+         */
+        if (ctx->invalid_inode_bitmap_flag) {
+                ext2fs_free_mem(&ctx->invalid_inode_bitmap_flag);
+                ctx->invalid_inode_bitmap_flag = 0;
+        }
+        if (ctx->invalid_block_bitmap_flag) {
+                ext2fs_free_mem(&ctx->invalid_block_bitmap_flag);
+                ctx->invalid_block_bitmap_flag = 0;
+        }
+        if (ctx->invalid_inode_table_flag) {
+                ext2fs_free_mem(&ctx->invalid_inode_table_flag);
+                ctx->invalid_inode_table_flag = 0;
+        }
+
+        /* Clear statistic counters */
+        ctx->fs_directory_count = 0;
+        ctx->fs_regular_count = 0;
+        ctx->fs_blockdev_count = 0;
+        ctx->fs_chardev_count = 0;
+        ctx->fs_links_count = 0;
+        ctx->fs_symlinks_count = 0;
+        ctx->fs_fast_symlinks_count = 0;
+        ctx->fs_fifo_count = 0;
+        ctx->fs_total_count = 0;
+        ctx->fs_badblocks_count = 0;
+        ctx->fs_sockets_count = 0;
+        ctx->fs_ind_count = 0;
+        ctx->fs_dind_count = 0;
+        ctx->fs_tind_count = 0;
+        ctx->fs_fragmented = 0;
+        ctx->large_files = 0;
+
+        /* Reset the superblock to the user's requested value */
+        ctx->superblock = ctx->use_superblock;
+
+        return 0;
+}
+
+void e2fsck_free_context(e2fsck_t ctx)
+{
+        if (!ctx)
+                return;
+
+        e2fsck_reset_context(ctx);
+        if (ctx->blkid)
+                blkid_put_cache(ctx->blkid);
+
+        ext2fs_free_mem(&ctx);
+}
+
+/*
+ * This function runs through the e2fsck passes and calls them all,
+ * returning restart, abort, or cancel as necessary...
+ */
+typedef void (*pass_t)(e2fsck_t ctx);
+
+static 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)
+
+int e2fsck_run(e2fsck_t ctx)
+{
+        int     i;
+        pass_t  e2fsck_pass;
+
+        if (setjmp(ctx->abort_loc)) {
+                ctx->flags &= ~E2F_FLAG_SETJMP_OK;
+                return (ctx->flags & E2F_FLAG_RUN_RETURN);
+        }
+        ctx->flags |= E2F_FLAG_SETJMP_OK;
+
+        for (i=0; (e2fsck_pass = e2fsck_passes[i]); i++) {
+                if (ctx->flags & E2F_FLAG_RUN_RETURN)
+                        break;
+                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;
+}
+/*
+ * ea_refcount.c
+ *
+ * Copyright (C) 2001 Theodore Ts'o.  This file may be
+ * redistributed under the terms of the GNU Public License.
+ */
+
+/*
+ * The strategy we use for keeping track of EA refcounts is as
+ * follows.  We keep a sorted array of first EA blocks and its
+ * reference counts.  Once the refcount has dropped to zero, it is
+ * removed from the array to save memory space.  Once the EA block is
+ * checked, its bit is set in the block_ea_map bitmap.
+ */
+struct ea_refcount_el {
+        blk_t   ea_blk;
+        int     ea_count;
+};
+
+struct ea_refcount {
+        blk_t           count;
+        blk_t           size;
+        blk_t           cursor;
+        struct ea_refcount_el   *list;
+};
+
+void ea_refcount_free(ext2_refcount_t refcount)
+{
+        if (!refcount)
+                return;
+
+        if (refcount->list)
+                ext2fs_free_mem(&refcount->list);
+        ext2fs_free_mem(&refcount);
+}
+
+errcode_t ea_refcount_create(int size, ext2_refcount_t *ret)
+{
+        ext2_refcount_t refcount;
+        errcode_t       retval;
+        size_t          bytes;
+
+        retval = ext2fs_get_mem(sizeof(struct ea_refcount), &refcount);
+        if (retval)
+                return retval;
+        memset(refcount, 0, sizeof(struct ea_refcount));
+
+        if (!size)
+                size = 500;
+        refcount->size = size;
+        bytes = (size_t) (size * sizeof(struct ea_refcount_el));
+#ifdef DEBUG
+        printf("Refcount allocated %d entries, %d bytes.\n",
+               refcount->size, bytes);
+#endif
+        retval = ext2fs_get_mem(bytes, &refcount->list);
+        if (retval)
+                goto errout;
+        memset(refcount->list, 0, bytes);
+
+        refcount->count = 0;
+        refcount->cursor = 0;
+
+        *ret = refcount;
+        return 0;
+
+errout:
+        ea_refcount_free(refcount);
+        return(retval);
+}
+
+/*
+ * collapse_refcount() --- go through the refcount array, and get rid
+ * of any count == zero entries
+ */
+static void refcount_collapse(ext2_refcount_t refcount)
+{
+        unsigned int    i, j;
+        struct ea_refcount_el   *list;
+
+        list = refcount->list;
+        for (i = 0, j = 0; i < refcount->count; i++) {
+                if (list[i].ea_count) {
+                        if (i != j)
+                                list[j] = list[i];
+                        j++;
+                }
+        }
+#if defined(DEBUG) || defined(TEST_PROGRAM)
+        printf("Refcount_collapse: size was %d, now %d\n",
+               refcount->count, j);
+#endif
+        refcount->count = j;
+}
+
+
+/*
+ * insert_refcount_el() --- Insert a new entry into the sorted list at a
+ *      specified position.
+ */
+static struct ea_refcount_el *insert_refcount_el(ext2_refcount_t refcount,
+                                                 blk_t blk, int pos)
+{
+        struct ea_refcount_el   *el;
+        errcode_t               retval;
+        blk_t                   new_size = 0;
+        int                     num;
+
+        if (refcount->count >= refcount->size) {
+                new_size = refcount->size + 100;
+#ifdef DEBUG
+                printf("Reallocating refcount %d entries...\n", new_size);
+#endif
+                retval = ext2fs_resize_mem((size_t) refcount->size *
+                                           sizeof(struct ea_refcount_el),
+                                           (size_t) new_size *
+                                           sizeof(struct ea_refcount_el),
+                                           &refcount->list);
+                if (retval)
+                        return 0;
+                refcount->size = new_size;
+        }
+        num = (int) refcount->count - pos;
+        if (num < 0)
+                return 0;       /* should never happen */
+        if (num) {
+                memmove(&refcount->list[pos+1], &refcount->list[pos],
+                        sizeof(struct ea_refcount_el) * num);
+        }
+        refcount->count++;
+        el = &refcount->list[pos];
+        el->ea_count = 0;
+        el->ea_blk = blk;
+        return el;
+}
+
+
+/*
+ * get_refcount_el() --- given an block number, try to find refcount
+ *      information in the sorted list.  If the create flag is set,
+ *      and we can't find an entry, create one in the sorted list.
+ */
+static struct ea_refcount_el *get_refcount_el(ext2_refcount_t refcount,
+                                              blk_t blk, int create)
+{
+        float   range;
+        int     low, high, mid;
+        blk_t   lowval, highval;
+
+        if (!refcount || !refcount->list)
+                return 0;
+retry:
+        low = 0;
+        high = (int) refcount->count-1;
+        if (create && ((refcount->count == 0) ||
+                       (blk > refcount->list[high].ea_blk))) {
+                if (refcount->count >= refcount->size)
+                        refcount_collapse(refcount);
+
+                return insert_refcount_el(refcount, blk,
+                                          (unsigned) refcount->count);
+        }
+        if (refcount->count == 0)
+                return 0;
+
+        if (refcount->cursor >= refcount->count)
+                refcount->cursor = 0;
+        if (blk == refcount->list[refcount->cursor].ea_blk)
+                return &refcount->list[refcount->cursor++];
+#ifdef DEBUG
+        printf("Non-cursor get_refcount_el: %u\n", blk);
+#endif
+        while (low <= high) {
+#if 0
+                mid = (low+high)/2;
 #else
-extern char *optarg;
-extern int optind;
+                if (low == high)
+                        mid = low;
+                else {
+                        /* Interpolate for efficiency */
+                        lowval = refcount->list[low].ea_blk;
+                        highval = refcount->list[high].ea_blk;
+
+                        if (blk < lowval)
+                                range = 0;
+                        else if (blk > highval)
+                                range = 1;
+                        else
+                                range = ((float) (blk - lowval)) /
+                                        (highval - lowval);
+                        mid = low + ((int) (range * (high-low)));
+                }
 #endif
-#include <unistd.h>
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
+                if (blk == refcount->list[mid].ea_blk) {
+                        refcount->cursor = mid+1;
+                        return &refcount->list[mid];
+                }
+                if (blk < refcount->list[mid].ea_blk)
+                        high = mid-1;
+                else
+                        low = mid+1;
+        }
+        /*
+         * If we need to create a new entry, it should be right at
+         * low (where high will be left at low-1).
+         */
+        if (create) {
+                if (refcount->count >= refcount->size) {
+                        refcount_collapse(refcount);
+                        if (refcount->count < refcount->size)
+                                goto retry;
+                }
+                return insert_refcount_el(refcount, blk, low);
+        }
+        return 0;
+}
+
+errcode_t ea_refcount_increment(ext2_refcount_t refcount, blk_t blk, int *ret)
+{
+        struct ea_refcount_el   *el;
+
+        el = get_refcount_el(refcount, blk, 1);
+        if (!el)
+                return EXT2_ET_NO_MEMORY;
+        el->ea_count++;
+
+        if (ret)
+                *ret = el->ea_count;
+        return 0;
+}
+
+errcode_t ea_refcount_decrement(ext2_refcount_t refcount, blk_t blk, int *ret)
+{
+        struct ea_refcount_el   *el;
+
+        el = get_refcount_el(refcount, blk, 0);
+        if (!el || el->ea_count == 0)
+                return EXT2_ET_INVALID_ARGUMENT;
+
+        el->ea_count--;
+
+        if (ret)
+                *ret = el->ea_count;
+        return 0;
+}
+
+errcode_t ea_refcount_store(ext2_refcount_t refcount, blk_t blk, int count)
+{
+        struct ea_refcount_el   *el;
+
+        /*
+         * Get the refcount element
+         */
+        el = get_refcount_el(refcount, blk, count ? 1 : 0);
+        if (!el)
+                return count ? EXT2_ET_NO_MEMORY : 0;
+        el->ea_count = count;
+        return 0;
+}
+
+void ea_refcount_intr_begin(ext2_refcount_t refcount)
+{
+        refcount->cursor = 0;
+}
+
+
+blk_t ea_refcount_intr_next(ext2_refcount_t refcount,
+                                int *ret)
+{
+        struct ea_refcount_el   *list;
+
+        while (1) {
+                if (refcount->cursor >= refcount->count)
+                        return 0;
+                list = refcount->list;
+                if (list[refcount->cursor].ea_count) {
+                        if (ret)
+                                *ret = list[refcount->cursor].ea_count;
+                        return list[refcount->cursor++].ea_blk;
+                }
+                refcount->cursor++;
+        }
+}
+
+
+/*
+ * ehandler.c --- handle bad block errors which come up during the
+ *      course of an e2fsck session.
+ *
+ * Copyright (C) 1994 Theodore Ts'o.  This file may be redistributed
+ * under the terms of the GNU Public License.
+ */
+
+
+static const char *operation;
+
+static errcode_t e2fsck_handle_read_error(io_channel channel,
+                                          unsigned long block,
+                                          int count,
+                                          void *data,
+                                          size_t size EXT2FS_ATTR((unused)),
+                                          int actual EXT2FS_ATTR((unused)),
+                                          errcode_t error)
+{
+        int     i;
+        char    *p;
+        ext2_filsys fs = (ext2_filsys) channel->app_data;
+        e2fsck_t ctx;
+
+        ctx = (e2fsck_t) fs->priv_data;
+
+        /*
+         * If more than one block was read, try reading each block
+         * separately.  We could use the actual bytes read to figure
+         * out where to start, but we don't bother.
+         */
+        if (count > 1) {
+                p = (char *) data;
+                for (i=0; i < count; i++, p += channel->block_size, block++) {
+                        error = io_channel_read_blk(channel, block,
+                                                    1, p);
+                        if (error)
+                                return error;
+                }
+                return 0;
+        }
+        if (operation)
+                printf(_("Error reading block %lu (%s) while %s.  "), block,
+                       error_message(error), operation);
+        else
+                printf(_("Error reading block %lu (%s).  "), block,
+                       error_message(error));
+        preenhalt(ctx);
+        if (ask(ctx, _("Ignore error"), 1)) {
+                if (ask(ctx, _("Force rewrite"), 1))
+                        io_channel_write_blk(channel, block, 1, data);
+                return 0;
+        }
+
+        return error;
+}
+
+static errcode_t e2fsck_handle_write_error(io_channel channel,
+                                            unsigned long block,
+                                            int count,
+                                            const void *data,
+                                            size_t size EXT2FS_ATTR((unused)),
+                                            int actual EXT2FS_ATTR((unused)),
+                                            errcode_t error)
+{
+        int             i;
+        const char      *p;
+        ext2_filsys fs = (ext2_filsys) channel->app_data;
+        e2fsck_t ctx;
+
+        ctx = (e2fsck_t) fs->priv_data;
+
+        /*
+         * If more than one block was written, try writing each block
+         * separately.  We could use the actual bytes read to figure
+         * out where to start, but we don't bother.
+         */
+        if (count > 1) {
+                p = (const char *) data;
+                for (i=0; i < count; i++, p += channel->block_size, block++) {
+                        error = io_channel_write_blk(channel, block,
+                                                     1, p);
+                        if (error)
+                                return error;
+                }
+                return 0;
+        }
+
+        if (operation)
+                printf(_("Error writing block %lu (%s) while %s.  "), block,
+                       error_message(error), operation);
+        else
+                printf(_("Error writing block %lu (%s).  "), block,
+                       error_message(error));
+        preenhalt(ctx);
+        if (ask(ctx, _("Ignore error"), 1))
+                return 0;
+
+        return error;
+}
+
+const char *ehandler_operation(const char *op)
+{
+        const char *ret = operation;
+
+        operation = op;
+        return ret;
+}
+
+void ehandler_init(io_channel channel)
+{
+        channel->read_error = e2fsck_handle_read_error;
+        channel->write_error = e2fsck_handle_write_error;
+}
+/*
+ * journal.c --- code for handling the "ext3" journal
+ *
+ * Copyright (C) 2000 Andreas Dilger
+ * Copyright (C) 2000 Theodore Ts'o
+ *
+ * Parts of the code are based on fs/jfs/journal.c by Stephen C. Tweedie
+ * Copyright (C) 1999 Red Hat Software
+ *
+ * This file may be redistributed under the terms of the
+ * GNU General Public License version 2 or at your discretion
+ * any later version.
+ */
+
+#define MNT_FL (MS_MGC_VAL | MS_RDONLY)
+
+
+#ifdef __CONFIG_JBD_DEBUG__E2FS         /* Enabled by configure --enable-jfs-debug */
+static int bh_count = 0;
 #endif
-#ifdef HAVE_MNTENT_H
-#include <mntent.h>
+
+/*
+ * Define USE_INODE_IO to use the inode_io.c / fileio.c codepaths.
+ * This creates a larger static binary, and a smaller binary using
+ * shared libraries.  It's also probably slightly less CPU-efficient,
+ * which is why it's not on by default.  But, it's a good way of
+ * testing the functions in inode_io.c and fileio.c.
+ */
+#undef USE_INODE_IO
+
+/* Kernel compatibility functions for handling the journal.  These allow us
+ * to use the recovery.c file virtually unchanged from the kernel, so we
+ * don't have to do much to keep kernel and user recovery in sync.
+ */
+int journal_bmap(journal_t *journal, blk_t block, unsigned long *phys)
+{
+#ifdef USE_INODE_IO
+        *phys = block;
+        return 0;
+#else
+        struct inode    *inode = journal->j_inode;
+        errcode_t       retval;
+        blk_t           pblk;
+
+        if (!inode) {
+                *phys = block;
+                return 0;
+        }
+
+        retval= ext2fs_bmap(inode->i_ctx->fs, inode->i_ino,
+                            &inode->i_ext2, NULL, 0, block, &pblk);
+        *phys = pblk;
+        return (retval);
 #endif
-#ifdef HAVE_SYS_IOCTL_H
-#include <sys/ioctl.h>
+}
+
+struct buffer_head *getblk(kdev_t kdev, blk_t blocknr, int blocksize)
+{
+        struct buffer_head *bh;
+
+        bh = e2fsck_allocate_memory(kdev->k_ctx, sizeof(*bh), "block buffer");
+        if (!bh)
+                return NULL;
+
+        jfs_debug(4, "getblk for block %lu (%d bytes)(total %d)\n",
+                  (unsigned long) blocknr, blocksize, ++bh_count);
+
+        bh->b_ctx = kdev->k_ctx;
+        if (kdev->k_dev == K_DEV_FS)
+                bh->b_io = kdev->k_ctx->fs->io;
+        else
+                bh->b_io = kdev->k_ctx->journal_io;
+        bh->b_size = blocksize;
+        bh->b_blocknr = blocknr;
+
+        return bh;
+}
+
+void sync_blockdev(kdev_t kdev)
+{
+        io_channel      io;
+
+        if (kdev->k_dev == K_DEV_FS)
+                io = kdev->k_ctx->fs->io;
+        else
+                io = kdev->k_ctx->journal_io;
+
+        io_channel_flush(io);
+}
+
+void ll_rw_block(int rw, int nr, struct buffer_head *bhp[])
+{
+        int retval;
+        struct buffer_head *bh;
+
+        for (; nr > 0; --nr) {
+                bh = *bhp++;
+                if (rw == READ && !bh->b_uptodate) {
+                        jfs_debug(3, "reading block %lu/%p\n",
+                                  (unsigned long) bh->b_blocknr, (void *) bh);
+                        retval = io_channel_read_blk(bh->b_io,
+                                                     bh->b_blocknr,
+                                                     1, bh->b_data);
+                        if (retval) {
+                                com_err(bh->b_ctx->device_name, retval,
+                                        "while reading block %lu\n",
+                                        (unsigned long) bh->b_blocknr);
+                                bh->b_err = retval;
+                                continue;
+                        }
+                        bh->b_uptodate = 1;
+                } else if (rw == WRITE && bh->b_dirty) {
+                        jfs_debug(3, "writing block %lu/%p\n",
+                                  (unsigned long) bh->b_blocknr, (void *) bh);
+                        retval = io_channel_write_blk(bh->b_io,
+                                                      bh->b_blocknr,
+                                                      1, bh->b_data);
+                        if (retval) {
+                                com_err(bh->b_ctx->device_name, retval,
+                                        "while writing block %lu\n",
+                                        (unsigned long) bh->b_blocknr);
+                                bh->b_err = retval;
+                                continue;
+                        }
+                        bh->b_dirty = 0;
+                        bh->b_uptodate = 1;
+                } else {
+                        jfs_debug(3, "no-op %s for block %lu\n",
+                                  rw == READ ? "read" : "write",
+                                  (unsigned long) bh->b_blocknr);
+                }
+        }
+}
+
+void mark_buffer_dirty(struct buffer_head *bh)
+{
+        bh->b_dirty = 1;
+}
+
+static void mark_buffer_clean(struct buffer_head * bh)
+{
+        bh->b_dirty = 0;
+}
+
+void brelse(struct buffer_head *bh)
+{
+        if (bh->b_dirty)
+                ll_rw_block(WRITE, 1, &bh);
+        jfs_debug(3, "freeing block %lu/%p (total %d)\n",
+                  (unsigned long) bh->b_blocknr, (void *) bh, --bh_count);
+        ext2fs_free_mem(&bh);
+}
+
+int buffer_uptodate(struct buffer_head *bh)
+{
+        return bh->b_uptodate;
+}
+
+void mark_buffer_uptodate(struct buffer_head *bh, int val)
+{
+        bh->b_uptodate = val;
+}
+
+void wait_on_buffer(struct buffer_head *bh)
+{
+        if (!bh->b_uptodate)
+                ll_rw_block(READ, 1, &bh);
+}
+
+
+static void e2fsck_clear_recover(e2fsck_t ctx, int error)
+{
+        ctx->fs->super->s_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
+
+        /* if we had an error doing journal recovery, we need a full fsck */
+        if (error)
+                ctx->fs->super->s_state &= ~EXT2_VALID_FS;
+        ext2fs_mark_super_dirty(ctx->fs);
+}
+
+static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal)
+{
+        struct ext2_super_block *sb = ctx->fs->super;
+        struct ext2_super_block jsuper;
+        struct problem_context  pctx;
+        struct buffer_head      *bh;
+        struct inode            *j_inode = NULL;
+        struct kdev_s           *dev_fs = NULL, *dev_journal;
+        const char              *journal_name = 0;
+        journal_t               *journal = NULL;
+        errcode_t               retval = 0;
+        io_manager              io_ptr = 0;
+        unsigned long           start = 0;
+        blk_t                   blk;
+        int                     ext_journal = 0;
+        int                     tried_backup_jnl = 0;
+        int                     i;
+
+        clear_problem_context(&pctx);
+
+        journal = e2fsck_allocate_memory(ctx, sizeof(journal_t), "journal");
+        if (!journal) {
+                return EXT2_ET_NO_MEMORY;
+        }
+
+        dev_fs = e2fsck_allocate_memory(ctx, 2*sizeof(struct kdev_s), "kdev");
+        if (!dev_fs) {
+                retval = EXT2_ET_NO_MEMORY;
+                goto errout;
+        }
+        dev_journal = dev_fs+1;
+
+        dev_fs->k_ctx = dev_journal->k_ctx = ctx;
+        dev_fs->k_dev = K_DEV_FS;
+        dev_journal->k_dev = K_DEV_JOURNAL;
+
+        journal->j_dev = dev_journal;
+        journal->j_fs_dev = dev_fs;
+        journal->j_inode = NULL;
+        journal->j_blocksize = ctx->fs->blocksize;
+
+        if (uuid_is_null(sb->s_journal_uuid)) {
+                if (!sb->s_journal_inum)
+                        return EXT2_ET_BAD_INODE_NUM;
+                j_inode = e2fsck_allocate_memory(ctx, sizeof(*j_inode),
+                                                 "journal inode");
+                if (!j_inode) {
+                        retval = EXT2_ET_NO_MEMORY;
+                        goto errout;
+                }
+
+                j_inode->i_ctx = ctx;
+                j_inode->i_ino = sb->s_journal_inum;
+
+                if ((retval = ext2fs_read_inode(ctx->fs,
+                                                sb->s_journal_inum,
+                                                &j_inode->i_ext2))) {
+                try_backup_journal:
+                        if (sb->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS ||
+                            tried_backup_jnl)
+                                goto errout;
+                        memset(&j_inode->i_ext2, 0, sizeof(struct ext2_inode));
+                        memcpy(&j_inode->i_ext2.i_block[0], sb->s_jnl_blocks,
+                               EXT2_N_BLOCKS*4);
+                        j_inode->i_ext2.i_size = sb->s_jnl_blocks[16];
+                        j_inode->i_ext2.i_links_count = 1;
+                        j_inode->i_ext2.i_mode = LINUX_S_IFREG | 0600;
+                        tried_backup_jnl++;
+                }
+                if (!j_inode->i_ext2.i_links_count ||
+                    !LINUX_S_ISREG(j_inode->i_ext2.i_mode)) {
+                        retval = EXT2_ET_NO_JOURNAL;
+                        goto try_backup_journal;
+                }
+                if (j_inode->i_ext2.i_size / journal->j_blocksize <
+                    JFS_MIN_JOURNAL_BLOCKS) {
+                        retval = EXT2_ET_JOURNAL_TOO_SMALL;
+                        goto try_backup_journal;
+                }
+                for (i=0; i < EXT2_N_BLOCKS; i++) {
+                        blk = j_inode->i_ext2.i_block[i];
+                        if (!blk) {
+                                if (i < EXT2_NDIR_BLOCKS) {
+                                        retval = EXT2_ET_JOURNAL_TOO_SMALL;
+                                        goto try_backup_journal;
+                                }
+                                continue;
+                        }
+                        if (blk < sb->s_first_data_block ||
+                            blk >= sb->s_blocks_count) {
+                                retval = EXT2_ET_BAD_BLOCK_NUM;
+                                goto try_backup_journal;
+                        }
+                }
+                journal->j_maxlen = j_inode->i_ext2.i_size / journal->j_blocksize;
+
+#ifdef USE_INODE_IO
+                retval = ext2fs_inode_io_intern2(ctx->fs, sb->s_journal_inum,
+                                                 &j_inode->i_ext2,
+                                                 &journal_name);
+                if (retval)
+                        goto errout;
+
+                io_ptr = inode_io_manager;
+#else
+                journal->j_inode = j_inode;
+                ctx->journal_io = ctx->fs->io;
+                if ((retval = journal_bmap(journal, 0, &start)) != 0)
+                        goto errout;
 #endif
-#ifdef HAVE_MALLOC_H
-#include <malloc.h>
+        } else {
+                ext_journal = 1;
+                if (!ctx->journal_name) {
+                        char uuid[37];
+
+                        uuid_unparse(sb->s_journal_uuid, uuid);
+                        ctx->journal_name = blkid_get_devname(ctx->blkid,
+                                                              "UUID", uuid);
+                        if (!ctx->journal_name)
+                                ctx->journal_name = blkid_devno_to_devname(sb->s_journal_dev);
+                }
+                journal_name = ctx->journal_name;
+
+                if (!journal_name) {
+                        fix_problem(ctx, PR_0_CANT_FIND_JOURNAL, &pctx);
+                        return EXT2_ET_LOAD_EXT_JOURNAL;
+                }
+
+                jfs_debug(1, "Using journal file %s\n", journal_name);
+                io_ptr = unix_io_manager;
+        }
+
+#if 0
+        test_io_backing_manager = io_ptr;
+        io_ptr = test_io_manager;
 #endif
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
+#ifndef USE_INODE_IO
+        if (ext_journal)
 #endif
-#ifdef HAVE_DIRENT_H
-#include <dirent.h>
+                retval = io_ptr->open(journal_name, IO_FLAG_RW,
+                                      &ctx->journal_io);
+        if (retval)
+                goto errout;
+
+        io_channel_set_blksize(ctx->journal_io, ctx->fs->blocksize);
+
+        if (ext_journal) {
+                if (ctx->fs->blocksize == 1024)
+                        start = 1;
+                bh = getblk(dev_journal, start, ctx->fs->blocksize);
+                if (!bh) {
+                        retval = EXT2_ET_NO_MEMORY;
+                        goto errout;
+                }
+                ll_rw_block(READ, 1, &bh);
+                if ((retval = bh->b_err) != 0)
+                        goto errout;
+                memcpy(&jsuper, start ? bh->b_data :  bh->b_data + 1024,
+                       sizeof(jsuper));
+                brelse(bh);
+#ifdef EXT2FS_ENABLE_SWAPFS
+                if (jsuper.s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
+                        ext2fs_swap_super(&jsuper);
 #endif
+                if (jsuper.s_magic != EXT2_SUPER_MAGIC ||
+                    !(jsuper.s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
+                        fix_problem(ctx, PR_0_EXT_JOURNAL_BAD_SUPER, &pctx);
+                        retval = EXT2_ET_LOAD_EXT_JOURNAL;
+                        goto errout;
+                }
+                /* Make sure the journal UUID is correct */
+                if (memcmp(jsuper.s_uuid, ctx->fs->super->s_journal_uuid,
+                           sizeof(jsuper.s_uuid))) {
+                        fix_problem(ctx, PR_0_JOURNAL_BAD_UUID, &pctx);
+                        retval = EXT2_ET_LOAD_EXT_JOURNAL;
+                        goto errout;
+                }
+
+                journal->j_maxlen = jsuper.s_blocks_count;
+                start++;
+        }
+
+        if (!(bh = getblk(dev_journal, start, journal->j_blocksize))) {
+                retval = EXT2_ET_NO_MEMORY;
+                goto errout;
+        }
+
+        journal->j_sb_buffer = bh;
+        journal->j_superblock = (journal_superblock_t *)bh->b_data;
+
+#ifdef USE_INODE_IO
+        if (j_inode)
+                ext2fs_free_mem(&j_inode);
+#endif
+
+        *ret_journal = journal;
+        return 0;
+
+errout:
+        if (dev_fs)
+                ext2fs_free_mem(&dev_fs);
+        if (j_inode)
+                ext2fs_free_mem(&j_inode);
+        if (journal)
+                ext2fs_free_mem(&journal);
+        return retval;
+
+}
+
+static errcode_t e2fsck_journal_fix_bad_inode(e2fsck_t ctx,
+                                              struct problem_context *pctx)
+{
+        struct ext2_super_block *sb = ctx->fs->super;
+        int recover = ctx->fs->super->s_feature_incompat &
+                EXT3_FEATURE_INCOMPAT_RECOVER;
+        int has_journal = ctx->fs->super->s_feature_compat &
+                EXT3_FEATURE_COMPAT_HAS_JOURNAL;
+
+        if (has_journal || sb->s_journal_inum) {
+                /* The journal inode is bogus, remove and force full fsck */
+                pctx->ino = sb->s_journal_inum;
+                if (fix_problem(ctx, PR_0_JOURNAL_BAD_INODE, pctx)) {
+                        if (has_journal && sb->s_journal_inum)
+                                printf("*** ext3 journal has been deleted - "
+                                       "filesystem is now ext2 only ***\n\n");
+                        sb->s_feature_compat &= ~EXT3_FEATURE_COMPAT_HAS_JOURNAL;
+                        sb->s_journal_inum = 0;
+                        ctx->flags |= E2F_FLAG_JOURNAL_INODE; /* FIXME: todo */
+                        e2fsck_clear_recover(ctx, 1);
+                        return 0;
+                }
+                return EXT2_ET_BAD_INODE_NUM;
+        } else if (recover) {
+                if (fix_problem(ctx, PR_0_JOURNAL_RECOVER_SET, pctx)) {
+                        e2fsck_clear_recover(ctx, 1);
+                        return 0;
+                }
+                return EXT2_ET_UNSUPP_FEATURE;
+        }
+        return 0;
+}
+
+#define V1_SB_SIZE      0x0024
+static void clear_v2_journal_fields(journal_t *journal)
+{
+        e2fsck_t ctx = journal->j_dev->k_ctx;
+        struct problem_context pctx;
+
+        clear_problem_context(&pctx);
+
+        if (!fix_problem(ctx, PR_0_CLEAR_V2_JOURNAL, &pctx))
+                return;
+
+        memset(((char *) journal->j_superblock) + V1_SB_SIZE, 0,
+               ctx->fs->blocksize-V1_SB_SIZE);
+        mark_buffer_dirty(journal->j_sb_buffer);
+}
+
+
+static errcode_t e2fsck_journal_load(journal_t *journal)
+{
+        e2fsck_t ctx = journal->j_dev->k_ctx;
+        journal_superblock_t *jsb;
+        struct buffer_head *jbh = journal->j_sb_buffer;
+        struct problem_context pctx;
+
+        clear_problem_context(&pctx);
+
+        ll_rw_block(READ, 1, &jbh);
+        if (jbh->b_err) {
+                com_err(ctx->device_name, jbh->b_err,
+                        _("reading journal superblock\n"));
+                return jbh->b_err;
+        }
+
+        jsb = journal->j_superblock;
+        /* If we don't even have JFS_MAGIC, we probably have a wrong inode */
+        if (jsb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER))
+                return e2fsck_journal_fix_bad_inode(ctx, &pctx);
+
+        switch (ntohl(jsb->s_header.h_blocktype)) {
+        case JFS_SUPERBLOCK_V1:
+                journal->j_format_version = 1;
+                if (jsb->s_feature_compat ||
+                    jsb->s_feature_incompat ||
+                    jsb->s_feature_ro_compat ||
+                    jsb->s_nr_users)
+                        clear_v2_journal_fields(journal);
+                break;
+
+        case JFS_SUPERBLOCK_V2:
+                journal->j_format_version = 2;
+                if (ntohl(jsb->s_nr_users) > 1 &&
+                    uuid_is_null(ctx->fs->super->s_journal_uuid))
+                        clear_v2_journal_fields(journal);
+                if (ntohl(jsb->s_nr_users) > 1) {
+                        fix_problem(ctx, PR_0_JOURNAL_UNSUPP_MULTIFS, &pctx);
+                        return EXT2_ET_JOURNAL_UNSUPP_VERSION;
+                }
+                break;
+
+        /*
+         * These should never appear in a journal super block, so if
+         * they do, the journal is badly corrupted.
+         */
+        case JFS_DESCRIPTOR_BLOCK:
+        case JFS_COMMIT_BLOCK:
+        case JFS_REVOKE_BLOCK:
+                return EXT2_ET_CORRUPT_SUPERBLOCK;
+
+        /* If we don't understand the superblock major type, but there
+         * is a magic number, then it is likely to be a new format we
+         * just don't understand, so leave it alone. */
+        default:
+                return EXT2_ET_JOURNAL_UNSUPP_VERSION;
+        }
+
+        if (JFS_HAS_INCOMPAT_FEATURE(journal, ~JFS_KNOWN_INCOMPAT_FEATURES))
+                return EXT2_ET_UNSUPP_FEATURE;
+
+        if (JFS_HAS_RO_COMPAT_FEATURE(journal, ~JFS_KNOWN_ROCOMPAT_FEATURES))
+                return EXT2_ET_RO_UNSUPP_FEATURE;
+
+        /* We have now checked whether we know enough about the journal
+         * format to be able to proceed safely, so any other checks that
+         * fail we should attempt to recover from. */
+        if (jsb->s_blocksize != htonl(journal->j_blocksize)) {
+                com_err(ctx->program_name, EXT2_ET_CORRUPT_SUPERBLOCK,
+                        _("%s: no valid journal superblock found\n"),
+                        ctx->device_name);
+                return EXT2_ET_CORRUPT_SUPERBLOCK;
+        }
+
+        if (ntohl(jsb->s_maxlen) < journal->j_maxlen)
+                journal->j_maxlen = ntohl(jsb->s_maxlen);
+        else if (ntohl(jsb->s_maxlen) > journal->j_maxlen) {
+                com_err(ctx->program_name, EXT2_ET_CORRUPT_SUPERBLOCK,
+                        _("%s: journal too short\n"),
+                        ctx->device_name);
+                return EXT2_ET_CORRUPT_SUPERBLOCK;
+        }
+
+        journal->j_tail_sequence = ntohl(jsb->s_sequence);
+        journal->j_transaction_sequence = journal->j_tail_sequence;
+        journal->j_tail = ntohl(jsb->s_start);
+        journal->j_first = ntohl(jsb->s_first);
+        journal->j_last = ntohl(jsb->s_maxlen);
+
+        return 0;
+}
+
+static void e2fsck_journal_reset_super(e2fsck_t ctx, journal_superblock_t *jsb,
+                                       journal_t *journal)
+{
+        char *p;
+        union {
+                uuid_t uuid;
+                __u32 val[4];
+        } u;
+        __u32 new_seq = 0;
+        int i;
+
+        /* Leave a valid existing V1 superblock signature alone.
+         * Anything unrecognisable we overwrite with a new V2
+         * signature. */
+
+        if (jsb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER) ||
+            jsb->s_header.h_blocktype != htonl(JFS_SUPERBLOCK_V1)) {
+                jsb->s_header.h_magic = htonl(JFS_MAGIC_NUMBER);
+                jsb->s_header.h_blocktype = htonl(JFS_SUPERBLOCK_V2);
+        }
+
+        /* Zero out everything else beyond the superblock header */
+
+        p = ((char *) jsb) + sizeof(journal_header_t);
+        memset (p, 0, ctx->fs->blocksize-sizeof(journal_header_t));
+
+        jsb->s_blocksize = htonl(ctx->fs->blocksize);
+        jsb->s_maxlen = htonl(journal->j_maxlen);
+        jsb->s_first = htonl(1);
+
+        /* Initialize the journal sequence number so that there is "no"
+         * chance we will find old "valid" transactions in the journal.
+         * This avoids the need to zero the whole journal (slow to do,
+         * and risky when we are just recovering the filesystem).
+         */
+        uuid_generate(u.uuid);
+        for (i = 0; i < 4; i ++)
+                new_seq ^= u.val[i];
+        jsb->s_sequence = htonl(new_seq);
+
+        mark_buffer_dirty(journal->j_sb_buffer);
+        ll_rw_block(WRITE, 1, &journal->j_sb_buffer);
+}
+
+static errcode_t e2fsck_journal_fix_corrupt_super(e2fsck_t ctx,
+                                                  journal_t *journal,
+                                                  struct problem_context *pctx)
+{
+        struct ext2_super_block *sb = ctx->fs->super;
+        int recover = ctx->fs->super->s_feature_incompat &
+                EXT3_FEATURE_INCOMPAT_RECOVER;
+
+        if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) {
+                if (fix_problem(ctx, PR_0_JOURNAL_BAD_SUPER, pctx)) {
+                        e2fsck_journal_reset_super(ctx, journal->j_superblock,
+                                                   journal);
+                        journal->j_transaction_sequence = 1;
+                        e2fsck_clear_recover(ctx, recover);
+                        return 0;
+                }
+                return EXT2_ET_CORRUPT_SUPERBLOCK;
+        } else if (e2fsck_journal_fix_bad_inode(ctx, pctx))
+                return EXT2_ET_CORRUPT_SUPERBLOCK;
+
+        return 0;
+}
+
+static void e2fsck_journal_release(e2fsck_t ctx, journal_t *journal,
+                                   int reset, int drop)
+{
+        journal_superblock_t *jsb;
+
+        if (drop)
+                mark_buffer_clean(journal->j_sb_buffer);
+        else if (!(ctx->options & E2F_OPT_READONLY)) {
+                jsb = journal->j_superblock;
+                jsb->s_sequence = htonl(journal->j_transaction_sequence);
+                if (reset)
+                        jsb->s_start = 0; /* this marks the journal as empty */
+                mark_buffer_dirty(journal->j_sb_buffer);
+        }
+        brelse(journal->j_sb_buffer);
+
+        if (ctx->journal_io) {
+                if (ctx->fs && ctx->fs->io != ctx->journal_io)
+                        io_channel_close(ctx->journal_io);
+                ctx->journal_io = 0;
+        }
+
+#ifndef USE_INODE_IO
+        if (journal->j_inode)
+                ext2fs_free_mem(&journal->j_inode);
+#endif
+        if (journal->j_fs_dev)
+                ext2fs_free_mem(&journal->j_fs_dev);
+        ext2fs_free_mem(&journal);
+}
+
+/*
+ * This function makes sure that the superblock fields regarding the
+ * journal are consistent.
+ */
+int e2fsck_check_ext3_journal(e2fsck_t ctx)
+{
+        struct ext2_super_block *sb = ctx->fs->super;
+        journal_t *journal;
+        int recover = ctx->fs->super->s_feature_incompat &
+                EXT3_FEATURE_INCOMPAT_RECOVER;
+        struct problem_context pctx;
+        problem_t problem;
+        int reset = 0, force_fsck = 0;
+        int retval;
+
+        /* If we don't have any journal features, don't do anything more */
+        if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
+            !recover && sb->s_journal_inum == 0 && sb->s_journal_dev == 0 &&
+            uuid_is_null(sb->s_journal_uuid))
+                return 0;
+
+        clear_problem_context(&pctx);
+        pctx.num = sb->s_journal_inum;
+
+        retval = e2fsck_get_journal(ctx, &journal);
+        if (retval) {
+                if ((retval == EXT2_ET_BAD_INODE_NUM) ||
+                    (retval == EXT2_ET_BAD_BLOCK_NUM) ||
+                    (retval == EXT2_ET_JOURNAL_TOO_SMALL) ||
+                    (retval == EXT2_ET_NO_JOURNAL))
+                        return e2fsck_journal_fix_bad_inode(ctx, &pctx);
+                return retval;
+        }
+
+        retval = e2fsck_journal_load(journal);
+        if (retval) {
+                if ((retval == EXT2_ET_CORRUPT_SUPERBLOCK) ||
+                    ((retval == EXT2_ET_UNSUPP_FEATURE) &&
+                    (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_INCOMPAT,
+                                  &pctx))) ||
+                    ((retval == EXT2_ET_RO_UNSUPP_FEATURE) &&
+                    (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_ROCOMPAT,
+                                  &pctx))) ||
+                    ((retval == EXT2_ET_JOURNAL_UNSUPP_VERSION) &&
+                    (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_VERSION, &pctx))))
+                        retval = e2fsck_journal_fix_corrupt_super(ctx, journal,
+                                                                  &pctx);
+                e2fsck_journal_release(ctx, journal, 0, 1);
+                return retval;
+        }
+
+        /*
+         * We want to make the flags consistent here.  We will not leave with
+         * needs_recovery set but has_journal clear.  We can't get in a loop
+         * with -y, -n, or -p, only if a user isn't making up their mind.
+         */
+no_has_journal:
+        if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
+                recover = sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER;
+                pctx.str = "inode";
+                if (fix_problem(ctx, PR_0_JOURNAL_HAS_JOURNAL, &pctx)) {
+                        if (recover &&
+                            !fix_problem(ctx, PR_0_JOURNAL_RECOVER_SET, &pctx))
+                                goto no_has_journal;
+                        /*
+                         * Need a full fsck if we are releasing a
+                         * journal stored on a reserved inode.
+                         */
+                        force_fsck = recover ||
+                                (sb->s_journal_inum < EXT2_FIRST_INODE(sb));
+                        /* Clear all of the journal fields */
+                        sb->s_journal_inum = 0;
+                        sb->s_journal_dev = 0;
+                        memset(sb->s_journal_uuid, 0,
+                               sizeof(sb->s_journal_uuid));
+                        e2fsck_clear_recover(ctx, force_fsck);
+                } else if (!(ctx->options & E2F_OPT_READONLY)) {
+                        sb->s_feature_compat |= EXT3_FEATURE_COMPAT_HAS_JOURNAL;
+                        ext2fs_mark_super_dirty(ctx->fs);
+                }
+        }
+
+        if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL &&
+            !(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) &&
+            journal->j_superblock->s_start != 0) {
+                /* Print status information */
+                fix_problem(ctx, PR_0_JOURNAL_RECOVERY_CLEAR, &pctx);
+                if (ctx->superblock)
+                        problem = PR_0_JOURNAL_RUN_DEFAULT;
+                else
+                        problem = PR_0_JOURNAL_RUN;
+                if (fix_problem(ctx, problem, &pctx)) {
+                        ctx->options |= E2F_OPT_FORCE;
+                        sb->s_feature_incompat |=
+                                EXT3_FEATURE_INCOMPAT_RECOVER;
+                        ext2fs_mark_super_dirty(ctx->fs);
+                } else if (fix_problem(ctx,
+                                       PR_0_JOURNAL_RESET_JOURNAL, &pctx)) {
+                        reset = 1;
+                        sb->s_state &= ~EXT2_VALID_FS;
+                        ext2fs_mark_super_dirty(ctx->fs);
+                }
+                /*
+                 * If the user answers no to the above question, we
+                 * ignore the fact that journal apparently has data;
+                 * accidentally replaying over valid data would be far
+                 * worse than skipping a questionable recovery.
+                 *
+                 * XXX should we abort with a fatal error here?  What
+                 * will the ext3 kernel code do if a filesystem with
+                 * !NEEDS_RECOVERY but with a non-zero
+                 * journal->j_superblock->s_start is mounted?
+                 */
+        }
+
+        e2fsck_journal_release(ctx, journal, reset, 0);
+        return retval;
+}
+
+static errcode_t recover_ext3_journal(e2fsck_t ctx)
+{
+        journal_t *journal;
+        int retval;
+
+        journal_init_revoke_caches();
+        retval = e2fsck_get_journal(ctx, &journal);
+        if (retval)
+                return retval;
+
+        retval = e2fsck_journal_load(journal);
+        if (retval)
+                goto errout;
+
+        retval = journal_init_revoke(journal, 1024);
+        if (retval)
+                goto errout;
+
+        retval = -journal_recover(journal);
+        if (retval)
+                goto errout;
+
+        if (journal->j_superblock->s_errno) {
+                ctx->fs->super->s_state |= EXT2_ERROR_FS;
+                ext2fs_mark_super_dirty(ctx->fs);
+                journal->j_superblock->s_errno = 0;
+                mark_buffer_dirty(journal->j_sb_buffer);
+        }
+
+errout:
+        journal_destroy_revoke(journal);
+        journal_destroy_revoke_caches();
+        e2fsck_journal_release(ctx, journal, 1, 0);
+        return retval;
+}
+
+int e2fsck_run_ext3_journal(e2fsck_t ctx)
+{
+        io_manager io_ptr = ctx->fs->io->manager;
+        int blocksize = ctx->fs->blocksize;
+        errcode_t       retval, recover_retval;
+
+        printf(_("%s: recovering journal\n"), ctx->device_name);
+        if (ctx->options & E2F_OPT_READONLY) {
+                printf(_("%s: won't do journal recovery while read-only\n"),
+                       ctx->device_name);
+                return EXT2_ET_FILE_RO;
+        }
+
+        if (ctx->fs->flags & EXT2_FLAG_DIRTY)
+                ext2fs_flush(ctx->fs);  /* Force out any modifications */
+
+        recover_retval = recover_ext3_journal(ctx);
+
+        /*
+         * Reload the filesystem context to get up-to-date data from disk
+         * because journal recovery will change the filesystem under us.
+         */
+        ext2fs_close(ctx->fs);
+        retval = ext2fs_open(ctx->filesystem_name, EXT2_FLAG_RW,
+                             ctx->superblock, blocksize, io_ptr,
+                             &ctx->fs);
+
+        if (retval) {
+                com_err(ctx->program_name, retval,
+                        _("while trying to re-open %s"),
+                        ctx->device_name);
+                fatal_error(ctx, 0);
+        }
+        ctx->fs->priv_data = ctx;
+
+        /* Set the superblock flags */
+        e2fsck_clear_recover(ctx, recover_retval);
+        return recover_retval;
+}
+
+/*
+ * This function will move the journal inode from a visible file in
+ * the filesystem directory hierarchy to the reserved inode if necessary.
+ */
+static const char * const journal_names[] = {
+        ".journal", "journal", ".journal.dat", "journal.dat", 0 };
+
+void e2fsck_move_ext3_journal(e2fsck_t ctx)
+{
+        struct ext2_super_block *sb = ctx->fs->super;
+        struct problem_context  pctx;
+        struct ext2_inode       inode;
+        ext2_filsys             fs = ctx->fs;
+        ext2_ino_t              ino;
+        errcode_t               retval;
+        const char * const *    cpp;
+        int                     group, mount_flags;
+
+        clear_problem_context(&pctx);
+
+        /*
+         * If the filesystem is opened read-only, or there is no
+         * journal, then do nothing.
+         */
+        if ((ctx->options & E2F_OPT_READONLY) ||
+            (sb->s_journal_inum == 0) ||
+            !(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL))
+                return;
+
+        /*
+         * Read in the journal inode
+         */
+        if (ext2fs_read_inode(fs, sb->s_journal_inum, &inode) != 0)
+                return;
+
+        /*
+         * If it's necessary to backup the journal inode, do so.
+         */
+        if ((sb->s_jnl_backup_type == 0) ||
+            ((sb->s_jnl_backup_type == EXT3_JNL_BACKUP_BLOCKS) &&
+             memcmp(inode.i_block, sb->s_jnl_blocks, EXT2_N_BLOCKS*4))) {
+                if (fix_problem(ctx, PR_0_BACKUP_JNL, &pctx)) {
+                        memcpy(sb->s_jnl_blocks, inode.i_block,
+                               EXT2_N_BLOCKS*4);
+                        sb->s_jnl_blocks[16] = inode.i_size;
+                        sb->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS;
+                        ext2fs_mark_super_dirty(fs);
+                        fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
+                }
+        }
+
+        /*
+         * If the journal is already the hidden inode, then do nothing
+         */
+        if (sb->s_journal_inum == EXT2_JOURNAL_INO)
+                return;
+
+        /*
+         * The journal inode had better have only one link and not be readable.
+         */
+        if (inode.i_links_count != 1)
+                return;
+
+        /*
+         * If the filesystem is mounted, or we can't tell whether
+         * or not it's mounted, do nothing.
+         */
+        retval = ext2fs_check_if_mounted(ctx->filesystem_name, &mount_flags);
+        if (retval || (mount_flags & EXT2_MF_MOUNTED))
+                return;
+
+        /*
+         * If we can't find the name of the journal inode, then do
+         * nothing.
+         */
+        for (cpp = journal_names; *cpp; cpp++) {
+                retval = ext2fs_lookup(fs, EXT2_ROOT_INO, *cpp,
+                                       strlen(*cpp), 0, &ino);
+                if ((retval == 0) && (ino == sb->s_journal_inum))
+                        break;
+        }
+        if (*cpp == 0)
+                return;
+
+        /* We need the inode bitmap to be loaded */
+        retval = ext2fs_read_bitmaps(fs);
+        if (retval)
+                return;
+
+        pctx.str = *cpp;
+        if (!fix_problem(ctx, PR_0_MOVE_JOURNAL, &pctx))
+                return;
+
+        /*
+         * OK, we've done all the checks, let's actually move the
+         * journal inode.  Errors at this point mean we need to force
+         * an ext2 filesystem check.
+         */
+        if ((retval = ext2fs_unlink(fs, EXT2_ROOT_INO, *cpp, ino, 0)) != 0)
+                goto err_out;
+        if ((retval = ext2fs_write_inode(fs, EXT2_JOURNAL_INO, &inode)) != 0)
+                goto err_out;
+        sb->s_journal_inum = EXT2_JOURNAL_INO;
+        ext2fs_mark_super_dirty(fs);
+        fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
+        inode.i_links_count = 0;
+        inode.i_dtime = time(0);
+        if ((retval = ext2fs_write_inode(fs, ino, &inode)) != 0)
+                goto err_out;
+
+        group = ext2fs_group_of_ino(fs, ino);
+        ext2fs_unmark_inode_bitmap(fs->inode_map, ino);
+        ext2fs_mark_ib_dirty(fs);
+        fs->group_desc[group].bg_free_inodes_count++;
+        fs->super->s_free_inodes_count++;
+        return;
+
+err_out:
+        pctx.errcode = retval;
+        fix_problem(ctx, PR_0_ERR_MOVE_JOURNAL, &pctx);
+        fs->super->s_state &= ~EXT2_VALID_FS;
+        ext2fs_mark_super_dirty(fs);
+        return;
+}
+
+/*
+ * message.c --- print e2fsck messages (with compression)
+ *
+ * Copyright 1996, 1997 by Theodore Ts'o
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ *
+ * print_e2fsck_message() prints a message to the user, using
+ * compression techniques and expansions of abbreviations.
+ *
+ * The following % expansions are supported:
+ *
+ *      %b      <blk>                   block number
+ *      %B      <blkcount>              integer
+ *      %c      <blk2>                  block number
+ *      %Di     <dirent>->ino           inode number
+ *      %Dn     <dirent>->name          string
+ *      %Dr     <dirent>->rec_len
+ *      %Dl     <dirent>->name_len
+ *      %Dt     <dirent>->filetype
+ *      %d      <dir>                   inode number
+ *      %g      <group>                 integer
+ *      %i      <ino>                   inode number
+ *      %Is     <inode> -> i_size
+ *      %IS     <inode> -> i_extra_isize
+ *      %Ib     <inode> -> i_blocks
+ *      %Il     <inode> -> i_links_count
+ *      %Im     <inode> -> i_mode
+ *      %IM     <inode> -> i_mtime
+ *      %IF     <inode> -> i_faddr
+ *      %If     <inode> -> i_file_acl
+ *      %Id     <inode> -> i_dir_acl
+ *      %Iu     <inode> -> i_uid
+ *      %Ig     <inode> -> i_gid
+ *      %j      <ino2>                  inode number
+ *      %m      <com_err error message>
+ *      %N      <num>
+ *      %p      ext2fs_get_pathname of directory <ino>
+ *      %P      ext2fs_get_pathname of <dirent>->ino with <ino2> as
+ *                      the containing directory.  (If dirent is NULL
+ *                      then return the pathname of directory <ino2>)
+ *      %q      ext2fs_get_pathname of directory <dir>
+ *      %Q      ext2fs_get_pathname of directory <ino> with <dir> as
+ *                      the containing directory.
+ *      %s      <str>                   miscellaneous string
+ *      %S      backup superblock
+ *      %X      <num> hexadecimal format
+ *
+ * The following '@' expansions are supported:
+ *
+ *      @a      extended attribute
+ *      @A      error allocating
+ *      @b      block
+ *      @B      bitmap
+ *      @c      compress
+ *      @C      conflicts with some other fs block
+ *      @D      deleted
+ *      @d      directory
+ *      @e      entry
+ *      @E      Entry '%Dn' in %p (%i)
+ *      @f      filesystem
+ *      @F      for @i %i (%Q) is
+ *      @g      group
+ *      @h      HTREE directory inode
+ *      @i      inode
+ *      @I      illegal
+ *      @j      journal
+ *      @l      lost+found
+ *      @L      is a link
+ *      @o      orphaned
+ *      @p      problem in
+ *      @r      root inode
+ *      @s      should be
+ *      @S      superblock
+ *      @u      unattached
+ *      @v      device
+ *      @z      zero-length
+ */
+
+
+/*
+ * This structure defines the abbreviations used by the text strings
+ * below.  The first character in the string is the index letter.  An
+ * abbreviation of the form '@<i>' is expanded by looking up the index
+ * letter <i> in the table below.
+ */
+static const char *abbrevs[] = {
+        N_("aextended attribute"),
+        N_("Aerror allocating"),
+        N_("bblock"),
+        N_("Bbitmap"),
+        N_("ccompress"),
+        N_("Cconflicts with some other fs @b"),
+        N_("iinode"),
+        N_("Iillegal"),
+        N_("jjournal"),
+        N_("Ddeleted"),
+        N_("ddirectory"),
+        N_("eentry"),
+        N_("E@e '%Dn' in %p (%i)"),
+        N_("ffilesystem"),
+        N_("Ffor @i %i (%Q) is"),
+        N_("ggroup"),
+        N_("hHTREE @d @i"),
+        N_("llost+found"),
+        N_("Lis a link"),
+        N_("oorphaned"),
+        N_("pproblem in"),
+        N_("rroot @i"),
+        N_("sshould be"),
+        N_("Ssuper@b"),
+        N_("uunattached"),
+        N_("vdevice"),
+        N_("zzero-length"),
+        "@@",
+        0
+        };
+
+/*
+ * Give more user friendly names to the "special" inodes.
+ */
+#define num_special_inodes      11
+static const char *special_inode_name[] =
+{
+        N_("<The NULL inode>"),                 /* 0 */
+        N_("<The bad blocks inode>"),           /* 1 */
+        "/",                                    /* 2 */
+        N_("<The ACL index inode>"),            /* 3 */
+        N_("<The ACL data inode>"),             /* 4 */
+        N_("<The boot loader inode>"),          /* 5 */
+        N_("<The undelete directory inode>"),   /* 6 */
+        N_("<The group descriptor inode>"),     /* 7 */
+        N_("<The journal inode>"),              /* 8 */
+        N_("<Reserved inode 9>"),               /* 9 */
+        N_("<Reserved inode 10>"),              /* 10 */
+};
+
+/*
+ * This function does "safe" printing.  It will convert non-printable
+ * ASCII characters using '^' and M- notation.
+ */
+static void safe_print(const char *cp, int len)
+{
+        unsigned char   ch;
+
+        if (len < 0)
+                len = strlen(cp);
+
+        while (len--) {
+                ch = *cp++;
+                if (ch > 128) {
+                        fputs("M-", stdout);
+                        ch -= 128;
+                }
+                if ((ch < 32) || (ch == 0x7f)) {
+                        fputc('^', stdout);
+                        ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */
+                }
+                fputc(ch, stdout);
+        }
+}
+
+
+/*
+ * This function prints a pathname, using the ext2fs_get_pathname
+ * function
+ */
+static void print_pathname(ext2_filsys fs, ext2_ino_t dir, ext2_ino_t ino)
+{
+        errcode_t       retval;
+        char            *path;
+
+        if (!dir && (ino < num_special_inodes)) {
+                fputs(_(special_inode_name[ino]), stdout);
+                return;
+        }
+
+        retval = ext2fs_get_pathname(fs, dir, ino, &path);
+        if (retval)
+                fputs("???", stdout);
+        else {
+                safe_print(path, -1);
+                ext2fs_free_mem(&path);
+        }
+}
+
+/*
+ * This function handles the '@' expansion.  We allow recursive
+ * expansion; an @ expression can contain further '@' and '%'
+ * expressions.
+ */
+static _INLINE_ void expand_at_expression(e2fsck_t ctx, char ch,
+                                          struct problem_context *pctx,
+                                          int *first)
+{
+        const char **cpp, *str;
+
+        /* Search for the abbreviation */
+        for (cpp = abbrevs; *cpp; cpp++) {
+                if (ch == *cpp[0])
+                        break;
+        }
+        if (*cpp) {
+                str = _(*cpp) + 1;
+                if (*first && islower(*str)) {
+                        *first = 0;
+                        fputc(toupper(*str++), stdout);
+                }
+                print_e2fsck_message(ctx, str, pctx, *first);
+        } else
+                printf("@%c", ch);
+}
+
+/*
+ * This function expands '%IX' expressions
+ */
+static _INLINE_ void expand_inode_expression(char ch,
+                                             struct problem_context *ctx)
+{
+        struct ext2_inode       *inode;
+        struct ext2_inode_large *large_inode;
+        char *                  time_str;
+        time_t                  t;
+        int                     do_gmt = -1;
+
+        if (!ctx || !ctx->inode)
+                goto no_inode;
+
+        inode = ctx->inode;
+        large_inode = (struct ext2_inode_large *) inode;
+
+        switch (ch) {
+        case 's':
+                if (LINUX_S_ISDIR(inode->i_mode))
+                        printf("%u", inode->i_size);
+                else {
+#ifdef EXT2_NO_64_TYPE
+                        if (inode->i_size_high)
+                                printf("0x%x%08x", inode->i_size_high,
+                                       inode->i_size);
+                        else
+                                printf("%u", inode->i_size);
+#else
+                        printf("%llu", (inode->i_size |
+                                        ((__u64) inode->i_size_high << 32)));
+#endif
+                }
+                break;
+        case 'S':
+                printf("%u", large_inode->i_extra_isize);
+                break;
+        case 'b':
+                printf("%u", inode->i_blocks);
+                break;
+        case 'l':
+                printf("%d", inode->i_links_count);
+                break;
+        case 'm':
+                printf("0%o", inode->i_mode);
+                break;
+        case 'M':
+                /* The diet libc doesn't respect the TZ environemnt variable */
+                if (do_gmt == -1) {
+                        time_str = getenv("TZ");
+                        if (!time_str)
+                                time_str = "";
+                        do_gmt = !strcmp(time_str, "GMT");
+                }
+                t = inode->i_mtime;
+                time_str = asctime(do_gmt ? gmtime(&t) : localtime(&t));
+                printf("%.24s", time_str);
+                break;
+        case 'F':
+                printf("%u", inode->i_faddr);
+                break;
+        case 'f':
+                printf("%u", inode->i_file_acl);
+                break;
+        case 'd':
+                printf("%u", (LINUX_S_ISDIR(inode->i_mode) ?
+                              inode->i_dir_acl : 0));
+                break;
+        case 'u':
+                printf("%d", (inode->i_uid |
+                              (inode->osd2.linux2.l_i_uid_high << 16)));
+                break;
+        case 'g':
+                printf("%d", (inode->i_gid |
+                              (inode->osd2.linux2.l_i_gid_high << 16)));
+                break;
+        default:
+        no_inode:
+                printf("%%I%c", ch);
+                break;
+        }
+}
+
+/*
+ * This function expands '%dX' expressions
+ */
+static _INLINE_ void expand_dirent_expression(char ch,
+                                              struct problem_context *ctx)
+{
+        struct ext2_dir_entry   *dirent;
+        int     len;
+
+        if (!ctx || !ctx->dirent)
+                goto no_dirent;
+
+        dirent = ctx->dirent;
+
+        switch (ch) {
+        case 'i':
+                printf("%u", dirent->inode);
+                break;
+        case 'n':
+                len = dirent->name_len & 0xFF;
+                if (len > EXT2_NAME_LEN)
+                        len = EXT2_NAME_LEN;
+                if (len > dirent->rec_len)
+                        len = dirent->rec_len;
+                safe_print(dirent->name, len);
+                break;
+        case 'r':
+                printf("%u", dirent->rec_len);
+                break;
+        case 'l':
+                printf("%u", dirent->name_len & 0xFF);
+                break;
+        case 't':
+                printf("%u", dirent->name_len >> 8);
+                break;
+        default:
+        no_dirent:
+                printf("%%D%c", ch);
+                break;
+        }
+}
+
+static _INLINE_ void expand_percent_expression(ext2_filsys fs, char ch,
+                                               struct problem_context *ctx)
+{
+        if (!ctx)
+                goto no_context;
+
+        switch (ch) {
+        case '%':
+                fputc('%', stdout);
+                break;
+        case 'b':
+                printf("%u", ctx->blk);
+                break;
+        case 'B':
+#ifdef EXT2_NO_64_TYPE
+                printf("%d", ctx->blkcount);
+#else
+                printf("%lld", ctx->blkcount);
+#endif
+                break;
+        case 'c':
+                printf("%u", ctx->blk2);
+                break;
+        case 'd':
+                printf("%u", ctx->dir);
+                break;
+        case 'g':
+                printf("%d", ctx->group);
+                break;
+        case 'i':
+                printf("%u", ctx->ino);
+                break;
+        case 'j':
+                printf("%u", ctx->ino2);
+                break;
+        case 'm':
+                printf("%s", error_message(ctx->errcode));
+                break;
+        case 'N':
+#ifdef EXT2_NO_64_TYPE
+                printf("%u", ctx->num);
+#else
+                printf("%llu", ctx->num);
+#endif
+                break;
+        case 'p':
+                print_pathname(fs, ctx->ino, 0);
+                break;
+        case 'P':
+                print_pathname(fs, ctx->ino2,
+                               ctx->dirent ? ctx->dirent->inode : 0);
+                break;
+        case 'q':
+                print_pathname(fs, ctx->dir, 0);
+                break;
+        case 'Q':
+                print_pathname(fs, ctx->dir, ctx->ino);
+                break;
+        case 'S':
+                printf("%d", get_backup_sb(NULL, fs, NULL, NULL));
+                break;
+        case 's':
+                printf("%s", ctx->str ? ctx->str : "NULL");
+                break;
+        case 'X':
+#ifdef EXT2_NO_64_TYPE
+                printf("0x%x", ctx->num);
+#else
+                printf("0x%llx", ctx->num);
+#endif
+                break;
+        default:
+        no_context:
+                printf("%%%c", ch);
+                break;
+        }
+}
+
+void print_e2fsck_message(e2fsck_t ctx, const char *msg,
+                          struct problem_context *pctx, int first)
+{
+        ext2_filsys fs = ctx->fs;
+        const char *    cp;
+        int             i;
+
+        e2fsck_clear_progbar(ctx);
+        for (cp = msg; *cp; cp++) {
+                if (cp[0] == '@') {
+                        cp++;
+                        expand_at_expression(ctx, *cp, pctx, &first);
+                } else if (cp[0] == '%' && cp[1] == 'I') {
+                        cp += 2;
+                        expand_inode_expression(*cp, pctx);
+                } else if (cp[0] == '%' && cp[1] == 'D') {
+                        cp += 2;
+                        expand_dirent_expression(*cp, pctx);
+                } else if ((cp[0] == '%')) {
+                        cp++;
+                        expand_percent_expression(fs, *cp, pctx);
+                } else {
+                        for (i=0; cp[i]; i++)
+                                if ((cp[i] == '@') || cp[i] == '%')
+                                        break;
+                        printf("%.*s", i, cp);
+                        cp += i-1;
+                }
+                first = 0;
+        }
+}
+/*
+ * pass1.c -- pass #1 of e2fsck: sequential scan of the inode table
+ *
+ * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ *
+ * Pass 1 of e2fsck iterates over all the inodes in the filesystems,
+ * and applies the following tests to each inode:
+ *
+ *      - The mode field of the inode must be legal.
+ *      - The size and block count fields of the inode are correct.
+ *      - A data block must not be used by another inode
+ *
+ * Pass 1 also gathers the collects the following information:
+ *
+ *      - A bitmap of which inodes are in use.          (inode_used_map)
+ *      - A bitmap of which inodes are directories.     (inode_dir_map)
+ *      - A bitmap of which inodes are regular files.   (inode_reg_map)
+ *      - A bitmap of which inodes have bad fields.     (inode_bad_map)
+ *      - A bitmap of which inodes are in bad blocks.   (inode_bb_map)
+ *      - A bitmap of which inodes are imagic inodes.   (inode_imagic_map)
+ *      - A bitmap of which blocks are in use.          (block_found_map)
+ *      - A bitmap of which blocks are in use by two inodes     (block_dup_map)
+ *      - The data blocks of the directory inodes.      (dir_map)
+ *
+ * Pass 1 is designed to stash away enough information so that the
+ * other passes should not need to read in the inode information
+ * during the normal course of a filesystem check.  (Althogh if an
+ * inconsistency is detected, other passes may need to read in an
+ * inode to fix it.)
+ *
+ * Note that pass 1B will be invoked if there are any duplicate blocks
+ * found.
+ */
+
+
+static int process_block(ext2_filsys fs, blk_t  *blocknr,
+                         e2_blkcnt_t blockcnt, blk_t ref_blk,
+                         int ref_offset, void *priv_data);
+static int process_bad_block(ext2_filsys fs, blk_t *block_nr,
+                             e2_blkcnt_t blockcnt, blk_t ref_blk,
+                             int ref_offset, void *priv_data);
+static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
+                         char *block_buf);
+static void mark_table_blocks(e2fsck_t ctx);
+static void alloc_bb_map(e2fsck_t ctx);
+static void alloc_imagic_map(e2fsck_t ctx);
+static void mark_inode_bad(e2fsck_t ctx, ino_t ino);
+static void handle_fs_bad_blocks(e2fsck_t ctx);
+static void process_inodes(e2fsck_t ctx, char *block_buf);
+static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b);
+static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan,
+                                  dgrp_t group, void * priv_data);
+static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
+                                    char *block_buf, int adjust_sign);
+/* static char *describe_illegal_block(ext2_filsys fs, blk_t block); */
+
+static void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino,
+                               struct ext2_inode * inode, int bufsize,
+                               const char *proc);
+
+struct process_block_struct_1 {
+        ext2_ino_t      ino;
+        unsigned        is_dir:1, is_reg:1, clear:1, suppress:1,
+                                fragmented:1, compressed:1, bbcheck:1;
+        blk_t           num_blocks;
+        blk_t           max_blocks;
+        e2_blkcnt_t     last_block;
+        int             num_illegal_blocks;
+        blk_t           previous_block;
+        struct ext2_inode *inode;
+        struct problem_context *pctx;
+        ext2fs_block_bitmap fs_meta_blocks;
+        e2fsck_t        ctx;
+};
+
+struct process_inode_block {
+        ext2_ino_t ino;
+        struct ext2_inode inode;
+};
+
+struct scan_callback_struct {
+        e2fsck_t        ctx;
+        char            *block_buf;
+};
+
+/*
+ * For the inodes to process list.
+ */
+static struct process_inode_block *inodes_to_process;
+static int process_inode_count;
+
+static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE -
+                            EXT2_MIN_BLOCK_LOG_SIZE + 1];
+
+/*
+ * Free all memory allocated by pass1 in preparation for restarting
+ * things.
+ */
+static void unwind_pass1(ext2_filsys fs EXT2FS_ATTR((unused)))
+{
+        ext2fs_free_mem(&inodes_to_process);
+        inodes_to_process = 0;
+}
+
+/*
+ * Check to make sure a device inode is real.  Returns 1 if the device
+ * checks out, 0 if not.
+ *
+ * Note: this routine is now also used to check FIFO's and Sockets,
+ * since they have the same requirement; the i_block fields should be
+ * zero.
+ */
+int e2fsck_pass1_check_device_inode(ext2_filsys fs, struct ext2_inode *inode)
+{
+        int     i;
+
+        /*
+         * If i_blocks is non-zero, or the index flag is set, then
+         * this is a bogus device/fifo/socket
+         */
+        if ((ext2fs_inode_data_blocks(fs, inode) != 0) ||
+            (inode->i_flags & EXT2_INDEX_FL))
+                return 0;
+
+        /*
+         * We should be able to do the test below all the time, but
+         * because the kernel doesn't forcibly clear the device
+         * inode's additional i_block fields, there are some rare
+         * occasions when a legitimate device inode will have non-zero
+         * additional i_block fields.  So for now, we only complain
+         * when the immutable flag is set, which should never happen
+         * for devices.  (And that's when the problem is caused, since
+         * you can't set or clear immutable flags for devices.)  Once
+         * the kernel has been fixed we can change this...
+         */
+        if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) {
+                for (i=4; i < EXT2_N_BLOCKS; i++)
+                        if (inode->i_block[i])
+                                return 0;
+        }
+        return 1;
+}
+
+/*
+ * Check to make sure a symlink inode is real.  Returns 1 if the symlink
+ * checks out, 0 if not.
+ */
+int e2fsck_pass1_check_symlink(ext2_filsys fs, struct ext2_inode *inode,
+                               char *buf)
+{
+        unsigned int len;
+        int i;
+        blk_t   blocks;
+
+        if ((inode->i_size_high || inode->i_size == 0) ||
+            (inode->i_flags & EXT2_INDEX_FL))
+                return 0;
+
+        blocks = ext2fs_inode_data_blocks(fs, inode);
+        if (blocks) {
+                if ((inode->i_size >= fs->blocksize) ||
+                    (blocks != fs->blocksize >> 9) ||
+                    (inode->i_block[0] < fs->super->s_first_data_block) ||
+                    (inode->i_block[0] >= fs->super->s_blocks_count))
+                        return 0;
+
+                for (i = 1; i < EXT2_N_BLOCKS; i++)
+                        if (inode->i_block[i])
+                                return 0;
+
+                if (io_channel_read_blk(fs->io, inode->i_block[0], 1, buf))
+                        return 0;
+
+                len = strnlen(buf, fs->blocksize);
+                if (len == fs->blocksize)
+                        return 0;
+        } else {
+                if (inode->i_size >= sizeof(inode->i_block))
+                        return 0;
+
+                len = strnlen((char *)inode->i_block, sizeof(inode->i_block));
+                if (len == sizeof(inode->i_block))
+                        return 0;
+        }
+        if (len != inode->i_size)
+                return 0;
+        return 1;
+}
+
+/*
+ * If the immutable (or append-only) flag is set on the inode, offer
+ * to clear it.
+ */
+#define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)
+static void check_immutable(e2fsck_t ctx, struct problem_context *pctx)
+{
+        if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS))
+                return;
+
+        if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx))
+                return;
+
+        pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS;
+        e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
+}
+
+/*
+ * If device, fifo or socket, check size is zero -- if not offer to
+ * clear it
+ */
+static void check_size(e2fsck_t ctx, struct problem_context *pctx)
+{
+        struct ext2_inode *inode = pctx->inode;
+
+        if ((inode->i_size == 0) && (inode->i_size_high == 0))
+                return;
+
+        if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx))
+                return;
+
+        inode->i_size = 0;
+        inode->i_size_high = 0;
+        e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
+}
+
+static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx)
+{
+        struct ext2_super_block *sb = ctx->fs->super;
+        struct ext2_inode_large *inode;
+        struct ext2_ext_attr_entry *entry;
+        char *start, *end;
+        int storage_size, remain, offs;
+        int problem = 0;
+
+        inode = (struct ext2_inode_large *) pctx->inode;
+        storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE -
+                inode->i_extra_isize;
+        start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
+                inode->i_extra_isize + sizeof(__u32);
+        end = (char *) inode + EXT2_INODE_SIZE(ctx->fs->super);
+        entry = (struct ext2_ext_attr_entry *) start;
+
+        /* scan all entry's headers first */
+
+        /* take finish entry 0UL into account */
+        remain = storage_size - sizeof(__u32);
+        offs = end - start;
+
+        while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
+
+                /* header eats this space */
+                remain -= sizeof(struct ext2_ext_attr_entry);
+
+                /* is attribute name valid? */
+                if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) {
+                        pctx->num = entry->e_name_len;
+                        problem = PR_1_ATTR_NAME_LEN;
+                        goto fix;
+                }
+
+                /* attribute len eats this space */
+                remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
+
+                /* check value size */
+                if (entry->e_value_size == 0 || entry->e_value_size > remain) {
+                        pctx->num = entry->e_value_size;
+                        problem = PR_1_ATTR_VALUE_SIZE;
+                        goto fix;
+                }
+
+                /* check value placement */
+                if (entry->e_value_offs +
+                    EXT2_XATTR_SIZE(entry->e_value_size) != offs) {
+                        printf("(entry->e_value_offs + entry->e_value_size: %d, offs: %d)\n", entry->e_value_offs + entry->e_value_size, offs);
+                        pctx->num = entry->e_value_offs;
+                        problem = PR_1_ATTR_VALUE_OFFSET;
+                        goto fix;
+                }
+
+                /* e_value_block must be 0 in inode's ea */
+                if (entry->e_value_block != 0) {
+                        pctx->num = entry->e_value_block;
+                        problem = PR_1_ATTR_VALUE_BLOCK;
+                        goto fix;
+                }
+
+                /* e_hash must be 0 in inode's ea */
+                if (entry->e_hash != 0) {
+                        pctx->num = entry->e_hash;
+                        problem = PR_1_ATTR_HASH;
+                        goto fix;
+                }
+
+                remain -= entry->e_value_size;
+                offs -= EXT2_XATTR_SIZE(entry->e_value_size);
+
+                entry = EXT2_EXT_ATTR_NEXT(entry);
+        }
+fix:
+        /*
+         * it seems like a corruption. it's very unlikely we could repair
+         * EA(s) in automatic fashion -bzzz
+         */
+#if 0
+        problem = PR_1_ATTR_HASH;
+#endif
+        if (problem == 0 || !fix_problem(ctx, problem, pctx))
+                return;
+
+        /* simple remove all possible EA(s) */
+        *((__u32 *)start) = 0UL;
+        e2fsck_write_inode_full(ctx, pctx->ino, (struct ext2_inode *)inode,
+                                EXT2_INODE_SIZE(sb), "pass1");
+}
+
+static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx)
+{
+        struct ext2_super_block *sb = ctx->fs->super;
+        struct ext2_inode_large *inode;
+        __u32 *eamagic;
+        int min, max;
+
+        inode = (struct ext2_inode_large *) pctx->inode;
+        if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) {
+                /* this isn't large inode. so, nothing to check */
+                return;
+        }
+
+#if 0
+        printf("inode #%u, i_extra_size %d\n", pctx->ino,
+                        inode->i_extra_isize);
+#endif
+        /* i_extra_isize must cover i_extra_isize + i_pad1 at least */
+        min = sizeof(inode->i_extra_isize) + sizeof(inode->i_pad1);
+        max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE;
+        /*
+         * For now we will allow i_extra_isize to be 0, but really
+         * implementations should never allow i_extra_isize to be 0
+         */
+        if (inode->i_extra_isize &&
+            (inode->i_extra_isize < min || inode->i_extra_isize > max)) {
+                if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx))
+                        return;
+                inode->i_extra_isize = min;
+                e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode,
+                                        EXT2_INODE_SIZE(sb), "pass1");
+                return;
+        }
+
+        eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
+                        inode->i_extra_isize);
+        if (*eamagic == EXT2_EXT_ATTR_MAGIC) {
+                /* it seems inode has an extended attribute(s) in body */
+                check_ea_in_inode(ctx, pctx);
+        }
+}
+
+void e2fsck_pass1(e2fsck_t ctx)
+{
+        int     i;
+        __u64   max_sizes;
+        ext2_filsys fs = ctx->fs;
+        ext2_ino_t      ino;
+        struct ext2_inode *inode;
+        ext2_inode_scan scan;
+        char            *block_buf;
+#ifdef RESOURCE_TRACK
+        struct resource_track   rtrack;
+#endif
+        unsigned char   frag, fsize;
+        struct          problem_context pctx;
+        struct          scan_callback_struct scan_struct;
+        struct ext2_super_block *sb = ctx->fs->super;
+        int             imagic_fs;
+        int             busted_fs_time = 0;
+        int             inode_size;
+
+#ifdef RESOURCE_TRACK
+        init_resource_track(&rtrack);
+#endif
+        clear_problem_context(&pctx);
+
+        if (!(ctx->options & E2F_OPT_PREEN))
+                fix_problem(ctx, PR_1_PASS_HEADER, &pctx);
+
+        if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
+            !(ctx->options & E2F_OPT_NO)) {
+                if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50))
+                        ctx->dirs_to_hash = 0;
+        }
+
+#ifdef MTRACE
+        mtrace_print("Pass 1");
+#endif
+
+#define EXT2_BPP(bits) (1ULL << ((bits) - 2))
+
+        for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) {
+                max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i);
+                max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i);
+                max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i);
+                max_sizes = (max_sizes * (1UL << i)) - 1;
+                ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes;
+        }
+#undef EXT2_BPP
+
+        imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES);
+
+        /*
+         * Allocate bitmaps structures
+         */
+        pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("in-use inode map"),
+                                              &ctx->inode_used_map);
+        if (pctx.errcode) {
+                pctx.num = 1;
+                fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+        pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
+                                _("directory inode map"), &ctx->inode_dir_map);
+        if (pctx.errcode) {
+                pctx.num = 2;
+                fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+        pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
+                        _("regular file inode map"), &ctx->inode_reg_map);
+        if (pctx.errcode) {
+                pctx.num = 6;
+                fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+        pctx.errcode = ext2fs_allocate_block_bitmap(fs, _("in-use block map"),
+                                              &ctx->block_found_map);
+        if (pctx.errcode) {
+                pctx.num = 1;
+                fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+        pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0,
+                                             &ctx->inode_link_info);
+        if (pctx.errcode) {
+                fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+        inode_size = EXT2_INODE_SIZE(fs->super);
+        inode = (struct ext2_inode *)
+                e2fsck_allocate_memory(ctx, inode_size, "scratch inode");
+
+        inodes_to_process = (struct process_inode_block *)
+                e2fsck_allocate_memory(ctx,
+                                       (ctx->process_inode_size *
+                                        sizeof(struct process_inode_block)),
+                                       "array of inodes to process");
+        process_inode_count = 0;
+
+        pctx.errcode = ext2fs_init_dblist(fs, 0);
+        if (pctx.errcode) {
+                fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+
+        /*
+         * If the last orphan field is set, clear it, since the pass1
+         * processing will automatically find and clear the orphans.
+         * In the future, we may want to try using the last_orphan
+         * linked list ourselves, but for now, we clear it so that the
+         * ext3 mount code won't get confused.
+         */
+        if (!(ctx->options & E2F_OPT_READONLY)) {
+                if (fs->super->s_last_orphan) {
+                        fs->super->s_last_orphan = 0;
+                        ext2fs_mark_super_dirty(fs);
+                }
+        }
+
+        mark_table_blocks(ctx);
+        block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3,
+                                                    "block interate buffer");
+        e2fsck_use_inode_shortcuts(ctx, 1);
+        ehandler_operation(_("doing inode scan"));
+        pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks,
+                                              &scan);
+        if (pctx.errcode) {
+                fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+        ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0);
+        ctx->stashed_inode = inode;
+        scan_struct.ctx = ctx;
+        scan_struct.block_buf = block_buf;
+        ext2fs_set_inode_callback(scan, scan_callback, &scan_struct);
+        if (ctx->progress)
+                if ((ctx->progress)(ctx, 1, 0, ctx->fs->group_desc_count))
+                        return;
+        if (fs->super->s_wtime < fs->super->s_inodes_count)
+                busted_fs_time = 1;
+
+        while (1) {
+                pctx.errcode = ext2fs_get_next_inode_full(scan, &ino,
+                                                          inode, inode_size);
+                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                        return;
+                if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) {
+                        if (!ctx->inode_bb_map)
+                                alloc_bb_map(ctx);
+                        ext2fs_mark_inode_bitmap(ctx->inode_bb_map, ino);
+                        ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
+                        continue;
+                }
+                if (pctx.errcode) {
+                        fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return;
+                }
+                if (!ino)
+                        break;
+                pctx.ino = ino;
+                pctx.inode = inode;
+                ctx->stashed_ino = ino;
+                if (inode->i_links_count) {
+                        pctx.errcode = ext2fs_icount_store(ctx->inode_link_info,
+                                           ino, inode->i_links_count);
+                        if (pctx.errcode) {
+                                pctx.num = inode->i_links_count;
+                                fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx);
+                                ctx->flags |= E2F_FLAG_ABORT;
+                                return;
+                        }
+                }
+                if (ino == EXT2_BAD_INO) {
+                        struct process_block_struct_1 pb;
+
+                        pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map,
+                                                          &pb.fs_meta_blocks);
+                        if (pctx.errcode) {
+                                pctx.num = 4;
+                                fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
+                                ctx->flags |= E2F_FLAG_ABORT;
+                                return;
+                        }
+                        pb.ino = EXT2_BAD_INO;
+                        pb.num_blocks = pb.last_block = 0;
+                        pb.num_illegal_blocks = 0;
+                        pb.suppress = 0; pb.clear = 0; pb.is_dir = 0;
+                        pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0;
+                        pb.inode = inode;
+                        pb.pctx = &pctx;
+                        pb.ctx = ctx;
+                        pctx.errcode = ext2fs_block_iterate2(fs, ino, 0,
+                                     block_buf, process_bad_block, &pb);
+                        ext2fs_free_block_bitmap(pb.fs_meta_blocks);
+                        if (pctx.errcode) {
+                                fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx);
+                                ctx->flags |= E2F_FLAG_ABORT;
+                                return;
+                        }
+                        if (pb.bbcheck)
+                                if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) {
+                                ctx->flags |= E2F_FLAG_ABORT;
+                                return;
+                        }
+                        ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
+                        clear_problem_context(&pctx);
+                        continue;
+                } else if (ino == EXT2_ROOT_INO) {
+                        /*
+                         * Make sure the root inode is a directory; if
+                         * not, offer to clear it.  It will be
+                         * regnerated in pass #3.
+                         */
+                        if (!LINUX_S_ISDIR(inode->i_mode)) {
+                                if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx)) {
+                                        inode->i_dtime = time(0);
+                                        inode->i_links_count = 0;
+                                        ext2fs_icount_store(ctx->inode_link_info,
+                                                            ino, 0);
+                                        e2fsck_write_inode(ctx, ino, inode,
+                                                           "pass1");
+                                }
+
+                        }
+                        /*
+                         * If dtime is set, offer to clear it.  mke2fs
+                         * version 0.2b created filesystems with the
+                         * dtime field set for the root and lost+found
+                         * directories.  We won't worry about
+                         * /lost+found, since that can be regenerated
+                         * easily.  But we will fix the root directory
+                         * as a special case.
+                         */
+                        if (inode->i_dtime && inode->i_links_count) {
+                                if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) {
+                                        inode->i_dtime = 0;
+                                        e2fsck_write_inode(ctx, ino, inode,
+                                                           "pass1");
+                                }
+                        }
+                } else if (ino == EXT2_JOURNAL_INO) {
+                        ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
+                        if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) {
+                                if (!LINUX_S_ISREG(inode->i_mode) &&
+                                    fix_problem(ctx, PR_1_JOURNAL_BAD_MODE,
+                                                &pctx)) {
+                                        inode->i_mode = LINUX_S_IFREG;
+                                        e2fsck_write_inode(ctx, ino, inode,
+                                                           "pass1");
+                                }
+                                check_blocks(ctx, &pctx, block_buf);
+                                continue;
+                        }
+                        if ((inode->i_links_count || inode->i_blocks ||
+                             inode->i_blocks || inode->i_block[0]) &&
+                            fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR,
+                                        &pctx)) {
+                                memset(inode, 0, inode_size);
+                                ext2fs_icount_store(ctx->inode_link_info,
+                                                    ino, 0);
+                                e2fsck_write_inode_full(ctx, ino, inode,
+                                                        inode_size, "pass1");
+                        }
+                } else if (ino < EXT2_FIRST_INODE(fs->super)) {
+                        int     problem = 0;
+
+                        ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
+                        if (ino == EXT2_BOOT_LOADER_INO) {
+                                if (LINUX_S_ISDIR(inode->i_mode))
+                                        problem = PR_1_RESERVED_BAD_MODE;
+                        } else if (ino == EXT2_RESIZE_INO) {
+                                if (inode->i_mode &&
+                                    !LINUX_S_ISREG(inode->i_mode))
+                                        problem = PR_1_RESERVED_BAD_MODE;
+                        } else {
+                                if (inode->i_mode != 0)
+                                        problem = PR_1_RESERVED_BAD_MODE;
+                        }
+                        if (problem) {
+                                if (fix_problem(ctx, problem, &pctx)) {
+                                        inode->i_mode = 0;
+                                        e2fsck_write_inode(ctx, ino, inode,
+                                                           "pass1");
+                                }
+                        }
+                        check_blocks(ctx, &pctx, block_buf);
+                        continue;
+                }
+                /*
+                 * Check for inodes who might have been part of the
+                 * orphaned list linked list.  They should have gotten
+                 * dealt with by now, unless the list had somehow been
+                 * corrupted.
+                 *
+                 * FIXME: In the future, inodes which are still in use
+                 * (and which are therefore) pending truncation should
+                 * be handled specially.  Right now we just clear the
+                 * dtime field, and the normal e2fsck handling of
+                 * inodes where i_size and the inode blocks are
+                 * inconsistent is to fix i_size, instead of releasing
+                 * the extra blocks.  This won't catch the inodes that
+                 * was at the end of the orphan list, but it's better
+                 * than nothing.  The right answer is that there
+                 * shouldn't be any bugs in the orphan list handling.  :-)
+                 */
+                if (inode->i_dtime && !busted_fs_time &&
+                    inode->i_dtime < ctx->fs->super->s_inodes_count) {
+                        if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) {
+                                inode->i_dtime = inode->i_links_count ?
+                                        0 : time(0);
+                                e2fsck_write_inode(ctx, ino, inode,
+                                                   "pass1");
+                        }
+                }
+
+                /*
+                 * This code assumes that deleted inodes have
+                 * i_links_count set to 0.
+                 */
+                if (!inode->i_links_count) {
+                        if (!inode->i_dtime && inode->i_mode) {
+                                if (fix_problem(ctx,
+                                            PR_1_ZERO_DTIME, &pctx)) {
+                                        inode->i_dtime = time(0);
+                                        e2fsck_write_inode(ctx, ino, inode,
+                                                           "pass1");
+                                }
+                        }
+                        continue;
+                }
+                /*
+                 * n.b.  0.3c ext2fs code didn't clear i_links_count for
+                 * deleted files.  Oops.
+                 *
+                 * Since all new ext2 implementations get this right,
+                 * we now assume that the case of non-zero
+                 * i_links_count and non-zero dtime means that we
+                 * should keep the file, not delete it.
+                 *
+                 */
+                if (inode->i_dtime) {
+                        if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) {
+                                inode->i_dtime = 0;
+                                e2fsck_write_inode(ctx, ino, inode, "pass1");
+                        }
+                }
+
+                ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
+                switch (fs->super->s_creator_os) {
+                    case EXT2_OS_LINUX:
+                        frag = inode->osd2.linux2.l_i_frag;
+                        fsize = inode->osd2.linux2.l_i_fsize;
+                        break;
+                    case EXT2_OS_HURD:
+                        frag = inode->osd2.hurd2.h_i_frag;
+                        fsize = inode->osd2.hurd2.h_i_fsize;
+                        break;
+                    case EXT2_OS_MASIX:
+                        frag = inode->osd2.masix2.m_i_frag;
+                        fsize = inode->osd2.masix2.m_i_fsize;
+                        break;
+                    default:
+                        frag = fsize = 0;
+                }
+
+                if (inode->i_faddr || frag || fsize ||
+                    (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl))
+                        mark_inode_bad(ctx, ino);
+                if (inode->i_flags & EXT2_IMAGIC_FL) {
+                        if (imagic_fs) {
+                                if (!ctx->inode_imagic_map)
+                                        alloc_imagic_map(ctx);
+                                ext2fs_mark_inode_bitmap(ctx->inode_imagic_map,
+                                                         ino);
+                        } else {
+                                if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) {
+                                        inode->i_flags &= ~EXT2_IMAGIC_FL;
+                                        e2fsck_write_inode(ctx, ino,
+                                                           inode, "pass1");
+                                }
+                        }
+                }
+
+                check_inode_extra_space(ctx, &pctx);
+
+                if (LINUX_S_ISDIR(inode->i_mode)) {
+                        ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino);
+                        e2fsck_add_dir_info(ctx, ino, 0);
+                        ctx->fs_directory_count++;
+                } else if (LINUX_S_ISREG (inode->i_mode)) {
+                        ext2fs_mark_inode_bitmap(ctx->inode_reg_map, ino);
+                        ctx->fs_regular_count++;
+                } else if (LINUX_S_ISCHR (inode->i_mode) &&
+                           e2fsck_pass1_check_device_inode(fs, inode)) {
+                        check_immutable(ctx, &pctx);
+                        check_size(ctx, &pctx);
+                        ctx->fs_chardev_count++;
+                } else if (LINUX_S_ISBLK (inode->i_mode) &&
+                           e2fsck_pass1_check_device_inode(fs, inode)) {
+                        check_immutable(ctx, &pctx);
+                        check_size(ctx, &pctx);
+                        ctx->fs_blockdev_count++;
+                } else if (LINUX_S_ISLNK (inode->i_mode) &&
+                           e2fsck_pass1_check_symlink(fs, inode, block_buf)) {
+                        check_immutable(ctx, &pctx);
+                        ctx->fs_symlinks_count++;
+                        if (ext2fs_inode_data_blocks(fs, inode) == 0) {
+                                ctx->fs_fast_symlinks_count++;
+                                check_blocks(ctx, &pctx, block_buf);
+                                continue;
+                        }
+                }
+                else if (LINUX_S_ISFIFO (inode->i_mode) &&
+                         e2fsck_pass1_check_device_inode(fs, inode)) {
+                        check_immutable(ctx, &pctx);
+                        check_size(ctx, &pctx);
+                        ctx->fs_fifo_count++;
+                } else if ((LINUX_S_ISSOCK (inode->i_mode)) &&
+                           e2fsck_pass1_check_device_inode(fs, inode)) {
+                        check_immutable(ctx, &pctx);
+                        check_size(ctx, &pctx);
+                        ctx->fs_sockets_count++;
+                } else
+                        mark_inode_bad(ctx, ino);
+                if (inode->i_block[EXT2_IND_BLOCK])
+                        ctx->fs_ind_count++;
+                if (inode->i_block[EXT2_DIND_BLOCK])
+                        ctx->fs_dind_count++;
+                if (inode->i_block[EXT2_TIND_BLOCK])
+                        ctx->fs_tind_count++;
+                if (inode->i_block[EXT2_IND_BLOCK] ||
+                    inode->i_block[EXT2_DIND_BLOCK] ||
+                    inode->i_block[EXT2_TIND_BLOCK] ||
+                    inode->i_file_acl) {
+                        inodes_to_process[process_inode_count].ino = ino;
+                        inodes_to_process[process_inode_count].inode = *inode;
+                        process_inode_count++;
+                } else
+                        check_blocks(ctx, &pctx, block_buf);
+
+                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                        return;
+
+                if (process_inode_count >= ctx->process_inode_size) {
+                        process_inodes(ctx, block_buf);
+
+                        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                                return;
+                }
+        }
+        process_inodes(ctx, block_buf);
+        ext2fs_close_inode_scan(scan);
+        ehandler_operation(0);
+
+        /*
+         * 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) {
+                ext2fs_block_bitmap save_bmap;
+
+                save_bmap = fs->block_map;
+                fs->block_map = ctx->block_found_map;
+                clear_problem_context(&pctx);
+                pctx.errcode = ext2fs_create_resize_inode(fs);
+                if (pctx.errcode) {
+                        fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, &pctx);
+                        /* Should never get here */
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return;
+                }
+                fs->block_map = save_bmap;
+                ctx->flags &= ~E2F_FLAG_RESIZE_INODE;
+        }
+
+        if (ctx->flags & E2F_FLAG_RESTART) {
+                /*
+                 * Only the master copy of the superblock and block
+                 * group descriptors are going to be written during a
+                 * restart, so set the superblock to be used to be the
+                 * master superblock.
+                 */
+                ctx->use_superblock = 0;
+                unwind_pass1(fs);
+                goto endit;
+        }
+
+        if (ctx->block_dup_map) {
+                if (ctx->options & E2F_OPT_PREEN) {
+                        clear_problem_context(&pctx);
+                        fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx);
+                }
+                e2fsck_pass1_dupblocks(ctx, block_buf);
+        }
+        ext2fs_free_mem(&inodes_to_process);
+endit:
+        e2fsck_use_inode_shortcuts(ctx, 0);
+
+        ext2fs_free_mem(&block_buf);
+        ext2fs_free_mem(&inode);
+
+#ifdef RESOURCE_TRACK
+        if (ctx->options & E2F_OPT_TIME2) {
+                e2fsck_clear_progbar(ctx);
+                print_resource_track(_("Pass 1"), &rtrack);
+        }
+#endif
+}
+
+/*
+ * When the inode_scan routines call this callback at the end of the
+ * glock group, call process_inodes.
+ */
+static errcode_t scan_callback(ext2_filsys fs,
+                               ext2_inode_scan scan EXT2FS_ATTR((unused)),
+                               dgrp_t group, void * priv_data)
+{
+        struct scan_callback_struct *scan_struct;
+        e2fsck_t ctx;
+
+        scan_struct = (struct scan_callback_struct *) priv_data;
+        ctx = scan_struct->ctx;
+
+        process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf);
+
+        if (ctx->progress)
+                if ((ctx->progress)(ctx, 1, group+1,
+                                    ctx->fs->group_desc_count))
+                        return EXT2_ET_CANCEL_REQUESTED;
+
+        return 0;
+}
+
+/*
+ * Process the inodes in the "inodes to process" list.
+ */
+static void process_inodes(e2fsck_t ctx, char *block_buf)
+{
+        int                     i;
+        struct ext2_inode       *old_stashed_inode;
+        ext2_ino_t              old_stashed_ino;
+        const char              *old_operation;
+        char                    buf[80];
+        struct problem_context  pctx;
+
+#if 0
+        printf("begin process_inodes: ");
+#endif
+        if (process_inode_count == 0)
+                return;
+        old_operation = ehandler_operation(0);
+        old_stashed_inode = ctx->stashed_inode;
+        old_stashed_ino = ctx->stashed_ino;
+        qsort(inodes_to_process, process_inode_count,
+                      sizeof(struct process_inode_block), process_inode_cmp);
+        clear_problem_context(&pctx);
+        for (i=0; i < process_inode_count; i++) {
+                pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode;
+                pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino;
+
+#if 0
+                printf("%u ", pctx.ino);
+#endif
+                sprintf(buf, _("reading indirect blocks of inode %u"),
+                        pctx.ino);
+                ehandler_operation(buf);
+                check_blocks(ctx, &pctx, block_buf);
+                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                        break;
+        }
+        ctx->stashed_inode = old_stashed_inode;
+        ctx->stashed_ino = old_stashed_ino;
+        process_inode_count = 0;
+#if 0
+        printf("end process inodes\n");
+#endif
+        ehandler_operation(old_operation);
+}
+
+static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b)
+{
+        const struct process_inode_block *ib_a =
+                (const struct process_inode_block *) a;
+        const struct process_inode_block *ib_b =
+                (const struct process_inode_block *) b;
+        int     ret;
+
+        ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] -
+               ib_b->inode.i_block[EXT2_IND_BLOCK]);
+        if (ret == 0)
+                ret = ib_a->inode.i_file_acl - ib_b->inode.i_file_acl;
+        return ret;
+}
+
+/*
+ * Mark an inode as being bad in some what
+ */
+static void mark_inode_bad(e2fsck_t ctx, ino_t ino)
+{
+        struct          problem_context pctx;
+
+        if (!ctx->inode_bad_map) {
+                clear_problem_context(&pctx);
+
+                pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
+                            _("bad inode map"), &ctx->inode_bad_map);
+                if (pctx.errcode) {
+                        pctx.num = 3;
+                        fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
+                        /* Should never get here */
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return;
+                }
+        }
+        ext2fs_mark_inode_bitmap(ctx->inode_bad_map, ino);
+}
+
+
+/*
+ * This procedure will allocate the inode "bb" (badblock) map table
+ */
+static void alloc_bb_map(e2fsck_t ctx)
+{
+        struct          problem_context pctx;
+
+        clear_problem_context(&pctx);
+        pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
+                                              _("inode in bad block map"),
+                                              &ctx->inode_bb_map);
+        if (pctx.errcode) {
+                pctx.num = 4;
+                fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
+                /* Should never get here */
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+}
+
+/*
+ * This procedure will allocate the inode imagic table
+ */
+static void alloc_imagic_map(e2fsck_t ctx)
+{
+        struct          problem_context pctx;
+
+        clear_problem_context(&pctx);
+        pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
+                                              _("imagic inode map"),
+                                              &ctx->inode_imagic_map);
+        if (pctx.errcode) {
+                pctx.num = 5;
+                fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
+                /* Should never get here */
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+}
+
+/*
+ * Marks a block as in use, setting the dup_map if it's been set
+ * already.  Called by process_block and process_bad_block.
+ *
+ * WARNING: Assumes checks have already been done to make sure block
+ * is valid.  This is true in both process_block and process_bad_block.
+ */
+static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block)
+{
+        struct          problem_context pctx;
+
+        clear_problem_context(&pctx);
+
+        if (ext2fs_fast_test_block_bitmap(ctx->block_found_map, block)) {
+                if (!ctx->block_dup_map) {
+                        pctx.errcode = ext2fs_allocate_block_bitmap(ctx->fs,
+                              _("multiply claimed block map"),
+                              &ctx->block_dup_map);
+                        if (pctx.errcode) {
+                                pctx.num = 3;
+                                fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR,
+                                            &pctx);
+                                /* Should never get here */
+                                ctx->flags |= E2F_FLAG_ABORT;
+                                return;
+                        }
+                }
+                ext2fs_fast_mark_block_bitmap(ctx->block_dup_map, block);
+        } else {
+                ext2fs_fast_mark_block_bitmap(ctx->block_found_map, block);
+        }
+}
+
+/*
+ * Adjust the extended attribute block's reference counts at the end
+ * of pass 1, either by subtracting out references for EA blocks that
+ * are still referenced in ctx->refcount, or by adding references for
+ * EA blocks that had extra references as accounted for in
+ * ctx->refcount_extra.
+ */
+static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount,
+                                    char *block_buf, int adjust_sign)
+{
+        struct ext2_ext_attr_header     *header;
+        struct problem_context          pctx;
+        ext2_filsys                     fs = ctx->fs;
+        blk_t                           blk;
+        __u32                           should_be;
+        int                             count;
+
+        clear_problem_context(&pctx);
+
+        ea_refcount_intr_begin(refcount);
+        while (1) {
+                if ((blk = ea_refcount_intr_next(refcount, &count)) == 0)
+                        break;
+                pctx.blk = blk;
+                pctx.errcode = ext2fs_read_ext_attr(fs, blk, block_buf);
+                if (pctx.errcode) {
+                        fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx);
+                        return;
+                }
+                header = (struct ext2_ext_attr_header *) block_buf;
+                pctx.blkcount = header->h_refcount;
+                should_be = header->h_refcount + adjust_sign * count;
+                pctx.num = should_be;
+                if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) {
+                        header->h_refcount = should_be;
+                        pctx.errcode = ext2fs_write_ext_attr(fs, blk,
+                                                             block_buf);
+                        if (pctx.errcode) {
+                                fix_problem(ctx, PR_1_EXTATTR_WRITE, &pctx);
+                                continue;
+                        }
+                }
+        }
+}
+
+/*
+ * Handle processing the extended attribute blocks
+ */
+static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx,
+                           char *block_buf)
+{
+        ext2_filsys fs = ctx->fs;
+        ext2_ino_t      ino = pctx->ino;
+        struct ext2_inode *inode = pctx->inode;
+        blk_t           blk;
+        char *          end;
+        struct ext2_ext_attr_header *header;
+        struct ext2_ext_attr_entry *entry;
+        int             count;
+        region_t        region;
+
+        blk = inode->i_file_acl;
+        if (blk == 0)
+                return 0;
+
+        /*
+         * If the Extended attribute flag isn't set, then a non-zero
+         * file acl means that the inode is corrupted.
+         *
+         * Or if the extended attribute block is an invalid block,
+         * then the inode is also corrupted.
+         */
+        if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) ||
+            (blk < fs->super->s_first_data_block) ||
+            (blk >= fs->super->s_blocks_count)) {
+                mark_inode_bad(ctx, ino);
+                return 0;
+        }
+
+        /* If ea bitmap hasn't been allocated, create it */
+        if (!ctx->block_ea_map) {
+                pctx->errcode = ext2fs_allocate_block_bitmap(fs,
+                                                      _("ext attr block map"),
+                                                      &ctx->block_ea_map);
+                if (pctx->errcode) {
+                        pctx->num = 2;
+                        fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx);
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return 0;
+                }
+        }
+
+        /* Create the EA refcount structure if necessary */
+        if (!ctx->refcount) {
+                pctx->errcode = ea_refcount_create(0, &ctx->refcount);
+                if (pctx->errcode) {
+                        pctx->num = 1;
+                        fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return 0;
+                }
+        }
+
+#if 0
+        /* Debugging text */
+        printf("Inode %u has EA block %u\n", ino, blk);
+#endif
+
+        /* Have we seen this EA block before? */
+        if (ext2fs_fast_test_block_bitmap(ctx->block_ea_map, blk)) {
+                if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0)
+                        return 1;
+                /* Ooops, this EA was referenced more than it stated */
+                if (!ctx->refcount_extra) {
+                        pctx->errcode = ea_refcount_create(0,
+                                           &ctx->refcount_extra);
+                        if (pctx->errcode) {
+                                pctx->num = 2;
+                                fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
+                                ctx->flags |= E2F_FLAG_ABORT;
+                                return 0;
+                        }
+                }
+                ea_refcount_increment(ctx->refcount_extra, blk, 0);
+                return 1;
+        }
+
+        /*
+         * OK, we haven't seen this EA block yet.  So we need to
+         * validate it
+         */
+        pctx->blk = blk;
+        pctx->errcode = ext2fs_read_ext_attr(fs, blk, block_buf);
+        if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx))
+                goto clear_extattr;
+        header = (struct ext2_ext_attr_header *) block_buf;
+        pctx->blk = inode->i_file_acl;
+        if (((ctx->ext_attr_ver == 1) &&
+             (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) ||
+            ((ctx->ext_attr_ver == 2) &&
+             (header->h_magic != EXT2_EXT_ATTR_MAGIC))) {
+                if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx))
+                        goto clear_extattr;
+        }
+
+        if (header->h_blocks != 1) {
+                if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx))
+                        goto clear_extattr;
+        }
+
+        region = region_create(0, fs->blocksize);
+        if (!region) {
+                fix_problem(ctx, PR_1_EA_ALLOC_REGION, pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return 0;
+        }
+        if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) {
+                if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
+                        goto clear_extattr;
+        }
+
+        entry = (struct ext2_ext_attr_entry *)(header+1);
+        end = block_buf + fs->blocksize;
+        while ((char *)entry < end && *(__u32 *)entry) {
+                if (region_allocate(region, (char *)entry - (char *)header,
+                                   EXT2_EXT_ATTR_LEN(entry->e_name_len))) {
+                        if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
+                                goto clear_extattr;
+                }
+                if ((ctx->ext_attr_ver == 1 &&
+                     (entry->e_name_len == 0 || entry->e_name_index != 0)) ||
+                    (ctx->ext_attr_ver == 2 &&
+                     entry->e_name_index == 0)) {
+                        if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx))
+                                goto clear_extattr;
+                }
+                if (entry->e_value_block != 0) {
+                        if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
+                                goto clear_extattr;
+                }
+                if (entry->e_value_size &&
+                    region_allocate(region, entry->e_value_offs,
+                                    EXT2_EXT_ATTR_SIZE(entry->e_value_size))) {
+                        if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
+                                goto clear_extattr;
+                }
+                entry = EXT2_EXT_ATTR_NEXT(entry);
+        }
+        if (region_allocate(region, (char *)entry - (char *)header, 4)) {
+                if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
+                        goto clear_extattr;
+        }
+        region_free(region);
+
+        count = header->h_refcount - 1;
+        if (count)
+                ea_refcount_store(ctx->refcount, blk, count);
+        mark_block_used(ctx, blk);
+        ext2fs_fast_mark_block_bitmap(ctx->block_ea_map, blk);
+
+        return 1;
+
+clear_extattr:
+        inode->i_file_acl = 0;
+        e2fsck_write_inode(ctx, ino, inode, "check_ext_attr");
+        return 0;
+}
+
+/* Returns 1 if bad htree, 0 if OK */
+static int handle_htree(e2fsck_t ctx, struct problem_context *pctx,
+                        ext2_ino_t ino EXT2FS_ATTR((unused)),
+                        struct ext2_inode *inode,
+                        char *block_buf)
+{
+        struct ext2_dx_root_info        *root;
+        ext2_filsys                     fs = ctx->fs;
+        errcode_t                       retval;
+        blk_t                           blk;
+
+        if ((!LINUX_S_ISDIR(inode->i_mode) &&
+             fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) ||
+            (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
+             fix_problem(ctx, PR_1_HTREE_SET, pctx)))
+                return 1;
+
+        blk = inode->i_block[0];
+        if (((blk == 0) ||
+             (blk < fs->super->s_first_data_block) ||
+             (blk >= fs->super->s_blocks_count)) &&
+            fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
+                return 1;
+
+        retval = io_channel_read_blk(fs->io, blk, 1, block_buf);
+        if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
+                return 1;
+
+        /* XXX should check that beginning matches a directory */
+        root = (struct ext2_dx_root_info *) (block_buf + 24);
+
+        if ((root->reserved_zero || root->info_length < 8) &&
+            fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
+                return 1;
+
+        pctx->num = root->hash_version;
+        if ((root->hash_version != EXT2_HASH_LEGACY) &&
+            (root->hash_version != EXT2_HASH_HALF_MD4) &&
+            (root->hash_version != EXT2_HASH_TEA) &&
+            fix_problem(ctx, PR_1_HTREE_HASHV, pctx))
+                return 1;
+
+        if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) &&
+            fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx))
+                return 1;
+
+        pctx->num = root->indirect_levels;
+        if ((root->indirect_levels > 1) &&
+            fix_problem(ctx, PR_1_HTREE_DEPTH, pctx))
+                return 1;
+
+        return 0;
+}
+
+/*
+ * This subroutine is called on each inode to account for all of the
+ * blocks used by that inode.
+ */
+static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
+                         char *block_buf)
+{
+        ext2_filsys fs = ctx->fs;
+        struct process_block_struct_1 pb;
+        ext2_ino_t      ino = pctx->ino;
+        struct ext2_inode *inode = pctx->inode;
+        int             bad_size = 0;
+        int             dirty_inode = 0;
+        __u64           size;
+
+        pb.ino = ino;
+        pb.num_blocks = 0;
+        pb.last_block = -1;
+        pb.num_illegal_blocks = 0;
+        pb.suppress = 0; pb.clear = 0;
+        pb.fragmented = 0;
+        pb.compressed = 0;
+        pb.previous_block = 0;
+        pb.is_dir = LINUX_S_ISDIR(inode->i_mode);
+        pb.is_reg = LINUX_S_ISREG(inode->i_mode);
+        pb.max_blocks = 1 << (31 - fs->super->s_log_block_size);
+        pb.inode = inode;
+        pb.pctx = pctx;
+        pb.ctx = ctx;
+        pctx->ino = ino;
+        pctx->errcode = 0;
+
+        if (inode->i_flags & EXT2_COMPRBLK_FL) {
+                if (fs->super->s_feature_incompat &
+                    EXT2_FEATURE_INCOMPAT_COMPRESSION)
+                        pb.compressed = 1;
+                else {
+                        if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) {
+                                inode->i_flags &= ~EXT2_COMPRBLK_FL;
+                                dirty_inode++;
+                        }
+                }
+        }
+
+        if (inode->i_file_acl && check_ext_attr(ctx, pctx, block_buf))
+                pb.num_blocks++;
+
+        if (ext2fs_inode_has_valid_blocks(inode))
+                pctx->errcode = ext2fs_block_iterate2(fs, ino,
+                                       pb.is_dir ? BLOCK_FLAG_HOLE : 0,
+                                       block_buf, process_block, &pb);
+        end_problem_latch(ctx, PR_LATCH_BLOCK);
+        end_problem_latch(ctx, PR_LATCH_TOOBIG);
+        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                goto out;
+        if (pctx->errcode)
+                fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx);
+
+        if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group)
+                ctx->fs_fragmented++;
+
+        if (pb.clear) {
+                inode->i_links_count = 0;
+                ext2fs_icount_store(ctx->inode_link_info, ino, 0);
+                inode->i_dtime = time(0);
+                dirty_inode++;
+                ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
+                ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino);
+                ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
+                /*
+                 * The inode was probably partially accounted for
+                 * before processing was aborted, so we need to
+                 * restart the pass 1 scan.
+                 */
+                ctx->flags |= E2F_FLAG_RESTART;
+                goto out;
+        }
+
+        if (inode->i_flags & EXT2_INDEX_FL) {
+                if (handle_htree(ctx, pctx, ino, inode, block_buf)) {
+                        inode->i_flags &= ~EXT2_INDEX_FL;
+                        dirty_inode++;
+                } else {
+#ifdef ENABLE_HTREE
+                        e2fsck_add_dx_dir(ctx, ino, pb.last_block+1);
+#endif
+                }
+        }
+        if (ctx->dirs_to_hash && pb.is_dir &&
+            !(inode->i_flags & EXT2_INDEX_FL) &&
+            ((inode->i_size / fs->blocksize) >= 3))
+                ext2fs_u32_list_add(ctx->dirs_to_hash, ino);
+
+        if (!pb.num_blocks && pb.is_dir) {
+                if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) {
+                        inode->i_links_count = 0;
+                        ext2fs_icount_store(ctx->inode_link_info, ino, 0);
+                        inode->i_dtime = time(0);
+                        dirty_inode++;
+                        ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
+                        ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino);
+                        ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
+                        ctx->fs_directory_count--;
+                        goto out;
+                }
+        }
+
+        pb.num_blocks *= (fs->blocksize / 512);
+#if 0
+        printf("inode %u, i_size = %lu, last_block = %lld, i_blocks=%lu, num_blocks = %lu\n",
+               ino, inode->i_size, pb.last_block, inode->i_blocks,
+               pb.num_blocks);
+#endif
+        if (pb.is_dir) {
+                int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super);
+                if (nblock > (pb.last_block + 1))
+                        bad_size = 1;
+                else if (nblock < (pb.last_block + 1)) {
+                        if (((pb.last_block + 1) - nblock) >
+                            fs->super->s_prealloc_dir_blocks)
+                                bad_size = 2;
+                }
+        } else {
+                size = EXT2_I_SIZE(inode);
+                if ((pb.last_block >= 0) &&
+                    (size < (__u64) pb.last_block * fs->blocksize))
+                        bad_size = 3;
+                else if (size > ext2_max_sizes[fs->super->s_log_block_size])
+                        bad_size = 4;
+        }
+        /* i_size for symlinks is checked elsewhere */
+        if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) {
+                pctx->num = (pb.last_block+1) * fs->blocksize;
+                if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) {
+                        inode->i_size = pctx->num;
+                        if (!LINUX_S_ISDIR(inode->i_mode))
+                                inode->i_size_high = pctx->num >> 32;
+                        dirty_inode++;
+                }
+                pctx->num = 0;
+        }
+        if (LINUX_S_ISREG(inode->i_mode) &&
+            (inode->i_size_high || inode->i_size & 0x80000000UL))
+                ctx->large_files++;
+        if (pb.num_blocks != inode->i_blocks) {
+                pctx->num = pb.num_blocks;
+                if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) {
+                        inode->i_blocks = pb.num_blocks;
+                        dirty_inode++;
+                }
+                pctx->num = 0;
+        }
+out:
+        if (dirty_inode)
+                e2fsck_write_inode(ctx, ino, inode, "check_blocks");
+}
+
+#if 0
+/*
+ * Helper function called by process block when an illegal block is
+ * found.  It returns a description about why the block is illegal
+ */
+static char *describe_illegal_block(ext2_filsys fs, blk_t block)
+{
+        blk_t   super;
+        int     i;
+        static char     problem[80];
+
+        super = fs->super->s_first_data_block;
+        strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block");
+        if (block < super) {
+                sprintf(problem, "< FIRSTBLOCK (%u)", super);
+                return(problem);
+        } else if (block >= fs->super->s_blocks_count) {
+                sprintf(problem, "> BLOCKS (%u)", fs->super->s_blocks_count);
+                return(problem);
+        }
+        for (i = 0; i < fs->group_desc_count; i++) {
+                if (block == super) {
+                        sprintf(problem, "is the superblock in group %d", i);
+                        break;
+                }
+                if (block > super &&
+                    block <= (super + fs->desc_blocks)) {
+                        sprintf(problem, "is in the group descriptors "
+                                "of group %d", i);
+                        break;
+                }
+                if (block == fs->group_desc[i].bg_block_bitmap) {
+                        sprintf(problem, "is the block bitmap of group %d", i);
+                        break;
+                }
+                if (block == fs->group_desc[i].bg_inode_bitmap) {
+                        sprintf(problem, "is the inode bitmap of group %d", i);
+                        break;
+                }
+                if (block >= fs->group_desc[i].bg_inode_table &&
+                    (block < fs->group_desc[i].bg_inode_table
+                     + fs->inode_blocks_per_group)) {
+                        sprintf(problem, "is in the inode table of group %d",
+                                i);
+                        break;
+                }
+                super += fs->super->s_blocks_per_group;
+        }
+        return(problem);
+}
+#endif
+
+/*
+ * This is a helper function for check_blocks().
+ */
+static int process_block(ext2_filsys fs,
+                  blk_t *block_nr,
+                  e2_blkcnt_t blockcnt,
+                  blk_t ref_block EXT2FS_ATTR((unused)),
+                  int ref_offset EXT2FS_ATTR((unused)),
+                  void *priv_data)
+{
+        struct process_block_struct_1 *p;
+        struct problem_context *pctx;
+        blk_t   blk = *block_nr;
+        int     ret_code = 0;
+        int     problem = 0;
+        e2fsck_t        ctx;
+
+        p = (struct process_block_struct_1 *) priv_data;
+        pctx = p->pctx;
+        ctx = p->ctx;
+
+        if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) {
+                /* todo: Check that the comprblk_fl is high, that the
+                   blkaddr pattern looks right (all non-holes up to
+                   first EXT2FS_COMPRESSED_BLKADDR, then all
+                   EXT2FS_COMPRESSED_BLKADDR up to end of cluster),
+                   that the feature_incompat bit is high, and that the
+                   inode is a regular file.  If we're doing a "full
+                   check" (a concept introduced to e2fsck by e2compr,
+                   meaning that we look at data blocks as well as
+                   metadata) then call some library routine that
+                   checks the compressed data.  I'll have to think
+                   about this, because one particularly important
+                   problem to be able to fix is to recalculate the
+                   cluster size if necessary.  I think that perhaps
+                   we'd better do most/all e2compr-specific checks
+                   separately, after the non-e2compr checks.  If not
+                   doing a full check, it may be useful to test that
+                   the personality is linux; e.g. if it isn't then
+                   perhaps this really is just an illegal block. */
+                return 0;
+        }
+
+        if (blk == 0) {
+                if (p->is_dir == 0) {
+                        /*
+                         * Should never happen, since only directories
+                         * get called with BLOCK_FLAG_HOLE
+                         */
+#if DEBUG_E2FSCK
+                        printf("process_block() called with blk == 0, "
+                               "blockcnt=%d, inode %lu???\n",
+                               blockcnt, p->ino);
+#endif
+                        return 0;
+                }
+                if (blockcnt < 0)
+                        return 0;
+                if (blockcnt * fs->blocksize < p->inode->i_size) {
+#if 0
+                        printf("Missing block (#%d) in directory inode %lu!\n",
+                               blockcnt, p->ino);
+#endif
+                        goto mark_dir;
+                }
+                return 0;
+        }
+
+#if 0
+        printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk,
+               blockcnt);
+#endif
+
+        /*
+         * Simplistic fragmentation check.  We merely require that the
+         * file be contiguous.  (Which can never be true for really
+         * big files that are greater than a block group.)
+         */
+        if (!HOLE_BLKADDR(p->previous_block)) {
+                if (p->previous_block+1 != blk)
+                        p->fragmented = 1;
+        }
+        p->previous_block = blk;
+
+        if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size)))
+                problem = PR_1_TOOBIG_DIR;
+        if (p->is_reg && p->num_blocks+1 >= p->max_blocks)
+                problem = PR_1_TOOBIG_REG;
+        if (!p->is_dir && !p->is_reg && blockcnt > 0)
+                problem = PR_1_TOOBIG_SYMLINK;
+
+        if (blk < fs->super->s_first_data_block ||
+            blk >= fs->super->s_blocks_count)
+                problem = PR_1_ILLEGAL_BLOCK_NUM;
+
+        if (problem) {
+                p->num_illegal_blocks++;
+                if (!p->suppress && (p->num_illegal_blocks % 12) == 0) {
+                        if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) {
+                                p->clear = 1;
+                                return BLOCK_ABORT;
+                        }
+                        if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) {
+                                p->suppress = 1;
+                                set_latch_flags(PR_LATCH_BLOCK,
+                                                PRL_SUPPRESS, 0);
+                        }
+                }
+                pctx->blk = blk;
+                pctx->blkcount = blockcnt;
+                if (fix_problem(ctx, problem, pctx)) {
+                        blk = *block_nr = 0;
+                        ret_code = BLOCK_CHANGED;
+                        goto mark_dir;
+                } else
+                        return 0;
+        }
+
+        if (p->ino == EXT2_RESIZE_INO) {
+                /*
+                 * The resize inode has already be sanity checked
+                 * during pass #0 (the superblock checks).  All we
+                 * have to do is mark the double indirect block as
+                 * being in use; all of the other blocks are handled
+                 * by mark_table_blocks()).
+                 */
+                if (blockcnt == BLOCK_COUNT_DIND)
+                        mark_block_used(ctx, blk);
+        } else
+                mark_block_used(ctx, blk);
+        p->num_blocks++;
+        if (blockcnt >= 0)
+                p->last_block = blockcnt;
+mark_dir:
+        if (p->is_dir && (blockcnt >= 0)) {
+                pctx->errcode = ext2fs_add_dir_block(fs->dblist, p->ino,
+                                                    blk, blockcnt);
+                if (pctx->errcode) {
+                        pctx->blk = blk;
+                        pctx->num = blockcnt;
+                        fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
+                        /* Should never get here */
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return BLOCK_ABORT;
+                }
+        }
+        return ret_code;
+}
+
+static int process_bad_block(ext2_filsys fs,
+                      blk_t *block_nr,
+                      e2_blkcnt_t blockcnt,
+                      blk_t ref_block EXT2FS_ATTR((unused)),
+                      int ref_offset EXT2FS_ATTR((unused)),
+                      void *priv_data)
+{
+        struct process_block_struct_1 *p;
+        blk_t           blk = *block_nr;
+        blk_t           first_block;
+        dgrp_t          i;
+        struct problem_context *pctx;
+        e2fsck_t        ctx;
+
+        /*
+         * Note: This function processes blocks for the bad blocks
+         * inode, which is never compressed.  So we don't use HOLE_BLKADDR().
+         */
+
+        if (!blk)
+                return 0;
+
+        p = (struct process_block_struct_1 *) priv_data;
+        ctx = p->ctx;
+        pctx = p->pctx;
+
+        pctx->ino = EXT2_BAD_INO;
+        pctx->blk = blk;
+        pctx->blkcount = blockcnt;
+
+        if ((blk < fs->super->s_first_data_block) ||
+            (blk >= fs->super->s_blocks_count)) {
+                if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) {
+                        *block_nr = 0;
+                        return BLOCK_CHANGED;
+                } else
+                        return 0;
+        }
+
+        if (blockcnt < 0) {
+                if (ext2fs_test_block_bitmap(p->fs_meta_blocks, blk)) {
+                        p->bbcheck = 1;
+                        if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) {
+                                *block_nr = 0;
+                                return BLOCK_CHANGED;
+                        }
+                } else if (ext2fs_test_block_bitmap(ctx->block_found_map,
+                                                    blk)) {
+                        p->bbcheck = 1;
+                        if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK,
+                                        pctx)) {
+                                *block_nr = 0;
+                                return BLOCK_CHANGED;
+                        }
+                        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                                return BLOCK_ABORT;
+                } else
+                        mark_block_used(ctx, blk);
+                return 0;
+        }
+#if 0
+        printf ("DEBUG: Marking %u as bad.\n", blk);
+#endif
+        ctx->fs_badblocks_count++;
+        /*
+         * If the block is not used, then mark it as used and return.
+         * If it is already marked as found, this must mean that
+         * there's an overlap between the filesystem table blocks
+         * (bitmaps and inode table) and the bad block list.
+         */
+        if (!ext2fs_test_block_bitmap(ctx->block_found_map, blk)) {
+                ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
+                return 0;
+        }
+        /*
+         * Try to find the where the filesystem block was used...
+         */
+        first_block = fs->super->s_first_data_block;
+
+        for (i = 0; i < fs->group_desc_count; i++ ) {
+                pctx->group = i;
+                pctx->blk = blk;
+                if (!ext2fs_bg_has_super(fs, i))
+                        goto skip_super;
+                if (blk == first_block) {
+                        if (i == 0) {
+                                if (fix_problem(ctx,
+                                                PR_1_BAD_PRIMARY_SUPERBLOCK,
+                                                pctx)) {
+                                        *block_nr = 0;
+                                        return BLOCK_CHANGED;
+                                }
+                                return 0;
+                        }
+                        fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx);
+                        return 0;
+                }
+                if ((blk > first_block) &&
+                    (blk <= first_block + fs->desc_blocks)) {
+                        if (i == 0) {
+                                pctx->blk = *block_nr;
+                                if (fix_problem(ctx,
+                        PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) {
+                                        *block_nr = 0;
+                                        return BLOCK_CHANGED;
+                                }
+                                return 0;
+                        }
+                        fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx);
+                        return 0;
+                }
+        skip_super:
+                if (blk == fs->group_desc[i].bg_block_bitmap) {
+                        if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) {
+                                ctx->invalid_block_bitmap_flag[i]++;
+                                ctx->invalid_bitmaps++;
+                        }
+                        return 0;
+                }
+                if (blk == fs->group_desc[i].bg_inode_bitmap) {
+                        if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) {
+                                ctx->invalid_inode_bitmap_flag[i]++;
+                                ctx->invalid_bitmaps++;
+                        }
+                        return 0;
+                }
+                if ((blk >= fs->group_desc[i].bg_inode_table) &&
+                    (blk < (fs->group_desc[i].bg_inode_table +
+                            fs->inode_blocks_per_group))) {
+                        /*
+                         * If there are bad blocks in the inode table,
+                         * the inode scan code will try to do
+                         * something reasonable automatically.
+                         */
+                        return 0;
+                }
+                first_block += fs->super->s_blocks_per_group;
+        }
+        /*
+         * If we've gotten to this point, then the only
+         * possibility is that the bad block inode meta data
+         * is using a bad block.
+         */
+        if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) ||
+            (blk == p->inode->i_block[EXT2_DIND_BLOCK]) ||
+            (blk == p->inode->i_block[EXT2_TIND_BLOCK])) {
+                p->bbcheck = 1;
+                if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) {
+                        *block_nr = 0;
+                        return BLOCK_CHANGED;
+                }
+                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                        return BLOCK_ABORT;
+                return 0;
+        }
+
+        pctx->group = -1;
+
+        /* Warn user that the block wasn't claimed */
+        fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx);
+
+        return 0;
+}
+
+static void new_table_block(e2fsck_t ctx, blk_t first_block, int group,
+                            const char *name, int num, blk_t *new_block)
+{
+        ext2_filsys fs = ctx->fs;
+        blk_t           old_block = *new_block;
+        int             i;
+        char            *buf;
+        struct problem_context  pctx;
+
+        clear_problem_context(&pctx);
+
+        pctx.group = group;
+        pctx.blk = old_block;
+        pctx.str = name;
+
+        pctx.errcode = ext2fs_get_free_blocks(fs, first_block,
+                        first_block + fs->super->s_blocks_per_group,
+                                        num, ctx->block_found_map, new_block);
+        if (pctx.errcode) {
+                pctx.num = num;
+                fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx);
+                ext2fs_unmark_valid(fs);
+                return;
+        }
+        pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf);
+        if (pctx.errcode) {
+                fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx);
+                ext2fs_unmark_valid(fs);
+                return;
+        }
+        ext2fs_mark_super_dirty(fs);
+        fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
+        pctx.blk2 = *new_block;
+        fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO :
+                          PR_1_RELOC_TO), &pctx);
+        pctx.blk2 = 0;
+        for (i = 0; i < num; i++) {
+                pctx.blk = i;
+                ext2fs_mark_block_bitmap(ctx->block_found_map, (*new_block)+i);
+                if (old_block) {
+                        pctx.errcode = io_channel_read_blk(fs->io,
+                                   old_block + i, 1, buf);
+                        if (pctx.errcode)
+                                fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx);
+                } else
+                        memset(buf, 0, fs->blocksize);
+
+                pctx.blk = (*new_block) + i;
+                pctx.errcode = io_channel_write_blk(fs->io, pctx.blk,
+                                              1, buf);
+                if (pctx.errcode)
+                        fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx);
+        }
+        ext2fs_free_mem(&buf);
+}
+
+/*
+ * This routine gets called at the end of pass 1 if bad blocks are
+ * detected in the superblock, group descriptors, inode_bitmaps, or
+ * block bitmaps.  At this point, all of the blocks have been mapped
+ * out, so we can try to allocate new block(s) to replace the bad
+ * blocks.
+ */
+static void handle_fs_bad_blocks(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        dgrp_t          i;
+        int             first_block = fs->super->s_first_data_block;
+
+        for (i = 0; i < fs->group_desc_count; i++) {
+                if (ctx->invalid_block_bitmap_flag[i]) {
+                        new_table_block(ctx, first_block, i, _("block bitmap"),
+                                        1, &fs->group_desc[i].bg_block_bitmap);
+                }
+                if (ctx->invalid_inode_bitmap_flag[i]) {
+                        new_table_block(ctx, first_block, i, _("inode bitmap"),
+                                        1, &fs->group_desc[i].bg_inode_bitmap);
+                }
+                if (ctx->invalid_inode_table_flag[i]) {
+                        new_table_block(ctx, first_block, i, _("inode table"),
+                                        fs->inode_blocks_per_group,
+                                        &fs->group_desc[i].bg_inode_table);
+                        ctx->flags |= E2F_FLAG_RESTART;
+                }
+                first_block += fs->super->s_blocks_per_group;
+        }
+        ctx->invalid_bitmaps = 0;
+}
+
+/*
+ * This routine marks all blocks which are used by the superblock,
+ * group descriptors, inode bitmaps, and block bitmaps.
+ */
+static void mark_table_blocks(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        blk_t   block, b;
+        dgrp_t  i;
+        int     j;
+        struct problem_context pctx;
+
+        clear_problem_context(&pctx);
+
+        block = fs->super->s_first_data_block;
+        for (i = 0; i < fs->group_desc_count; i++) {
+                pctx.group = i;
+
+                ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map);
+
+                /*
+                 * Mark the blocks used for the inode table
+                 */
+                if (fs->group_desc[i].bg_inode_table) {
+                        for (j = 0, b = fs->group_desc[i].bg_inode_table;
+                             j < fs->inode_blocks_per_group;
+                             j++, b++) {
+                                if (ext2fs_test_block_bitmap(ctx->block_found_map,
+                                                             b)) {
+                                        pctx.blk = b;
+                                        if (fix_problem(ctx,
+                                                PR_1_ITABLE_CONFLICT, &pctx)) {
+                                                ctx->invalid_inode_table_flag[i]++;
+                                                ctx->invalid_bitmaps++;
+                                        }
+                                } else {
+                                    ext2fs_mark_block_bitmap(ctx->block_found_map,
+                                                             b);
+                                }
+                        }
+                }
+
+                /*
+                 * Mark block used for the block bitmap
+                 */
+                if (fs->group_desc[i].bg_block_bitmap) {
+                        if (ext2fs_test_block_bitmap(ctx->block_found_map,
+                                     fs->group_desc[i].bg_block_bitmap)) {
+                                pctx.blk = fs->group_desc[i].bg_block_bitmap;
+                                if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) {
+                                        ctx->invalid_block_bitmap_flag[i]++;
+                                        ctx->invalid_bitmaps++;
+                                }
+                        } else {
+                            ext2fs_mark_block_bitmap(ctx->block_found_map,
+                                     fs->group_desc[i].bg_block_bitmap);
+                    }
+
+                }
+                /*
+                 * Mark block used for the inode bitmap
+                 */
+                if (fs->group_desc[i].bg_inode_bitmap) {
+                        if (ext2fs_test_block_bitmap(ctx->block_found_map,
+                                     fs->group_desc[i].bg_inode_bitmap)) {
+                                pctx.blk = fs->group_desc[i].bg_inode_bitmap;
+                                if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) {
+                                        ctx->invalid_inode_bitmap_flag[i]++;
+                                        ctx->invalid_bitmaps++;
+                                }
+                        } else {
+                            ext2fs_mark_block_bitmap(ctx->block_found_map,
+                                     fs->group_desc[i].bg_inode_bitmap);
+                        }
+                }
+                block += fs->super->s_blocks_per_group;
+        }
+}
+
+/*
+ * Thes subroutines short circuits ext2fs_get_blocks and
+ * ext2fs_check_directory; we use them since we already have the inode
+ * structure, so there's no point in letting the ext2fs library read
+ * the inode again.
+ */
+static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino,
+                                  blk_t *blocks)
+{
+        e2fsck_t ctx = (e2fsck_t) fs->priv_data;
+        int     i;
+
+        if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
+                return EXT2_ET_CALLBACK_NOTHANDLED;
+
+        for (i=0; i < EXT2_N_BLOCKS; i++)
+                blocks[i] = ctx->stashed_inode->i_block[i];
+        return 0;
+}
+
+static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino,
+                                  struct ext2_inode *inode)
+{
+        e2fsck_t ctx = (e2fsck_t) fs->priv_data;
+
+        if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
+                return EXT2_ET_CALLBACK_NOTHANDLED;
+        *inode = *ctx->stashed_inode;
+        return 0;
+}
+
+static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino,
+                            struct ext2_inode *inode)
+{
+        e2fsck_t ctx = (e2fsck_t) fs->priv_data;
+
+        if ((ino == ctx->stashed_ino) && ctx->stashed_inode)
+                *ctx->stashed_inode = *inode;
+        return EXT2_ET_CALLBACK_NOTHANDLED;
+}
+
+static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino)
+{
+        e2fsck_t ctx = (e2fsck_t) fs->priv_data;
+
+        if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
+                return EXT2_ET_CALLBACK_NOTHANDLED;
+
+        if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode))
+                return EXT2_ET_NO_DIRECTORY;
+        return 0;
+}
+
+void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool)
+{
+        ext2_filsys fs = ctx->fs;
+
+        if (bool) {
+                fs->get_blocks = pass1_get_blocks;
+                fs->check_directory = pass1_check_directory;
+                fs->read_inode = pass1_read_inode;
+                fs->write_inode = pass1_write_inode;
+                ctx->stashed_ino = 0;
+        } else {
+                fs->get_blocks = 0;
+                fs->check_directory = 0;
+                fs->read_inode = 0;
+                fs->write_inode = 0;
+        }
+}
+/*
+ * pass1b.c --- Pass #1b of e2fsck
+ *
+ * This file contains pass1B, pass1C, and pass1D of e2fsck.  They are
+ * only invoked if pass 1 discovered blocks which are in use by more
+ * than one inode.
+ *
+ * Pass1B scans the data blocks of all the inodes again, generating a
+ * complete list of duplicate blocks and which inodes have claimed
+ * them.
+ *
+ * Pass1C does a tree-traversal of the filesystem, to determine the
+ * parent directories of these inodes.  This step is necessary so that
+ * e2fsck can print out the pathnames of affected inodes.
+ *
+ * Pass1D is a reconciliation pass.  For each inode with duplicate
+ * blocks, the user is prompted if s/he would like to clone the file
+ * (so that the file gets a fresh copy of the duplicated blocks) or
+ * simply to delete the file.
+ *
+ * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ *
+ */
+
+
+/* Needed for architectures where sizeof(int) != sizeof(void *) */
+#define INT_TO_VOIDPTR(val)  ((void *)(intptr_t)(val))
+#define VOIDPTR_TO_INT(ptr)  ((int)(intptr_t)(ptr))
+
+/* Define an extension to the ext2 library's block count information */
+#define BLOCK_COUNT_EXTATTR     (-5)
+
+struct block_el {
+        blk_t   block;
+        struct block_el *next;
+};
+
+struct inode_el {
+        ext2_ino_t      inode;
+        struct inode_el *next;
+};
+
+struct dup_block {
+        int             num_bad;
+        struct inode_el *inode_list;
+};
+
+/*
+ * This structure stores information about a particular inode which
+ * is sharing blocks with other inodes.  This information is collected
+ * to display to the user, so that the user knows what files he or she
+ * is dealing with, when trying to decide how to resolve the conflict
+ * of multiply-claimed blocks.
+ */
+struct dup_inode {
+        ext2_ino_t              dir;
+        int                     num_dupblocks;
+        struct ext2_inode       inode;
+        struct block_el         *block_list;
+};
+
+static int process_pass1b_block(ext2_filsys fs, blk_t   *blocknr,
+                                e2_blkcnt_t blockcnt, blk_t ref_blk,
+                                int ref_offset, void *priv_data);
+static void delete_file(e2fsck_t ctx, ext2_ino_t ino,
+                        struct dup_inode *dp, char *block_buf);
+static int clone_file(e2fsck_t ctx, ext2_ino_t ino,
+                      struct dup_inode *dp, char* block_buf);
+static int check_if_fs_block(e2fsck_t ctx, blk_t test_blk);
+
+static void pass1b(e2fsck_t ctx, char *block_buf);
+static void pass1c(e2fsck_t ctx, char *block_buf);
+static void pass1d(e2fsck_t ctx, char *block_buf);
+
+static int dup_inode_count = 0;
+
+static dict_t blk_dict, ino_dict;
+
+static ext2fs_inode_bitmap inode_dup_map;
+
+static int dict_int_cmp(const void *a, const void *b)
+{
+        intptr_t        ia, ib;
+
+        ia = (intptr_t)a;
+        ib = (intptr_t)b;
+
+        return (ia-ib);
+}
+
+/*
+ * Add a duplicate block record
+ */
+static void add_dupe(e2fsck_t ctx, ext2_ino_t ino, blk_t blk,
+                     struct ext2_inode *inode)
+{
+        dnode_t *n;
+        struct dup_block        *db;
+        struct dup_inode        *di;
+        struct block_el         *blk_el;
+        struct inode_el         *ino_el;
+
+        n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(blk));
+        if (n)
+                db = (struct dup_block *) dnode_get(n);
+        else {
+                db = (struct dup_block *) e2fsck_allocate_memory(ctx,
+                         sizeof(struct dup_block), "duplicate block header");
+                db->num_bad = 0;
+                db->inode_list = 0;
+                dict_alloc_insert(&blk_dict, INT_TO_VOIDPTR(blk), db);
+        }
+        ino_el = (struct inode_el *) e2fsck_allocate_memory(ctx,
+                         sizeof(struct inode_el), "inode element");
+        ino_el->inode = ino;
+        ino_el->next = db->inode_list;
+        db->inode_list = ino_el;
+        db->num_bad++;
+
+        n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(ino));
+        if (n)
+                di = (struct dup_inode *) dnode_get(n);
+        else {
+                di = (struct dup_inode *) e2fsck_allocate_memory(ctx,
+                         sizeof(struct dup_inode), "duplicate inode header");
+                di->dir = (ino == EXT2_ROOT_INO) ? EXT2_ROOT_INO : 0 ;
+                di->num_dupblocks = 0;
+                di->block_list = 0;
+                di->inode = *inode;
+                dict_alloc_insert(&ino_dict, INT_TO_VOIDPTR(ino), di);
+        }
+        blk_el = (struct block_el *) e2fsck_allocate_memory(ctx,
+                         sizeof(struct block_el), "block element");
+        blk_el->block = blk;
+        blk_el->next = di->block_list;
+        di->block_list = blk_el;
+        di->num_dupblocks++;
+}
+
+/*
+ * Free a duplicate inode record
+ */
+static void inode_dnode_free(dnode_t *node,
+                             void *context EXT2FS_ATTR((unused)))
+{
+        struct dup_inode        *di;
+        struct block_el         *p, *next;
+
+        di = (struct dup_inode *) dnode_get(node);
+        for (p = di->block_list; p; p = next) {
+                next = p->next;
+                free(p);
+        }
+        free(node);
+}
+
+/*
+ * Free a duplicate block record
+ */
+static void block_dnode_free(dnode_t *node,
+                             void *context EXT2FS_ATTR((unused)))
+{
+        struct dup_block        *db;
+        struct inode_el         *p, *next;
+
+        db = (struct dup_block *) dnode_get(node);
+        for (p = db->inode_list; p; p = next) {
+                next = p->next;
+                free(p);
+        }
+        free(node);
+}
+
+
+/*
+ * Main procedure for handling duplicate blocks
+ */
+void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf)
+{
+        ext2_filsys             fs = ctx->fs;
+        struct problem_context  pctx;
+
+        clear_problem_context(&pctx);
+
+        pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
+                      _("multiply claimed inode map"), &inode_dup_map);
+        if (pctx.errcode) {
+                fix_problem(ctx, PR_1B_ALLOCATE_IBITMAP_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+
+        dict_init(&ino_dict, DICTCOUNT_T_MAX, dict_int_cmp);
+        dict_init(&blk_dict, DICTCOUNT_T_MAX, dict_int_cmp);
+        dict_set_allocator(&ino_dict, NULL, inode_dnode_free, NULL);
+        dict_set_allocator(&blk_dict, NULL, block_dnode_free, NULL);
+
+        pass1b(ctx, block_buf);
+        pass1c(ctx, block_buf);
+        pass1d(ctx, block_buf);
+
+        /*
+         * Time to free all of the accumulated data structures that we
+         * don't need anymore.
+         */
+        dict_free_nodes(&ino_dict);
+        dict_free_nodes(&blk_dict);
+}
+
+/*
+ * Scan the inodes looking for inodes that contain duplicate blocks.
+ */
+struct process_block_struct_1b {
+        e2fsck_t        ctx;
+        ext2_ino_t      ino;
+        int             dup_blocks;
+        struct ext2_inode *inode;
+        struct problem_context *pctx;
+};
+
+static void pass1b(e2fsck_t ctx, char *block_buf)
+{
+        ext2_filsys fs = ctx->fs;
+        ext2_ino_t ino;
+        struct ext2_inode inode;
+        ext2_inode_scan scan;
+        struct process_block_struct_1b pb;
+        struct problem_context pctx;
+
+        clear_problem_context(&pctx);
+
+        if (!(ctx->options & E2F_OPT_PREEN))
+                fix_problem(ctx, PR_1B_PASS_HEADER, &pctx);
+        pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks,
+                                              &scan);
+        if (pctx.errcode) {
+                fix_problem(ctx, PR_1B_ISCAN_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+        ctx->stashed_inode = &inode;
+        pb.ctx = ctx;
+        pb.pctx = &pctx;
+        pctx.str = "pass1b";
+        while (1) {
+                pctx.errcode = ext2fs_get_next_inode(scan, &ino, &inode);
+                if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE)
+                        continue;
+                if (pctx.errcode) {
+                        fix_problem(ctx, PR_1B_ISCAN_ERROR, &pctx);
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return;
+                }
+                if (!ino)
+                        break;
+                pctx.ino = ctx->stashed_ino = ino;
+                if ((ino != EXT2_BAD_INO) &&
+                    !ext2fs_test_inode_bitmap(ctx->inode_used_map, ino))
+                        continue;
+
+                pb.ino = ino;
+                pb.dup_blocks = 0;
+                pb.inode = &inode;
+
+                if (ext2fs_inode_has_valid_blocks(&inode) ||
+                    (ino == EXT2_BAD_INO))
+                        pctx.errcode = ext2fs_block_iterate2(fs, ino,
+                                     0, block_buf, process_pass1b_block, &pb);
+                if (inode.i_file_acl)
+                        process_pass1b_block(fs, &inode.i_file_acl,
+                                             BLOCK_COUNT_EXTATTR, 0, 0, &pb);
+                if (pb.dup_blocks) {
+                        end_problem_latch(ctx, PR_LATCH_DBLOCK);
+                        if (ino >= EXT2_FIRST_INODE(fs->super) ||
+                            ino == EXT2_ROOT_INO)
+                                dup_inode_count++;
+                }
+                if (pctx.errcode)
+                        fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx);
+        }
+        ext2fs_close_inode_scan(scan);
+        e2fsck_use_inode_shortcuts(ctx, 0);
+}
+
+static int process_pass1b_block(ext2_filsys fs EXT2FS_ATTR((unused)),
+                                blk_t   *block_nr,
+                                e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
+                                blk_t ref_blk EXT2FS_ATTR((unused)),
+                                int ref_offset EXT2FS_ATTR((unused)),
+                                void *priv_data)
+{
+        struct process_block_struct_1b *p;
+        e2fsck_t ctx;
+
+        if (HOLE_BLKADDR(*block_nr))
+                return 0;
+        p = (struct process_block_struct_1b *) priv_data;
+        ctx = p->ctx;
+
+        if (!ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr))
+                return 0;
+
+        /* OK, this is a duplicate block */
+        if (p->ino != EXT2_BAD_INO) {
+                p->pctx->blk = *block_nr;
+                fix_problem(ctx, PR_1B_DUP_BLOCK, p->pctx);
+        }
+        p->dup_blocks++;
+        ext2fs_mark_inode_bitmap(inode_dup_map, p->ino);
+
+        add_dupe(ctx, p->ino, *block_nr, p->inode);
+
+        return 0;
+}
+
+/*
+ * Pass 1c: Scan directories for inodes with duplicate blocks.  This
+ * is used so that we can print pathnames when prompting the user for
+ * what to do.
+ */
+struct search_dir_struct {
+        int             count;
+        ext2_ino_t      first_inode;
+        ext2_ino_t      max_inode;
+};
+
+static int search_dirent_proc(ext2_ino_t dir, int entry,
+                              struct ext2_dir_entry *dirent,
+                              int offset EXT2FS_ATTR((unused)),
+                              int blocksize EXT2FS_ATTR((unused)),
+                              char *buf EXT2FS_ATTR((unused)),
+                              void *priv_data)
+{
+        struct search_dir_struct *sd;
+        struct dup_inode        *p;
+        dnode_t                 *n;
+
+        sd = (struct search_dir_struct *) priv_data;
+
+        if (dirent->inode > sd->max_inode)
+                /* Should abort this inode, but not everything */
+                return 0;
+
+        if ((dirent->inode < sd->first_inode) || (entry < DIRENT_OTHER_FILE) ||
+            !ext2fs_test_inode_bitmap(inode_dup_map, dirent->inode))
+                return 0;
+
+        n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(dirent->inode));
+        if (!n)
+                return 0;
+        p = (struct dup_inode *) dnode_get(n);
+        p->dir = dir;
+        sd->count--;
+
+        return(sd->count ? 0 : DIRENT_ABORT);
+}
+
+
+static void pass1c(e2fsck_t ctx, char *block_buf)
+{
+        ext2_filsys fs = ctx->fs;
+        struct search_dir_struct sd;
+        struct problem_context pctx;
+
+        clear_problem_context(&pctx);
+
+        if (!(ctx->options & E2F_OPT_PREEN))
+                fix_problem(ctx, PR_1C_PASS_HEADER, &pctx);
+
+        /*
+         * Search through all directories to translate inodes to names
+         * (by searching for the containing directory for that inode.)
+         */
+        sd.count = dup_inode_count;
+        sd.first_inode = EXT2_FIRST_INODE(fs->super);
+        sd.max_inode = fs->super->s_inodes_count;
+        ext2fs_dblist_dir_iterate(fs->dblist, 0, block_buf,
+                                  search_dirent_proc, &sd);
+}
+
+static void pass1d(e2fsck_t ctx, char *block_buf)
+{
+        ext2_filsys fs = ctx->fs;
+        struct dup_inode        *p, *t;
+        struct dup_block        *q;
+        ext2_ino_t              *shared, ino;
+        int     shared_len;
+        int     i;
+        int     file_ok;
+        int     meta_data = 0;
+        struct problem_context pctx;
+        dnode_t *n, *m;
+        struct block_el *s;
+        struct inode_el *r;
+
+        clear_problem_context(&pctx);
+
+        if (!(ctx->options & E2F_OPT_PREEN))
+                fix_problem(ctx, PR_1D_PASS_HEADER, &pctx);
+        e2fsck_read_bitmaps(ctx);
+
+        pctx.num = dup_inode_count; /* dict_count(&ino_dict); */
+        fix_problem(ctx, PR_1D_NUM_DUP_INODES, &pctx);
+        shared = (ext2_ino_t *) e2fsck_allocate_memory(ctx,
+                                sizeof(ext2_ino_t) * dict_count(&ino_dict),
+                                "Shared inode list");
+        for (n = dict_first(&ino_dict); n; n = dict_next(&ino_dict, n)) {
+                p = (struct dup_inode *) dnode_get(n);
+                shared_len = 0;
+                file_ok = 1;
+                ino = (ext2_ino_t)VOIDPTR_TO_INT(dnode_getkey(n));
+                if (ino == EXT2_BAD_INO)
+                        continue;
+
+                /*
+                 * Find all of the inodes which share blocks with this
+                 * one.  First we find all of the duplicate blocks
+                 * belonging to this inode, and then search each block
+                 * get the list of inodes, and merge them together.
+                 */
+                for (s = p->block_list; s; s = s->next) {
+                        m = dict_lookup(&blk_dict, INT_TO_VOIDPTR(s->block));
+                        if (!m)
+                                continue; /* Should never happen... */
+                        q = (struct dup_block *) dnode_get(m);
+                        if (q->num_bad > 1)
+                                file_ok = 0;
+                        if (check_if_fs_block(ctx, s->block)) {
+                                file_ok = 0;
+                                meta_data = 1;
+                        }
+
+                        /*
+                         * Add all inodes used by this block to the
+                         * shared[] --- which is a unique list, so
+                         * if an inode is already in shared[], don't
+                         * add it again.
+                         */
+                        for (r = q->inode_list; r; r = r->next) {
+                                if (r->inode == ino)
+                                        continue;
+                                for (i = 0; i < shared_len; i++)
+                                        if (shared[i] == r->inode)
+                                                break;
+                                if (i == shared_len) {
+                                        shared[shared_len++] = r->inode;
+                                }
+                        }
+                }
+
+                /*
+                 * Report the inode that we are working on
+                 */
+                pctx.inode = &p->inode;
+                pctx.ino = ino;
+                pctx.dir = p->dir;
+                pctx.blkcount = p->num_dupblocks;
+                pctx.num = meta_data ? shared_len+1 : shared_len;
+                fix_problem(ctx, PR_1D_DUP_FILE, &pctx);
+                pctx.blkcount = 0;
+                pctx.num = 0;
+
+                if (meta_data)
+                        fix_problem(ctx, PR_1D_SHARE_METADATA, &pctx);
+
+                for (i = 0; i < shared_len; i++) {
+                        m = dict_lookup(&ino_dict, INT_TO_VOIDPTR(shared[i]));
+                        if (!m)
+                                continue; /* should never happen */
+                        t = (struct dup_inode *) dnode_get(m);
+                        /*
+                         * Report the inode that we are sharing with
+                         */
+                        pctx.inode = &t->inode;
+                        pctx.ino = shared[i];
+                        pctx.dir = t->dir;
+                        fix_problem(ctx, PR_1D_DUP_FILE_LIST, &pctx);
+                }
+                if (file_ok) {
+                        fix_problem(ctx, PR_1D_DUP_BLOCKS_DEALT, &pctx);
+                        continue;
+                }
+                if (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))
+                        delete_file(ctx, ino, p, block_buf);
+                else
+                        ext2fs_unmark_valid(fs);
+        }
+        ext2fs_free_mem(&shared);
+}
+
+/*
+ * Drop the refcount on the dup_block structure, and clear the entry
+ * in the block_dup_map if appropriate.
+ */
+static void decrement_badcount(e2fsck_t ctx, blk_t block, struct dup_block *p)
+{
+        p->num_bad--;
+        if (p->num_bad <= 0 ||
+            (p->num_bad == 1 && !check_if_fs_block(ctx, block)))
+                ext2fs_unmark_block_bitmap(ctx->block_dup_map, block);
+}
+
+static int delete_file_block(ext2_filsys fs,
+                             blk_t      *block_nr,
+                             e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
+                             blk_t ref_block EXT2FS_ATTR((unused)),
+                             int ref_offset EXT2FS_ATTR((unused)),
+                             void *priv_data)
+{
+        struct process_block_struct_1b *pb;
+        struct dup_block *p;
+        dnode_t *n;
+        e2fsck_t ctx;
+
+        pb = (struct process_block_struct_1b *) priv_data;
+        ctx = pb->ctx;
+
+        if (HOLE_BLKADDR(*block_nr))
+                return 0;
+
+        if (ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr)) {
+                n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(*block_nr));
+                if (n) {
+                        p = (struct dup_block *) dnode_get(n);
+                        decrement_badcount(ctx, *block_nr, p);
+                } else
+                        com_err("delete_file_block", 0,
+                            _("internal error; can't find dup_blk for %d\n"),
+                                *block_nr);
+        } else {
+                ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr);
+                ext2fs_block_alloc_stats(fs, *block_nr, -1);
+        }
+
+        return 0;
+}
+
+static void delete_file(e2fsck_t ctx, ext2_ino_t ino,
+                        struct dup_inode *dp, char* block_buf)
+{
+        ext2_filsys fs = ctx->fs;
+        struct process_block_struct_1b pb;
+        struct ext2_inode       inode;
+        struct problem_context  pctx;
+        unsigned int            count;
+
+        clear_problem_context(&pctx);
+        pctx.ino = pb.ino = ino;
+        pb.dup_blocks = dp->num_dupblocks;
+        pb.ctx = ctx;
+        pctx.str = "delete_file";
+
+        e2fsck_read_inode(ctx, ino, &inode, "delete_file");
+        if (ext2fs_inode_has_valid_blocks(&inode))
+                pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf,
+                                                     delete_file_block, &pb);
+        if (pctx.errcode)
+                fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx);
+        ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
+        ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
+        if (ctx->inode_bad_map)
+                ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino);
+        ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode));
+
+        /* Inode may have changed by block_iterate, so reread it */
+        e2fsck_read_inode(ctx, ino, &inode, "delete_file");
+        inode.i_links_count = 0;
+        inode.i_dtime = time(0);
+        if (inode.i_file_acl &&
+            (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) {
+                count = 1;
+                pctx.errcode = ext2fs_adjust_ea_refcount(fs, inode.i_file_acl,
+                                                   block_buf, -1, &count);
+                if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) {
+                        pctx.errcode = 0;
+                        count = 1;
+                }
+                if (pctx.errcode) {
+                        pctx.blk = inode.i_file_acl;
+                        fix_problem(ctx, PR_1B_ADJ_EA_REFCOUNT, &pctx);
+                }
+                /*
+                 * If the count is zero, then arrange to have the
+                 * block deleted.  If the block is in the block_dup_map,
+                 * also call delete_file_block since it will take care
+                 * of keeping the accounting straight.
+                 */
+                if ((count == 0) ||
+                    ext2fs_test_block_bitmap(ctx->block_dup_map,
+                                             inode.i_file_acl))
+                        delete_file_block(fs, &inode.i_file_acl,
+                                          BLOCK_COUNT_EXTATTR, 0, 0, &pb);
+        }
+        e2fsck_write_inode(ctx, ino, &inode, "delete_file");
+}
+
+struct clone_struct {
+        errcode_t       errcode;
+        ext2_ino_t      dir;
+        char    *buf;
+        e2fsck_t ctx;
+};
+
+static int clone_file_block(ext2_filsys fs,
+                            blk_t       *block_nr,
+                            e2_blkcnt_t blockcnt,
+                            blk_t ref_block EXT2FS_ATTR((unused)),
+                            int ref_offset EXT2FS_ATTR((unused)),
+                            void *priv_data)
+{
+        struct dup_block *p;
+        blk_t   new_block;
+        errcode_t       retval;
+        struct clone_struct *cs = (struct clone_struct *) priv_data;
+        dnode_t *n;
+        e2fsck_t ctx;
+
+        ctx = cs->ctx;
+
+        if (HOLE_BLKADDR(*block_nr))
+                return 0;
+
+        if (ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr)) {
+                n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(*block_nr));
+                if (n) {
+                        p = (struct dup_block *) dnode_get(n);
+                        retval = ext2fs_new_block(fs, 0, ctx->block_found_map,
+                                                  &new_block);
+                        if (retval) {
+                                cs->errcode = retval;
+                                return BLOCK_ABORT;
+                        }
+                        if (cs->dir && (blockcnt >= 0)) {
+                                retval = ext2fs_set_dir_block(fs->dblist,
+                                      cs->dir, new_block, blockcnt);
+                                if (retval) {
+                                        cs->errcode = retval;
+                                        return BLOCK_ABORT;
+                                }
+                        }
+#if 0
+                        printf("Cloning block %u to %u\n", *block_nr,
+                               new_block);
+#endif
+                        retval = io_channel_read_blk(fs->io, *block_nr, 1,
+                                                     cs->buf);
+                        if (retval) {
+                                cs->errcode = retval;
+                                return BLOCK_ABORT;
+                        }
+                        retval = io_channel_write_blk(fs->io, new_block, 1,
+                                                      cs->buf);
+                        if (retval) {
+                                cs->errcode = retval;
+                                return BLOCK_ABORT;
+                        }
+                        decrement_badcount(ctx, *block_nr, p);
+                        *block_nr = new_block;
+                        ext2fs_mark_block_bitmap(ctx->block_found_map,
+                                                 new_block);
+                        ext2fs_mark_block_bitmap(fs->block_map, new_block);
+                        return BLOCK_CHANGED;
+                } else
+                        com_err("clone_file_block", 0,
+                            _("internal error; can't find dup_blk for %d\n"),
+                                *block_nr);
+        }
+        return 0;
+}
+
+static int clone_file(e2fsck_t ctx, ext2_ino_t ino,
+                      struct dup_inode *dp, char* block_buf)
+{
+        ext2_filsys fs = ctx->fs;
+        errcode_t       retval;
+        struct clone_struct cs;
+        struct problem_context  pctx;
+        blk_t           blk;
+        dnode_t         *n;
+        struct inode_el *ino_el;
+        struct dup_block        *db;
+        struct dup_inode        *di;
+
+        clear_problem_context(&pctx);
+        cs.errcode = 0;
+        cs.dir = 0;
+        cs.ctx = ctx;
+        retval = ext2fs_get_mem(fs->blocksize, &cs.buf);
+        if (retval)
+                return retval;
+
+        if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, ino))
+                cs.dir = ino;
+
+        pctx.ino = ino;
+        pctx.str = "clone_file";
+        if (ext2fs_inode_has_valid_blocks(&dp->inode))
+                pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf,
+                                                     clone_file_block, &cs);
+        ext2fs_mark_bb_dirty(fs);
+        if (pctx.errcode) {
+                fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx);
+                retval = pctx.errcode;
+                goto errout;
+        }
+        if (cs.errcode) {
+                com_err("clone_file", cs.errcode,
+                        _("returned from clone_file_block"));
+                retval = cs.errcode;
+                goto errout;
+        }
+        /* The inode may have changed on disk, so we have to re-read it */
+        e2fsck_read_inode(ctx, ino, &dp->inode, "clone file EA");
+        blk = dp->inode.i_file_acl;
+        if (blk && (clone_file_block(fs, &dp->inode.i_file_acl,
+                                     BLOCK_COUNT_EXTATTR, 0, 0, &cs) ==
+                    BLOCK_CHANGED)) {
+                e2fsck_write_inode(ctx, ino, &dp->inode, "clone file EA");
+                /*
+                 * If we cloned the EA block, find all other inodes
+                 * which refered to that EA block, and modify
+                 * them to point to the new EA block.
+                 */
+                n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(blk));
+                db = (struct dup_block *) dnode_get(n);
+                for (ino_el = db->inode_list; ino_el; ino_el = ino_el->next) {
+                        if (ino_el->inode == ino)
+                                continue;
+                        n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(ino_el->inode));
+                        di = (struct dup_inode *) dnode_get(n);
+                        if (di->inode.i_file_acl == blk) {
+                                di->inode.i_file_acl = dp->inode.i_file_acl;
+                                e2fsck_write_inode(ctx, ino_el->inode,
+                                           &di->inode, "clone file EA");
+                                decrement_badcount(ctx, blk, db);
+                        }
+                }
+        }
+        retval = 0;
+errout:
+        ext2fs_free_mem(&cs.buf);
+        return retval;
+}
+
+/*
+ * This routine returns 1 if a block overlaps with one of the superblocks,
+ * group descriptors, inode bitmaps, or block bitmaps.
+ */
+static int check_if_fs_block(e2fsck_t ctx, blk_t test_block)
+{
+        ext2_filsys fs = ctx->fs;
+        blk_t   block;
+        dgrp_t  i;
+
+        block = fs->super->s_first_data_block;
+        for (i = 0; i < fs->group_desc_count; i++) {
+
+                /* Check superblocks/block group descriptros */
+                if (ext2fs_bg_has_super(fs, i)) {
+                        if (test_block >= block &&
+                            (test_block <= block + fs->desc_blocks))
+                                return 1;
+                }
+
+                /* Check the inode table */
+                if ((fs->group_desc[i].bg_inode_table) &&
+                    (test_block >= fs->group_desc[i].bg_inode_table) &&
+                    (test_block < (fs->group_desc[i].bg_inode_table +
+                                   fs->inode_blocks_per_group)))
+                        return 1;
+
+                /* Check the bitmap blocks */
+                if ((test_block == fs->group_desc[i].bg_block_bitmap) ||
+                    (test_block == fs->group_desc[i].bg_inode_bitmap))
+                        return 1;
+
+                block += fs->super->s_blocks_per_group;
+        }
+        return 0;
+}
+/*
+ * pass2.c --- check directory structure
+ *
+ * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ *
+ * Pass 2 of e2fsck iterates through all active directory inodes, and
+ * applies to following tests to each directory entry in the directory
+ * blocks in the inodes:
+ *
+ *      - The length of the directory entry (rec_len) should be at
+ *              least 8 bytes, and no more than the remaining space
+ *              left in the directory block.
+ *      - The length of the name in the directory entry (name_len)
+ *              should be less than (rec_len - 8).
+ *      - The inode number in the directory entry should be within
+ *              legal bounds.
+ *      - The inode number should refer to a in-use inode.
+ *      - The first entry should be '.', and its inode should be
+ *              the inode of the directory.
+ *      - The second entry should be '..'.
+ *
+ * To minimize disk seek time, the directory blocks are processed in
+ * sorted order of block numbers.
+ *
+ * Pass 2 also collects the following information:
+ *      - The inode numbers of the subdirectories for each directory.
+ *
+ * Pass 2 relies on the following information from previous passes:
+ *      - The directory information collected in pass 1.
+ *      - The inode_used_map bitmap
+ *      - The inode_bad_map bitmap
+ *      - The inode_dir_map bitmap
+ *
+ * Pass 2 frees the following data structures
+ *      - The inode_bad_map bitmap
+ *      - The inode_reg_map bitmap
+ */
+
+/* #define DX_DEBUG */
+
+/*
+ * Keeps track of how many times an inode is referenced.
+ */
+static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf);
+static int check_dir_block(ext2_filsys fs,
+                           struct ext2_db_entry *dir_blocks_info,
+                           void *priv_data);
+static int allocate_dir_block(e2fsck_t ctx,
+                              struct ext2_db_entry *dir_blocks_info,
+                              char *buf, struct problem_context *pctx);
+static int update_dir_block(ext2_filsys fs,
+                            blk_t       *block_nr,
+                            e2_blkcnt_t blockcnt,
+                            blk_t       ref_block,
+                            int         ref_offset,
+                            void        *priv_data);
+static void clear_htree(e2fsck_t ctx, ext2_ino_t ino);
+static int htree_depth(struct dx_dir_info *dx_dir,
+                       struct dx_dirblock_info *dx_db);
+static EXT2_QSORT_TYPE special_dir_block_cmp(const void *a, const void *b);
+
+struct check_dir_struct {
+        char *buf;
+        struct problem_context  pctx;
+        int     count, max;
+        e2fsck_t ctx;
+};
+
+void e2fsck_pass2(e2fsck_t ctx)
+{
+        struct ext2_super_block *sb = ctx->fs->super;
+        struct problem_context  pctx;
+        ext2_filsys             fs = ctx->fs;
+        char                    *buf;
+#ifdef RESOURCE_TRACK
+        struct resource_track   rtrack;
+#endif
+        struct dir_info         *dir;
+        struct check_dir_struct cd;
+        struct dx_dir_info      *dx_dir;
+        struct dx_dirblock_info *dx_db, *dx_parent;
+        int                     b;
+        int                     i, depth;
+        problem_t               code;
+        int                     bad_dir;
+
+#ifdef RESOURCE_TRACK
+        init_resource_track(&rtrack);
+#endif
+
+        clear_problem_context(&cd.pctx);
+
+#ifdef MTRACE
+        mtrace_print("Pass 2");
+#endif
+
+        if (!(ctx->options & E2F_OPT_PREEN))
+                fix_problem(ctx, PR_2_PASS_HEADER, &cd.pctx);
+
+        cd.pctx.errcode = ext2fs_create_icount2(fs, EXT2_ICOUNT_OPT_INCREMENT,
+                                                0, ctx->inode_link_info,
+                                                &ctx->inode_count);
+        if (cd.pctx.errcode) {
+                fix_problem(ctx, PR_2_ALLOCATE_ICOUNT, &cd.pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+        buf = (char *) e2fsck_allocate_memory(ctx, 2*fs->blocksize,
+                                              "directory scan buffer");
+
+        /*
+         * Set up the parent pointer for the root directory, if
+         * present.  (If the root directory is not present, we will
+         * create it in pass 3.)
+         */
+        dir = e2fsck_get_dir_info(ctx, EXT2_ROOT_INO);
+        if (dir)
+                dir->parent = EXT2_ROOT_INO;
+
+        cd.buf = buf;
+        cd.ctx = ctx;
+        cd.count = 1;
+        cd.max = ext2fs_dblist_count(fs->dblist);
+
+        if (ctx->progress)
+                (void) (ctx->progress)(ctx, 2, 0, cd.max);
+
+        if (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX)
+                ext2fs_dblist_sort(fs->dblist, special_dir_block_cmp);
+
+        cd.pctx.errcode = ext2fs_dblist_iterate(fs->dblist, check_dir_block,
+                                                &cd);
+        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                return;
+        if (cd.pctx.errcode) {
+                fix_problem(ctx, PR_2_DBLIST_ITERATE, &cd.pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+
+#ifdef ENABLE_HTREE
+        for (i=0; (dx_dir = e2fsck_dx_dir_info_iter(ctx, &i)) != 0;) {
+                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                        return;
+                if (dx_dir->numblocks == 0)
+                        continue;
+                clear_problem_context(&pctx);
+                bad_dir = 0;
+                pctx.dir = dx_dir->ino;
+                dx_db = dx_dir->dx_block;
+                if (dx_db->flags & DX_FLAG_REFERENCED)
+                        dx_db->flags |= DX_FLAG_DUP_REF;
+                else
+                        dx_db->flags |= DX_FLAG_REFERENCED;
+                /*
+                 * Find all of the first and last leaf blocks, and
+                 * update their parent's min and max hash values
+                 */
+                for (b=0, dx_db = dx_dir->dx_block;
+                     b < dx_dir->numblocks;
+                     b++, dx_db++) {
+                        if ((dx_db->type != DX_DIRBLOCK_LEAF) ||
+                            !(dx_db->flags & (DX_FLAG_FIRST | DX_FLAG_LAST)))
+                                continue;
+                        dx_parent = &dx_dir->dx_block[dx_db->parent];
+                        /*
+                         * XXX Make sure dx_parent->min_hash > dx_db->min_hash
+                         */
+                        if (dx_db->flags & DX_FLAG_FIRST)
+                                dx_parent->min_hash = dx_db->min_hash;
+                        /*
+                         * XXX Make sure dx_parent->max_hash < dx_db->max_hash
+                         */
+                        if (dx_db->flags & DX_FLAG_LAST)
+                                dx_parent->max_hash = dx_db->max_hash;
+                }
+
+                for (b=0, dx_db = dx_dir->dx_block;
+                     b < dx_dir->numblocks;
+                     b++, dx_db++) {
+                        pctx.blkcount = b;
+                        pctx.group = dx_db->parent;
+                        code = 0;
+                        if (!(dx_db->flags & DX_FLAG_FIRST) &&
+                            (dx_db->min_hash < dx_db->node_min_hash)) {
+                                pctx.blk = dx_db->min_hash;
+                                pctx.blk2 = dx_db->node_min_hash;
+                                code = PR_2_HTREE_MIN_HASH;
+                                fix_problem(ctx, code, &pctx);
+                                bad_dir++;
+                        }
+                        if (dx_db->type == DX_DIRBLOCK_LEAF) {
+                                depth = htree_depth(dx_dir, dx_db);
+                                if (depth != dx_dir->depth) {
+                                        code = PR_2_HTREE_BAD_DEPTH;
+                                        fix_problem(ctx, code, &pctx);
+                                        bad_dir++;
+                                }
+                        }
+                        /*
+                         * This test doesn't apply for the root block
+                         * at block #0
+                         */
+                        if (b &&
+                            (dx_db->max_hash > dx_db->node_max_hash)) {
+                                pctx.blk = dx_db->max_hash;
+                                pctx.blk2 = dx_db->node_max_hash;
+                                code = PR_2_HTREE_MAX_HASH;
+                                fix_problem(ctx, code, &pctx);
+                                bad_dir++;
+                        }
+                        if (!(dx_db->flags & DX_FLAG_REFERENCED)) {
+                                code = PR_2_HTREE_NOTREF;
+                                fix_problem(ctx, code, &pctx);
+                                bad_dir++;
+                        } else if (dx_db->flags & DX_FLAG_DUP_REF) {
+                                code = PR_2_HTREE_DUPREF;
+                                fix_problem(ctx, code, &pctx);
+                                bad_dir++;
+                        }
+                        if (code == 0)
+                                continue;
+                }
+                if (bad_dir && fix_problem(ctx, PR_2_HTREE_CLEAR, &pctx)) {
+                        clear_htree(ctx, dx_dir->ino);
+                        dx_dir->numblocks = 0;
+                }
+        }
+#endif
+        ext2fs_free_mem(&buf);
+        ext2fs_free_dblist(fs->dblist);
+
+        if (ctx->inode_bad_map) {
+                ext2fs_free_inode_bitmap(ctx->inode_bad_map);
+                ctx->inode_bad_map = 0;
+        }
+        if (ctx->inode_reg_map) {
+                ext2fs_free_inode_bitmap(ctx->inode_reg_map);
+                ctx->inode_reg_map = 0;
+        }
+
+        clear_problem_context(&pctx);
+        if (ctx->large_files) {
+                if (!(sb->s_feature_ro_compat &
+                      EXT2_FEATURE_RO_COMPAT_LARGE_FILE) &&
+                    fix_problem(ctx, PR_2_FEATURE_LARGE_FILES, &pctx)) {
+                        sb->s_feature_ro_compat |=
+                                EXT2_FEATURE_RO_COMPAT_LARGE_FILE;
+                        ext2fs_mark_super_dirty(fs);
+                }
+                if (sb->s_rev_level == EXT2_GOOD_OLD_REV &&
+                    fix_problem(ctx, PR_1_FS_REV_LEVEL, &pctx)) {
+                        ext2fs_update_dynamic_rev(fs);
+                        ext2fs_mark_super_dirty(fs);
+                }
+        } else if (!ctx->large_files &&
+            (sb->s_feature_ro_compat &
+              EXT2_FEATURE_RO_COMPAT_LARGE_FILE)) {
+                if (fs->flags & EXT2_FLAG_RW) {
+                        sb->s_feature_ro_compat &=
+                                ~EXT2_FEATURE_RO_COMPAT_LARGE_FILE;
+                        ext2fs_mark_super_dirty(fs);
+                }
+        }
+
+#ifdef RESOURCE_TRACK
+        if (ctx->options & E2F_OPT_TIME2) {
+                e2fsck_clear_progbar(ctx);
+                print_resource_track(_("Pass 2"), &rtrack);
+        }
+#endif
+}
+
+#define MAX_DEPTH 32000
+static int htree_depth(struct dx_dir_info *dx_dir,
+                       struct dx_dirblock_info *dx_db)
+{
+        int     depth = 0;
+
+        while (dx_db->type != DX_DIRBLOCK_ROOT && depth < MAX_DEPTH) {
+                dx_db = &dx_dir->dx_block[dx_db->parent];
+                depth++;
+        }
+        return depth;
+}
+
+static int dict_de_cmp(const void *a, const void *b)
+{
+        const struct ext2_dir_entry *de_a, *de_b;
+        int     a_len, b_len;
+
+        de_a = (const struct ext2_dir_entry *) a;
+        a_len = de_a->name_len & 0xFF;
+        de_b = (const struct ext2_dir_entry *) b;
+        b_len = de_b->name_len & 0xFF;
+
+        if (a_len != b_len)
+                return (a_len - b_len);
+
+        return strncmp(de_a->name, de_b->name, a_len);
+}
+
+/*
+ * This is special sort function that makes sure that directory blocks
+ * with a dirblock of zero are sorted to the beginning of the list.
+ * This guarantees that the root node of the htree directories are
+ * processed first, so we know what hash version to use.
+ */
+static EXT2_QSORT_TYPE special_dir_block_cmp(const void *a, const void *b)
+{
+        const struct ext2_db_entry *db_a =
+                (const struct ext2_db_entry *) a;
+        const struct ext2_db_entry *db_b =
+                (const struct ext2_db_entry *) b;
+
+        if (db_a->blockcnt && !db_b->blockcnt)
+                return 1;
+
+        if (!db_a->blockcnt && db_b->blockcnt)
+                return -1;
+
+        if (db_a->blk != db_b->blk)
+                return (int) (db_a->blk - db_b->blk);
+
+        if (db_a->ino != db_b->ino)
+                return (int) (db_a->ino - db_b->ino);
+
+        return (int) (db_a->blockcnt - db_b->blockcnt);
+}
+
+
+/*
+ * Make sure the first entry in the directory is '.', and that the
+ * directory entry is sane.
+ */
+static int check_dot(e2fsck_t ctx,
+                     struct ext2_dir_entry *dirent,
+                     ext2_ino_t ino, struct problem_context *pctx)
+{
+        struct ext2_dir_entry *nextdir;
+        int     status = 0;
+        int     created = 0;
+        int     new_len;
+        int     problem = 0;
+
+        if (!dirent->inode)
+                problem = PR_2_MISSING_DOT;
+        else if (((dirent->name_len & 0xFF) != 1) ||
+                 (dirent->name[0] != '.'))
+                problem = PR_2_1ST_NOT_DOT;
+        else if (dirent->name[1] != '\0')
+                problem = PR_2_DOT_NULL_TERM;
+
+        if (problem) {
+                if (fix_problem(ctx, problem, pctx)) {
+                        if (dirent->rec_len < 12)
+                                dirent->rec_len = 12;
+                        dirent->inode = ino;
+                        dirent->name_len = 1;
+                        dirent->name[0] = '.';
+                        dirent->name[1] = '\0';
+                        status = 1;
+                        created = 1;
+                }
+        }
+        if (dirent->inode != ino) {
+                if (fix_problem(ctx, PR_2_BAD_INODE_DOT, pctx)) {
+                        dirent->inode = ino;
+                        status = 1;
+                }
+        }
+        if (dirent->rec_len > 12) {
+                new_len = dirent->rec_len - 12;
+                if (new_len > 12) {
+                        if (created ||
+                            fix_problem(ctx, PR_2_SPLIT_DOT, pctx)) {
+                                nextdir = (struct ext2_dir_entry *)
+                                        ((char *) dirent + 12);
+                                dirent->rec_len = 12;
+                                nextdir->rec_len = new_len;
+                                nextdir->inode = 0;
+                                nextdir->name_len = 0;
+                                status = 1;
+                        }
+                }
+        }
+        return status;
+}
+
+/*
+ * Make sure the second entry in the directory is '..', and that the
+ * directory entry is sane.  We do not check the inode number of '..'
+ * here; this gets done in pass 3.
+ */
+static int check_dotdot(e2fsck_t ctx,
+                        struct ext2_dir_entry *dirent,
+                        struct dir_info *dir, struct problem_context *pctx)
+{
+        int             problem = 0;
+
+        if (!dirent->inode)
+                problem = PR_2_MISSING_DOT_DOT;
+        else if (((dirent->name_len & 0xFF) != 2) ||
+                 (dirent->name[0] != '.') ||
+                 (dirent->name[1] != '.'))
+                problem = PR_2_2ND_NOT_DOT_DOT;
+        else if (dirent->name[2] != '\0')
+                problem = PR_2_DOT_DOT_NULL_TERM;
+
+        if (problem) {
+                if (fix_problem(ctx, problem, pctx)) {
+                        if (dirent->rec_len < 12)
+                                dirent->rec_len = 12;
+                        /*
+                         * Note: we don't have the parent inode just
+                         * yet, so we will fill it in with the root
+                         * inode.  This will get fixed in pass 3.
+                         */
+                        dirent->inode = EXT2_ROOT_INO;
+                        dirent->name_len = 2;
+                        dirent->name[0] = '.';
+                        dirent->name[1] = '.';
+                        dirent->name[2] = '\0';
+                        return 1;
+                }
+                return 0;
+        }
+        dir->dotdot = dirent->inode;
+        return 0;
+}
+
+/*
+ * Check to make sure a directory entry doesn't contain any illegal
+ * characters.
+ */
+static int check_name(e2fsck_t ctx,
+                      struct ext2_dir_entry *dirent,
+                      ext2_ino_t dir_ino EXT2FS_ATTR((unused)),
+                      struct problem_context *pctx)
+{
+        int     i;
+        int     fixup = -1;
+        int     ret = 0;
+
+        for ( i = 0; i < (dirent->name_len & 0xFF); i++) {
+                if (dirent->name[i] == '/' || dirent->name[i] == '\0') {
+                        if (fixup < 0) {
+                                fixup = fix_problem(ctx, PR_2_BAD_NAME, pctx);
+                        }
+                        if (fixup) {
+                                dirent->name[i] = '.';
+                                ret = 1;
+                        }
+                }
+        }
+        return ret;
+}
+
+/*
+ * Check the directory filetype (if present)
+ */
+static _INLINE_ int check_filetype(e2fsck_t ctx,
+                                   struct ext2_dir_entry *dirent,
+                                   ext2_ino_t dir_ino EXT2FS_ATTR((unused)),
+                                   struct problem_context *pctx)
+{
+        int     filetype = dirent->name_len >> 8;
+        int     should_be = EXT2_FT_UNKNOWN;
+        struct ext2_inode       inode;
+
+        if (!(ctx->fs->super->s_feature_incompat &
+              EXT2_FEATURE_INCOMPAT_FILETYPE)) {
+                if (filetype == 0 ||
+                    !fix_problem(ctx, PR_2_CLEAR_FILETYPE, pctx))
+                        return 0;
+                dirent->name_len = dirent->name_len & 0xFF;
+                return 1;
+        }
+
+        if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, dirent->inode)) {
+                should_be = EXT2_FT_DIR;
+        } else if (ext2fs_test_inode_bitmap(ctx->inode_reg_map,
+                                            dirent->inode)) {
+                should_be = EXT2_FT_REG_FILE;
+        } else if (ctx->inode_bad_map &&
+                   ext2fs_test_inode_bitmap(ctx->inode_bad_map,
+                                            dirent->inode))
+                should_be = 0;
+        else {
+                e2fsck_read_inode(ctx, dirent->inode, &inode,
+                                  "check_filetype");
+                should_be = ext2_file_type(inode.i_mode);
+        }
+        if (filetype == should_be)
+                return 0;
+        pctx->num = should_be;
+
+        if (fix_problem(ctx, filetype ? PR_2_BAD_FILETYPE : PR_2_SET_FILETYPE,
+                        pctx) == 0)
+                return 0;
+
+        dirent->name_len = (dirent->name_len & 0xFF) | should_be << 8;
+        return 1;
+}
+
+#ifdef ENABLE_HTREE
+static void parse_int_node(ext2_filsys fs,
+                           struct ext2_db_entry *db,
+                           struct check_dir_struct *cd,
+                           struct dx_dir_info   *dx_dir,
+                           char *block_buf)
+{
+        struct          ext2_dx_root_info  *root;
+        struct          ext2_dx_entry *ent;
+        struct          ext2_dx_countlimit *limit;
+        struct dx_dirblock_info *dx_db;
+        int             i, expect_limit, count;
+        blk_t           blk;
+        ext2_dirhash_t  min_hash = 0xffffffff;
+        ext2_dirhash_t  max_hash = 0;
+        ext2_dirhash_t  hash = 0, prev_hash;
+
+        if (db->blockcnt == 0) {
+                root = (struct ext2_dx_root_info *) (block_buf + 24);
+
+#ifdef DX_DEBUG
+                printf("Root node dump:\n");
+                printf("\t Reserved zero: %d\n", root->reserved_zero);
+                printf("\t Hash Version: %d\n", root->hash_version);
+                printf("\t Info length: %d\n", root->info_length);
+                printf("\t Indirect levels: %d\n", root->indirect_levels);
+                printf("\t Flags: %d\n", root->unused_flags);
+#endif
+
+                ent = (struct ext2_dx_entry *) (block_buf + 24 + root->info_length);
+        } else {
+                ent = (struct ext2_dx_entry *) (block_buf+8);
+        }
+        limit = (struct ext2_dx_countlimit *) ent;
+
+#ifdef DX_DEBUG
+        printf("Number of entries (count): %d\n",
+               ext2fs_le16_to_cpu(limit->count));
+        printf("Number of entries (limit): %d\n",
+               ext2fs_le16_to_cpu(limit->limit));
+#endif
+
+        count = ext2fs_le16_to_cpu(limit->count);
+        expect_limit = (fs->blocksize - ((char *) ent - block_buf)) /
+                sizeof(struct ext2_dx_entry);
+        if (ext2fs_le16_to_cpu(limit->limit) != expect_limit) {
+                cd->pctx.num = ext2fs_le16_to_cpu(limit->limit);
+                if (fix_problem(cd->ctx, PR_2_HTREE_BAD_LIMIT, &cd->pctx))
+                        goto clear_and_exit;
+        }
+        if (count > expect_limit) {
+                cd->pctx.num = count;
+                if (fix_problem(cd->ctx, PR_2_HTREE_BAD_COUNT, &cd->pctx))
+                        goto clear_and_exit;
+                count = expect_limit;
+        }
+
+        for (i=0; i < count; i++) {
+                prev_hash = hash;
+                hash = i ? (ext2fs_le32_to_cpu(ent[i].hash) & ~1) : 0;
+#ifdef DX_DEBUG
+                printf("Entry #%d: Hash 0x%08x, block %d\n", i,
+                       hash, ext2fs_le32_to_cpu(ent[i].block));
+#endif
+                blk = ext2fs_le32_to_cpu(ent[i].block) & 0x0ffffff;
+                /* Check to make sure the block is valid */
+                if (blk > (blk_t) dx_dir->numblocks) {
+                        cd->pctx.blk = blk;
+                        if (fix_problem(cd->ctx, PR_2_HTREE_BADBLK,
+                                        &cd->pctx))
+                                goto clear_and_exit;
+                }
+                if (hash < prev_hash &&
+                    fix_problem(cd->ctx, PR_2_HTREE_HASH_ORDER, &cd->pctx))
+                        goto clear_and_exit;
+                dx_db = &dx_dir->dx_block[blk];
+                if (dx_db->flags & DX_FLAG_REFERENCED) {
+                        dx_db->flags |= DX_FLAG_DUP_REF;
+                } else {
+                        dx_db->flags |= DX_FLAG_REFERENCED;
+                        dx_db->parent = db->blockcnt;
+                }
+                if (hash < min_hash)
+                        min_hash = hash;
+                if (hash > max_hash)
+                        max_hash = hash;
+                dx_db->node_min_hash = hash;
+                if ((i+1) < count)
+                        dx_db->node_max_hash =
+                          ext2fs_le32_to_cpu(ent[i+1].hash) & ~1;
+                else {
+                        dx_db->node_max_hash = 0xfffffffe;
+                        dx_db->flags |= DX_FLAG_LAST;
+                }
+                if (i == 0)
+                        dx_db->flags |= DX_FLAG_FIRST;
+        }
+#ifdef DX_DEBUG
+        printf("Blockcnt = %d, min hash 0x%08x, max hash 0x%08x\n",
+               db->blockcnt, min_hash, max_hash);
+#endif
+        dx_db = &dx_dir->dx_block[db->blockcnt];
+        dx_db->min_hash = min_hash;
+        dx_db->max_hash = max_hash;
+        return;
+
+clear_and_exit:
+        clear_htree(cd->ctx, cd->pctx.ino);
+        dx_dir->numblocks = 0;
+}
+#endif /* ENABLE_HTREE */
+
+/*
+ * Given a busted directory, try to salvage it somehow.
+ *
+ */
+static void salvage_directory(ext2_filsys fs,
+                              struct ext2_dir_entry *dirent,
+                              struct ext2_dir_entry *prev,
+                              unsigned int *offset)
+{
+        char    *cp = (char *) dirent;
+        int left = fs->blocksize - *offset - dirent->rec_len;
+        int name_len = dirent->name_len & 0xFF;
+
+        /*
+         * Special case of directory entry of size 8: copy what's left
+         * of the directory block up to cover up the invalid hole.
+         */
+        if ((left >= 12) && (dirent->rec_len == 8)) {
+                memmove(cp, cp+8, left);
+                memset(cp + left, 0, 8);
+                return;
+        }
+        /*
+         * If the directory entry overruns the end of the directory
+         * block, and the name is small enough to fit, then adjust the
+         * record length.
+         */
+        if ((left < 0) &&
+            (name_len + 8 <= dirent->rec_len + left) &&
+            dirent->inode <= fs->super->s_inodes_count &&
+            strnlen(dirent->name, name_len) == name_len) {
+                dirent->rec_len += left;
+                return;
+        }
+        /*
+         * If the directory entry is a multiple of four, so it is
+         * valid, let the previous directory entry absorb the invalid
+         * one.
+         */
+        if (prev && dirent->rec_len && (dirent->rec_len % 4) == 0) {
+                prev->rec_len += dirent->rec_len;
+                *offset += dirent->rec_len;
+                return;
+        }
+        /*
+         * Default salvage method --- kill all of the directory
+         * entries for the rest of the block.  We will either try to
+         * absorb it into the previous directory entry, or create a
+         * new empty directory entry the rest of the directory block.
+         */
+        if (prev) {
+                prev->rec_len += fs->blocksize - *offset;
+                *offset = fs->blocksize;
+        } else {
+                dirent->rec_len = fs->blocksize - *offset;
+                dirent->name_len = 0;
+                dirent->inode = 0;
+        }
+}
+
+static int check_dir_block(ext2_filsys fs,
+                           struct ext2_db_entry *db,
+                           void *priv_data)
+{
+        struct dir_info         *subdir, *dir;
+        struct dx_dir_info      *dx_dir;
+#ifdef ENABLE_HTREE
+        struct dx_dirblock_info *dx_db = 0;
+#endif /* ENABLE_HTREE */
+        struct ext2_dir_entry   *dirent, *prev;
+        ext2_dirhash_t          hash;
+        unsigned int            offset = 0;
+        int                     dir_modified = 0;
+        int                     dot_state;
+        blk_t                   block_nr = db->blk;
+        ext2_ino_t              ino = db->ino;
+        __u16                   links;
+        struct check_dir_struct *cd;
+        char                    *buf;
+        e2fsck_t                ctx;
+        int                     problem;
+        struct ext2_dx_root_info *root;
+        struct ext2_dx_countlimit *limit;
+        static dict_t de_dict;
+        struct problem_context  pctx;
+        int     dups_found = 0;
+
+        cd = (struct check_dir_struct *) priv_data;
+        buf = cd->buf;
+        ctx = cd->ctx;
+
+        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                return DIRENT_ABORT;
+
+        if (ctx->progress && (ctx->progress)(ctx, 2, cd->count++, cd->max))
+                return DIRENT_ABORT;
+
+        /*
+         * Make sure the inode is still in use (could have been
+         * deleted in the duplicate/bad blocks pass.
+         */
+        if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, ino)))
+                return 0;
+
+        cd->pctx.ino = ino;
+        cd->pctx.blk = block_nr;
+        cd->pctx.blkcount = db->blockcnt;
+        cd->pctx.ino2 = 0;
+        cd->pctx.dirent = 0;
+        cd->pctx.num = 0;
+
+        if (db->blk == 0) {
+                if (allocate_dir_block(ctx, db, buf, &cd->pctx))
+                        return 0;
+                block_nr = db->blk;
+        }
+
+        if (db->blockcnt)
+                dot_state = 2;
+        else
+                dot_state = 0;
+
+        if (ctx->dirs_to_hash &&
+            ext2fs_u32_list_test(ctx->dirs_to_hash, ino))
+                dups_found++;
+
+#if 0
+        printf("In process_dir_block block %lu, #%d, inode %lu\n", block_nr,
+               db->blockcnt, ino);
+#endif
+
+        cd->pctx.errcode = ext2fs_read_dir_block(fs, block_nr, buf);
+        if (cd->pctx.errcode == EXT2_ET_DIR_CORRUPTED)
+                cd->pctx.errcode = 0; /* We'll handle this ourselves */
+        if (cd->pctx.errcode) {
+                if (!fix_problem(ctx, PR_2_READ_DIRBLOCK, &cd->pctx)) {
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return DIRENT_ABORT;
+                }
+                memset(buf, 0, fs->blocksize);
+        }
+#ifdef ENABLE_HTREE
+        dx_dir = e2fsck_get_dx_dir_info(ctx, ino);
+        if (dx_dir && dx_dir->numblocks) {
+                if (db->blockcnt >= dx_dir->numblocks) {
+                        printf("XXX should never happen!!!\n");
+                        abort();
+                }
+                dx_db = &dx_dir->dx_block[db->blockcnt];
+                dx_db->type = DX_DIRBLOCK_LEAF;
+                dx_db->phys = block_nr;
+                dx_db->min_hash = ~0;
+                dx_db->max_hash = 0;
+
+                dirent = (struct ext2_dir_entry *) buf;
+                limit = (struct ext2_dx_countlimit *) (buf+8);
+                if (db->blockcnt == 0) {
+                        root = (struct ext2_dx_root_info *) (buf + 24);
+                        dx_db->type = DX_DIRBLOCK_ROOT;
+                        dx_db->flags |= DX_FLAG_FIRST | DX_FLAG_LAST;
+                        if ((root->reserved_zero ||
+                             root->info_length < 8 ||
+                             root->indirect_levels > 1) &&
+                            fix_problem(ctx, PR_2_HTREE_BAD_ROOT, &cd->pctx)) {
+                                clear_htree(ctx, ino);
+                                dx_dir->numblocks = 0;
+                                dx_db = 0;
+                        }
+                        dx_dir->hashversion = root->hash_version;
+                        dx_dir->depth = root->indirect_levels + 1;
+                } else if ((dirent->inode == 0) &&
+                           (dirent->rec_len == fs->blocksize) &&
+                           (dirent->name_len == 0) &&
+                           (ext2fs_le16_to_cpu(limit->limit) ==
+                            ((fs->blocksize-8) /
+                             sizeof(struct ext2_dx_entry))))
+                        dx_db->type = DX_DIRBLOCK_NODE;
+        }
+#endif /* ENABLE_HTREE */
+
+        dict_init(&de_dict, DICTCOUNT_T_MAX, dict_de_cmp);
+        prev = 0;
+        do {
+                problem = 0;
+                dirent = (struct ext2_dir_entry *) (buf + offset);
+                cd->pctx.dirent = dirent;
+                cd->pctx.num = offset;
+                if (((offset + dirent->rec_len) > fs->blocksize) ||
+                    (dirent->rec_len < 12) ||
+                    ((dirent->rec_len % 4) != 0) ||
+                    (((dirent->name_len & 0xFF)+8) > dirent->rec_len)) {
+                        if (fix_problem(ctx, PR_2_DIR_CORRUPTED, &cd->pctx)) {
+                                salvage_directory(fs, dirent, prev, &offset);
+                                dir_modified++;
+                                continue;
+                        } else
+                                goto abort_free_dict;
+                }
+                if ((dirent->name_len & 0xFF) > EXT2_NAME_LEN) {
+                        if (fix_problem(ctx, PR_2_FILENAME_LONG, &cd->pctx)) {
+                                dirent->name_len = EXT2_NAME_LEN;
+                                dir_modified++;
+                        }
+                }
+
+                if (dot_state == 0) {
+                        if (check_dot(ctx, dirent, ino, &cd->pctx))
+                                dir_modified++;
+                } else if (dot_state == 1) {
+                        dir = e2fsck_get_dir_info(ctx, ino);
+                        if (!dir) {
+                                fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx);
+                                goto abort_free_dict;
+                        }
+                        if (check_dotdot(ctx, dirent, dir, &cd->pctx))
+                                dir_modified++;
+                } else if (dirent->inode == ino) {
+                        problem = PR_2_LINK_DOT;
+                        if (fix_problem(ctx, PR_2_LINK_DOT, &cd->pctx)) {
+                                dirent->inode = 0;
+                                dir_modified++;
+                                goto next;
+                        }
+                }
+                if (!dirent->inode)
+                        goto next;
+
+                /*
+                 * Make sure the inode listed is a legal one.
+                 */
+                if (((dirent->inode != EXT2_ROOT_INO) &&
+                     (dirent->inode < EXT2_FIRST_INODE(fs->super))) ||
+                    (dirent->inode > fs->super->s_inodes_count)) {
+                        problem = PR_2_BAD_INO;
+                } else if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map,
+                                               dirent->inode))) {
+                        /*
+                         * If the inode is unused, offer to clear it.
+                         */
+                        problem = PR_2_UNUSED_INODE;
+                } else if (ctx->inode_bb_map &&
+                           (ext2fs_test_inode_bitmap(ctx->inode_bb_map,
+                                                     dirent->inode))) {
+                        /*
+                         * If the inode is in a bad block, offer to
+                         * clear it.
+                         */
+                        problem = PR_2_BB_INODE;
+                } else if ((dot_state > 1) &&
+                           ((dirent->name_len & 0xFF) == 1) &&
+                           (dirent->name[0] == '.')) {
+                        /*
+                         * If there's a '.' entry in anything other
+                         * than the first directory entry, it's a
+                         * duplicate entry that should be removed.
+                         */
+                        problem = PR_2_DUP_DOT;
+                } else if ((dot_state > 1) &&
+                           ((dirent->name_len & 0xFF) == 2) &&
+                           (dirent->name[0] == '.') &&
+                           (dirent->name[1] == '.')) {
+                        /*
+                         * If there's a '..' entry in anything other
+                         * than the second directory entry, it's a
+                         * duplicate entry that should be removed.
+                         */
+                        problem = PR_2_DUP_DOT_DOT;
+                } else if ((dot_state > 1) &&
+                           (dirent->inode == EXT2_ROOT_INO)) {
+                        /*
+                         * Don't allow links to the root directory.
+                         * We check this specially to make sure we
+                         * catch this error case even if the root
+                         * directory hasn't been created yet.
+                         */
+                        problem = PR_2_LINK_ROOT;
+                } else if ((dot_state > 1) &&
+                           (dirent->name_len & 0xFF) == 0) {
+                        /*
+                         * Don't allow zero-length directory names.
+                         */
+                        problem = PR_2_NULL_NAME;
+                }
+
+                if (problem) {
+                        if (fix_problem(ctx, problem, &cd->pctx)) {
+                                dirent->inode = 0;
+                                dir_modified++;
+                                goto next;
+                        } else {
+                                ext2fs_unmark_valid(fs);
+                                if (problem == PR_2_BAD_INO)
+                                        goto next;
+                        }
+                }
+
+                /*
+                 * If the inode was marked as having bad fields in
+                 * pass1, process it and offer to fix/clear it.
+                 * (We wait until now so that we can display the
+                 * pathname to the user.)
+                 */
+                if (ctx->inode_bad_map &&
+                    ext2fs_test_inode_bitmap(ctx->inode_bad_map,
+                                             dirent->inode)) {
+                        if (e2fsck_process_bad_inode(ctx, ino,
+                                                     dirent->inode,
+                                                     buf + fs->blocksize)) {
+                                dirent->inode = 0;
+                                dir_modified++;
+                                goto next;
+                        }
+                        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                                return DIRENT_ABORT;
+                }
+
+                if (check_name(ctx, dirent, ino, &cd->pctx))
+                        dir_modified++;
+
+                if (check_filetype(ctx, dirent, ino, &cd->pctx))
+                        dir_modified++;
+
+#ifdef ENABLE_HTREE
+                if (dx_db) {
+                        ext2fs_dirhash(dx_dir->hashversion, dirent->name,
+                                       (dirent->name_len & 0xFF),
+                                       fs->super->s_hash_seed, &hash, 0);
+                        if (hash < dx_db->min_hash)
+                                dx_db->min_hash = hash;
+                        if (hash > dx_db->max_hash)
+                                dx_db->max_hash = hash;
+                }
+#endif
+
+                /*
+                 * If this is a directory, then mark its parent in its
+                 * dir_info structure.  If the parent field is already
+                 * filled in, then this directory has more than one
+                 * hard link.  We assume the first link is correct,
+                 * and ask the user if he/she wants to clear this one.
+                 */
+                if ((dot_state > 1) &&
+                    (ext2fs_test_inode_bitmap(ctx->inode_dir_map,
+                                              dirent->inode))) {
+                        subdir = e2fsck_get_dir_info(ctx, dirent->inode);
+                        if (!subdir) {
+                                cd->pctx.ino = dirent->inode;
+                                fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx);
+                                goto abort_free_dict;
+                        }
+                        if (subdir->parent) {
+                                cd->pctx.ino2 = subdir->parent;
+                                if (fix_problem(ctx, PR_2_LINK_DIR,
+                                                &cd->pctx)) {
+                                        dirent->inode = 0;
+                                        dir_modified++;
+                                        goto next;
+                                }
+                                cd->pctx.ino2 = 0;
+                        } else
+                                subdir->parent = ino;
+                }
+
+                if (dups_found) {
+                        ;
+                } else if (dict_lookup(&de_dict, dirent)) {
+                        clear_problem_context(&pctx);
+                        pctx.ino = ino;
+                        pctx.dirent = dirent;
+                        fix_problem(ctx, PR_2_REPORT_DUP_DIRENT, &pctx);
+                        if (!ctx->dirs_to_hash)
+                                ext2fs_u32_list_create(&ctx->dirs_to_hash, 50);
+                        if (ctx->dirs_to_hash)
+                                ext2fs_u32_list_add(ctx->dirs_to_hash, ino);
+                        dups_found++;
+                } else
+                        dict_alloc_insert(&de_dict, dirent, dirent);
+
+                ext2fs_icount_increment(ctx->inode_count, dirent->inode,
+                                        &links);
+                if (links > 1)
+                        ctx->fs_links_count++;
+                ctx->fs_total_count++;
+        next:
+                prev = dirent;
+                offset += dirent->rec_len;
+                dot_state++;
+        } while (offset < fs->blocksize);
+#if 0
+        printf("\n");
+#endif
+#ifdef ENABLE_HTREE
+        if (dx_db) {
+#ifdef DX_DEBUG
+                printf("db_block %d, type %d, min_hash 0x%0x, max_hash 0x%0x\n",
+                       db->blockcnt, dx_db->type,
+                       dx_db->min_hash, dx_db->max_hash);
+#endif
+                cd->pctx.dir = cd->pctx.ino;
+                if ((dx_db->type == DX_DIRBLOCK_ROOT) ||
+                    (dx_db->type == DX_DIRBLOCK_NODE))
+                        parse_int_node(fs, db, cd, dx_dir, buf);
+        }
+#endif /* ENABLE_HTREE */
+        if (offset != fs->blocksize) {
+                cd->pctx.num = dirent->rec_len - fs->blocksize + offset;
+                if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) {
+                        dirent->rec_len = cd->pctx.num;
+                        dir_modified++;
+                }
+        }
+        if (dir_modified) {
+                cd->pctx.errcode = ext2fs_write_dir_block(fs, block_nr, buf);
+                if (cd->pctx.errcode) {
+                        if (!fix_problem(ctx, PR_2_WRITE_DIRBLOCK,
+                                         &cd->pctx))
+                                goto abort_free_dict;
+                }
+                ext2fs_mark_changed(fs);
+        }
+        dict_free_nodes(&de_dict);
+        return 0;
+abort_free_dict:
+        dict_free_nodes(&de_dict);
+        ctx->flags |= E2F_FLAG_ABORT;
+        return DIRENT_ABORT;
+}
+
+/*
+ * This function is called to deallocate a block, and is an interator
+ * functioned called by deallocate inode via ext2fs_iterate_block().
+ */
+static int deallocate_inode_block(ext2_filsys fs,
+                                  blk_t *block_nr,
+                                  e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
+                                  blk_t ref_block EXT2FS_ATTR((unused)),
+                                  int ref_offset EXT2FS_ATTR((unused)),
+                                  void *priv_data)
+{
+        e2fsck_t        ctx = (e2fsck_t) priv_data;
+
+        if (HOLE_BLKADDR(*block_nr))
+                return 0;
+        if ((*block_nr < fs->super->s_first_data_block) ||
+            (*block_nr >= fs->super->s_blocks_count))
+                return 0;
+        ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr);
+        ext2fs_block_alloc_stats(fs, *block_nr, -1);
+        return 0;
+}
+
+/*
+ * This fuction deallocates an inode
+ */
+static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf)
+{
+        ext2_filsys fs = ctx->fs;
+        struct ext2_inode       inode;
+        struct problem_context  pctx;
+        __u32                   count;
+
+        ext2fs_icount_store(ctx->inode_link_info, ino, 0);
+        e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode");
+        inode.i_links_count = 0;
+        inode.i_dtime = time(0);
+        e2fsck_write_inode(ctx, ino, &inode, "deallocate_inode");
+        clear_problem_context(&pctx);
+        pctx.ino = ino;
+
+        /*
+         * Fix up the bitmaps...
+         */
+        e2fsck_read_bitmaps(ctx);
+        ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
+        ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
+        if (ctx->inode_bad_map)
+                ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino);
+        ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode));
+
+        if (inode.i_file_acl &&
+            (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) {
+                pctx.errcode = ext2fs_adjust_ea_refcount(fs, inode.i_file_acl,
+                                                   block_buf, -1, &count);
+                if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) {
+                        pctx.errcode = 0;
+                        count = 1;
+                }
+                if (pctx.errcode) {
+                        pctx.blk = inode.i_file_acl;
+                        fix_problem(ctx, PR_2_ADJ_EA_REFCOUNT, &pctx);
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return;
+                }
+                if (count == 0) {
+                        ext2fs_unmark_block_bitmap(ctx->block_found_map,
+                                                   inode.i_file_acl);
+                        ext2fs_block_alloc_stats(fs, inode.i_file_acl, -1);
+                }
+                inode.i_file_acl = 0;
+        }
+
+        if (!ext2fs_inode_has_valid_blocks(&inode))
+                return;
+
+        if (LINUX_S_ISREG(inode.i_mode) &&
+            (inode.i_size_high || inode.i_size & 0x80000000UL))
+                ctx->large_files--;
+
+        pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf,
+                                            deallocate_inode_block, ctx);
+        if (pctx.errcode) {
+                fix_problem(ctx, PR_2_DEALLOC_INODE, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+}
+
+/*
+ * This fuction clears the htree flag on an inode
+ */
+static void clear_htree(e2fsck_t ctx, ext2_ino_t ino)
+{
+        struct ext2_inode       inode;
+
+        e2fsck_read_inode(ctx, ino, &inode, "clear_htree");
+        inode.i_flags = inode.i_flags & ~EXT2_INDEX_FL;
+        e2fsck_write_inode(ctx, ino, &inode, "clear_htree");
+        if (ctx->dirs_to_hash)
+                ext2fs_u32_list_add(ctx->dirs_to_hash, ino);
+}
+
+
+static int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir,
+                                    ext2_ino_t ino, char *buf)
+{
+        ext2_filsys fs = ctx->fs;
+        struct ext2_inode       inode;
+        int                     inode_modified = 0;
+        int                     not_fixed = 0;
+        unsigned char           *frag, *fsize;
+        struct problem_context  pctx;
+        int     problem = 0;
+
+        e2fsck_read_inode(ctx, ino, &inode, "process_bad_inode");
+
+        clear_problem_context(&pctx);
+        pctx.ino = ino;
+        pctx.dir = dir;
+        pctx.inode = &inode;
+
+        if (inode.i_file_acl &&
+            !(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) &&
+            fix_problem(ctx, PR_2_FILE_ACL_ZERO, &pctx)) {
+                inode.i_file_acl = 0;
+#ifdef EXT2FS_ENABLE_SWAPFS
+                /*
+                 * This is a special kludge to deal with long symlinks
+                 * on big endian systems.  i_blocks had already been
+                 * decremented earlier in pass 1, but since i_file_acl
+                 * hadn't yet been cleared, ext2fs_read_inode()
+                 * assumed that the file was short symlink and would
+                 * not have byte swapped i_block[0].  Hence, we have
+                 * to byte-swap it here.
+                 */
+                if (LINUX_S_ISLNK(inode.i_mode) &&
+                    (fs->flags & EXT2_FLAG_SWAP_BYTES) &&
+                    (inode.i_blocks == fs->blocksize >> 9))
+                        inode.i_block[0] = ext2fs_swab32(inode.i_block[0]);
+#endif
+                inode_modified++;
+        } else
+                not_fixed++;
+
+        if (!LINUX_S_ISDIR(inode.i_mode) && !LINUX_S_ISREG(inode.i_mode) &&
+            !LINUX_S_ISCHR(inode.i_mode) && !LINUX_S_ISBLK(inode.i_mode) &&
+            !LINUX_S_ISLNK(inode.i_mode) && !LINUX_S_ISFIFO(inode.i_mode) &&
+            !(LINUX_S_ISSOCK(inode.i_mode)))
+                problem = PR_2_BAD_MODE;
+        else if (LINUX_S_ISCHR(inode.i_mode)
+                 && !e2fsck_pass1_check_device_inode(fs, &inode))
+                problem = PR_2_BAD_CHAR_DEV;
+        else if (LINUX_S_ISBLK(inode.i_mode)
+                 && !e2fsck_pass1_check_device_inode(fs, &inode))
+                problem = PR_2_BAD_BLOCK_DEV;
+        else if (LINUX_S_ISFIFO(inode.i_mode)
+                 && !e2fsck_pass1_check_device_inode(fs, &inode))
+                problem = PR_2_BAD_FIFO;
+        else if (LINUX_S_ISSOCK(inode.i_mode)
+                 && !e2fsck_pass1_check_device_inode(fs, &inode))
+                problem = PR_2_BAD_SOCKET;
+        else if (LINUX_S_ISLNK(inode.i_mode)
+                 && !e2fsck_pass1_check_symlink(fs, &inode, buf)) {
+                problem = PR_2_INVALID_SYMLINK;
+        }
+
+        if (problem) {
+                if (fix_problem(ctx, problem, &pctx)) {
+                        deallocate_inode(ctx, ino, 0);
+                        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                                return 0;
+                        return 1;
+                } else
+                        not_fixed++;
+                problem = 0;
+        }
+
+        if (inode.i_faddr) {
+                if (fix_problem(ctx, PR_2_FADDR_ZERO, &pctx)) {
+                        inode.i_faddr = 0;
+                        inode_modified++;
+                } else
+                        not_fixed++;
+        }
+
+        switch (fs->super->s_creator_os) {
+            case EXT2_OS_LINUX:
+                frag = &inode.osd2.linux2.l_i_frag;
+                fsize = &inode.osd2.linux2.l_i_fsize;
+                break;
+            case EXT2_OS_HURD:
+                frag = &inode.osd2.hurd2.h_i_frag;
+                fsize = &inode.osd2.hurd2.h_i_fsize;
+                break;
+            case EXT2_OS_MASIX:
+                frag = &inode.osd2.masix2.m_i_frag;
+                fsize = &inode.osd2.masix2.m_i_fsize;
+                break;
+            default:
+                frag = fsize = 0;
+        }
+        if (frag && *frag) {
+                pctx.num = *frag;
+                if (fix_problem(ctx, PR_2_FRAG_ZERO, &pctx)) {
+                        *frag = 0;
+                        inode_modified++;
+                } else
+                        not_fixed++;
+                pctx.num = 0;
+        }
+        if (fsize && *fsize) {
+                pctx.num = *fsize;
+                if (fix_problem(ctx, PR_2_FSIZE_ZERO, &pctx)) {
+                        *fsize = 0;
+                        inode_modified++;
+                } else
+                        not_fixed++;
+                pctx.num = 0;
+        }
+
+        if (inode.i_file_acl &&
+            ((inode.i_file_acl < fs->super->s_first_data_block) ||
+             (inode.i_file_acl >= fs->super->s_blocks_count))) {
+                if (fix_problem(ctx, PR_2_FILE_ACL_BAD, &pctx)) {
+                        inode.i_file_acl = 0;
+                        inode_modified++;
+                } else
+                        not_fixed++;
+        }
+        if (inode.i_dir_acl &&
+            LINUX_S_ISDIR(inode.i_mode)) {
+                if (fix_problem(ctx, PR_2_DIR_ACL_ZERO, &pctx)) {
+                        inode.i_dir_acl = 0;
+                        inode_modified++;
+                } else
+                        not_fixed++;
+        }
+
+        if (inode_modified)
+                e2fsck_write_inode(ctx, ino, &inode, "process_bad_inode");
+        if (!not_fixed)
+                ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino);
+        return 0;
+}
+
+
+/*
+ * allocate_dir_block --- this function allocates a new directory
+ *      block for a particular inode; this is done if a directory has
+ *      a "hole" in it, or if a directory has a illegal block number
+ *      that was zeroed out and now needs to be replaced.
+ */
+static int allocate_dir_block(e2fsck_t ctx,
+                              struct ext2_db_entry *db,
+                              char *buf EXT2FS_ATTR((unused)),
+                              struct problem_context *pctx)
+{
+        ext2_filsys fs = ctx->fs;
+        blk_t                   blk;
+        char                    *block;
+        struct ext2_inode       inode;
+
+        if (fix_problem(ctx, PR_2_DIRECTORY_HOLE, pctx) == 0)
+                return 1;
+
+        /*
+         * Read the inode and block bitmaps in; we'll be messing with
+         * them.
+         */
+        e2fsck_read_bitmaps(ctx);
+
+        /*
+         * First, find a free block
+         */
+        pctx->errcode = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk);
+        if (pctx->errcode) {
+                pctx->str = "ext2fs_new_block";
+                fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
+                return 1;
+        }
+        ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
+        ext2fs_mark_block_bitmap(fs->block_map, blk);
+        ext2fs_mark_bb_dirty(fs);
+
+        /*
+         * Now let's create the actual data block for the inode
+         */
+        if (db->blockcnt)
+                pctx->errcode = ext2fs_new_dir_block(fs, 0, 0, &block);
+        else
+                pctx->errcode = ext2fs_new_dir_block(fs, db->ino,
+                                                     EXT2_ROOT_INO, &block);
+
+        if (pctx->errcode) {
+                pctx->str = "ext2fs_new_dir_block";
+                fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
+                return 1;
+        }
+
+        pctx->errcode = ext2fs_write_dir_block(fs, blk, block);
+        ext2fs_free_mem(&block);
+        if (pctx->errcode) {
+                pctx->str = "ext2fs_write_dir_block";
+                fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
+                return 1;
+        }
+
+        /*
+         * Update the inode block count
+         */
+        e2fsck_read_inode(ctx, db->ino, &inode, "allocate_dir_block");
+        inode.i_blocks += fs->blocksize / 512;
+        if (inode.i_size < (db->blockcnt+1) * fs->blocksize)
+                inode.i_size = (db->blockcnt+1) * fs->blocksize;
+        e2fsck_write_inode(ctx, db->ino, &inode, "allocate_dir_block");
+
+        /*
+         * Finally, update the block pointers for the inode
+         */
+        db->blk = blk;
+        pctx->errcode = ext2fs_block_iterate2(fs, db->ino, BLOCK_FLAG_HOLE,
+                                      0, update_dir_block, db);
+        if (pctx->errcode) {
+                pctx->str = "ext2fs_block_iterate";
+                fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
+                return 1;
+        }
+
+        return 0;
+}
+
+/*
+ * This is a helper function for allocate_dir_block().
+ */
+static int update_dir_block(ext2_filsys fs EXT2FS_ATTR((unused)),
+                            blk_t       *block_nr,
+                            e2_blkcnt_t blockcnt,
+                            blk_t ref_block EXT2FS_ATTR((unused)),
+                            int ref_offset EXT2FS_ATTR((unused)),
+                            void *priv_data)
+{
+        struct ext2_db_entry *db;
+
+        db = (struct ext2_db_entry *) priv_data;
+        if (db->blockcnt == (int) blockcnt) {
+                *block_nr = db->blk;
+                return BLOCK_CHANGED;
+        }
+        return 0;
+}
+/*
+ * pass3.c -- pass #3 of e2fsck: Check for directory connectivity
+ *
+ * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ *
+ * Pass #3 assures that all directories are connected to the
+ * filesystem tree, using the following algorithm:
+ *
+ * First, the root directory is checked to make sure it exists; if
+ * not, e2fsck will offer to create a new one.  It is then marked as
+ * "done".
+ *
+ * Then, pass3 interates over all directory inodes; for each directory
+ * it attempts to trace up the filesystem tree, using dirinfo.parent
+ * until it reaches a directory which has been marked "done".  If it
+ * can not do so, then the directory must be disconnected, and e2fsck
+ * will offer to reconnect it to /lost+found.  While it is chasing
+ * parent pointers up the filesystem tree, if pass3 sees a directory
+ * twice, then it has detected a filesystem loop, and it will again
+ * offer to reconnect the directory to /lost+found in to break the
+ * filesystem loop.
+ *
+ * Pass 3 also contains the subroutine, e2fsck_reconnect_file() to
+ * reconnect inodes to /lost+found; this subroutine is also used by
+ * pass 4.  e2fsck_reconnect_file() calls get_lost_and_found(), which
+ * is responsible for creating /lost+found if it does not exist.
+ *
+ * Pass 3 frees the following data structures:
+ *      - The dirinfo directory information cache.
+ */
+
+static void check_root(e2fsck_t ctx);
+static int check_directory(e2fsck_t ctx, struct dir_info *dir,
+                           struct problem_context *pctx);
+static void fix_dotdot(e2fsck_t ctx, struct dir_info *dir, ext2_ino_t parent);
+
+static ext2fs_inode_bitmap inode_loop_detect = 0;
+static ext2fs_inode_bitmap inode_done_map = 0;
+
+void e2fsck_pass3(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        int             i;
+#ifdef RESOURCE_TRACK
+        struct resource_track   rtrack;
+#endif
+        struct problem_context  pctx;
+        struct dir_info *dir;
+        unsigned long maxdirs, count;
+
+#ifdef RESOURCE_TRACK
+        init_resource_track(&rtrack);
+#endif
+
+        clear_problem_context(&pctx);
+
+#ifdef MTRACE
+        mtrace_print("Pass 3");
+#endif
+
+        if (!(ctx->options & E2F_OPT_PREEN))
+                fix_problem(ctx, PR_3_PASS_HEADER, &pctx);
+
+        /*
+         * Allocate some bitmaps to do loop detection.
+         */
+        pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("inode done bitmap"),
+                                                    &inode_done_map);
+        if (pctx.errcode) {
+                pctx.num = 2;
+                fix_problem(ctx, PR_3_ALLOCATE_IBITMAP_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                goto abort_exit;
+        }
+#ifdef RESOURCE_TRACK
+        if (ctx->options & E2F_OPT_TIME) {
+                e2fsck_clear_progbar(ctx);
+                print_resource_track(_("Peak memory"), &ctx->global_rtrack);
+        }
+#endif
+
+        check_root(ctx);
+        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                goto abort_exit;
+
+        ext2fs_mark_inode_bitmap(inode_done_map, EXT2_ROOT_INO);
+
+        maxdirs = e2fsck_get_num_dirinfo(ctx);
+        count = 1;
+
+        if (ctx->progress)
+                if ((ctx->progress)(ctx, 3, 0, maxdirs))
+                        goto abort_exit;
+
+        for (i=0; (dir = e2fsck_dir_info_iter(ctx, &i)) != 0;) {
+                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                        goto abort_exit;
+                if (ctx->progress && (ctx->progress)(ctx, 3, count++, maxdirs))
+                        goto abort_exit;
+                if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, dir->ino))
+                        if (check_directory(ctx, dir, &pctx))
+                                goto abort_exit;
+        }
+
+        /*
+         * Force the creation of /lost+found if not present
+         */
+        if ((ctx->flags & E2F_OPT_READONLY) == 0)
+                e2fsck_get_lost_and_found(ctx, 1);
+
+        /*
+         * If there are any directories that need to be indexed or
+         * optimized, do it here.
+         */
+        e2fsck_rehash_directories(ctx);
+
+abort_exit:
+        e2fsck_free_dir_info(ctx);
+        if (inode_loop_detect) {
+                ext2fs_free_inode_bitmap(inode_loop_detect);
+                inode_loop_detect = 0;
+        }
+        if (inode_done_map) {
+                ext2fs_free_inode_bitmap(inode_done_map);
+                inode_done_map = 0;
+        }
+
+#ifdef RESOURCE_TRACK
+        if (ctx->options & E2F_OPT_TIME2) {
+                e2fsck_clear_progbar(ctx);
+                print_resource_track(_("Pass 3"), &rtrack);
+        }
+#endif
+}
+
+/*
+ * This makes sure the root inode is present; if not, we ask if the
+ * user wants us to create it.  Not creating it is a fatal error.
+ */
+static void check_root(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        blk_t                   blk;
+        struct ext2_inode       inode;
+        char *                  block;
+        struct problem_context  pctx;
+
+        clear_problem_context(&pctx);
+
+        if (ext2fs_test_inode_bitmap(ctx->inode_used_map, EXT2_ROOT_INO)) {
+                /*
+                 * If the root inode is not a directory, die here.  The
+                 * user must have answered 'no' in pass1 when we
+                 * offered to clear it.
+                 */
+                if (!(ext2fs_test_inode_bitmap(ctx->inode_dir_map,
+                                               EXT2_ROOT_INO))) {
+                        fix_problem(ctx, PR_3_ROOT_NOT_DIR_ABORT, &pctx);
+                        ctx->flags |= E2F_FLAG_ABORT;
+                }
+                return;
+        }
+
+        if (!fix_problem(ctx, PR_3_NO_ROOT_INODE, &pctx)) {
+                fix_problem(ctx, PR_3_NO_ROOT_INODE_ABORT, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+
+        e2fsck_read_bitmaps(ctx);
+
+        /*
+         * First, find a free block
+         */
+        pctx.errcode = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk);
+        if (pctx.errcode) {
+                pctx.str = "ext2fs_new_block";
+                fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+        ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
+        ext2fs_mark_block_bitmap(fs->block_map, blk);
+        ext2fs_mark_bb_dirty(fs);
+
+        /*
+         * Now let's create the actual data block for the inode
+         */
+        pctx.errcode = ext2fs_new_dir_block(fs, EXT2_ROOT_INO, EXT2_ROOT_INO,
+                                            &block);
+        if (pctx.errcode) {
+                pctx.str = "ext2fs_new_dir_block";
+                fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+
+        pctx.errcode = ext2fs_write_dir_block(fs, blk, block);
+        if (pctx.errcode) {
+                pctx.str = "ext2fs_write_dir_block";
+                fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+        ext2fs_free_mem(&block);
+
+        /*
+         * Set up the inode structure
+         */
+        memset(&inode, 0, sizeof(inode));
+        inode.i_mode = 040755;
+        inode.i_size = fs->blocksize;
+        inode.i_atime = inode.i_ctime = inode.i_mtime = time(0);
+        inode.i_links_count = 2;
+        inode.i_blocks = fs->blocksize / 512;
+        inode.i_block[0] = blk;
+
+        /*
+         * Write out the inode.
+         */
+        pctx.errcode = ext2fs_write_new_inode(fs, EXT2_ROOT_INO, &inode);
+        if (pctx.errcode) {
+                pctx.str = "ext2fs_write_inode";
+                fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+
+        /*
+         * Miscellaneous bookkeeping...
+         */
+        e2fsck_add_dir_info(ctx, EXT2_ROOT_INO, EXT2_ROOT_INO);
+        ext2fs_icount_store(ctx->inode_count, EXT2_ROOT_INO, 2);
+        ext2fs_icount_store(ctx->inode_link_info, EXT2_ROOT_INO, 2);
+
+        ext2fs_mark_inode_bitmap(ctx->inode_used_map, EXT2_ROOT_INO);
+        ext2fs_mark_inode_bitmap(ctx->inode_dir_map, EXT2_ROOT_INO);
+        ext2fs_mark_inode_bitmap(fs->inode_map, EXT2_ROOT_INO);
+        ext2fs_mark_ib_dirty(fs);
+}
+
+/*
+ * This subroutine is responsible for making sure that a particular
+ * directory is connected to the root; if it isn't we trace it up as
+ * far as we can go, and then offer to connect the resulting parent to
+ * the lost+found.  We have to do loop detection; if we ever discover
+ * a loop, we treat that as a disconnected directory and offer to
+ * reparent it to lost+found.
+ *
+ * However, loop detection is expensive, because for very large
+ * filesystems, the inode_loop_detect bitmap is huge, and clearing it
+ * is non-trivial.  Loops in filesystems are also a rare error case,
+ * and we shouldn't optimize for error cases.  So we try two passes of
+ * the algorithm.  The first time, we ignore loop detection and merely
+ * increment a counter; if the counter exceeds some extreme threshold,
+ * then we try again with the loop detection bitmap enabled.
+ */
+static int check_directory(e2fsck_t ctx, struct dir_info *dir,
+                           struct problem_context *pctx)
+{
+        ext2_filsys     fs = ctx->fs;
+        struct dir_info *p = dir;
+        int             loop_pass = 0, parent_count = 0;
+
+        if (!p)
+                return 0;
+
+        while (1) {
+                /*
+                 * Mark this inode as being "done"; by the time we
+                 * return from this function, the inode we either be
+                 * verified as being connected to the directory tree,
+                 * or we will have offered to reconnect this to
+                 * lost+found.
+                 *
+                 * If it was marked done already, then we've reached a
+                 * parent we've already checked.
+                 */
+                if (ext2fs_mark_inode_bitmap(inode_done_map, p->ino))
+                        break;
+
+                /*
+                 * If this directory doesn't have a parent, or we've
+                 * seen the parent once already, then offer to
+                 * reparent it to lost+found
+                 */
+                if (!p->parent ||
+                    (loop_pass &&
+                     (ext2fs_test_inode_bitmap(inode_loop_detect,
+                                              p->parent)))) {
+                        pctx->ino = p->ino;
+                        if (fix_problem(ctx, PR_3_UNCONNECTED_DIR, pctx)) {
+                                if (e2fsck_reconnect_file(ctx, pctx->ino))
+                                        ext2fs_unmark_valid(fs);
+                                else {
+                                        p = e2fsck_get_dir_info(ctx, pctx->ino);
+                                        p->parent = ctx->lost_and_found;
+                                        fix_dotdot(ctx, p, ctx->lost_and_found);
+                                }
+                        }
+                        break;
+                }
+                p = e2fsck_get_dir_info(ctx, p->parent);
+                if (!p) {
+                        fix_problem(ctx, PR_3_NO_DIRINFO, pctx);
+                        return 0;
+                }
+                if (loop_pass) {
+                        ext2fs_mark_inode_bitmap(inode_loop_detect,
+                                                 p->ino);
+                } else if (parent_count++ > 2048) {
+                        /*
+                         * If we've run into a path depth that's
+                         * greater than 2048, try again with the inode
+                         * loop bitmap turned on and start from the
+                         * top.
+                         */
+                        loop_pass = 1;
+                        if (inode_loop_detect)
+                                ext2fs_clear_inode_bitmap(inode_loop_detect);
+                        else {
+                                pctx->errcode = ext2fs_allocate_inode_bitmap(fs, _("inode loop detection bitmap"), &inode_loop_detect);
+                                if (pctx->errcode) {
+                                        pctx->num = 1;
+                                        fix_problem(ctx,
+                                    PR_3_ALLOCATE_IBITMAP_ERROR, pctx);
+                                        ctx->flags |= E2F_FLAG_ABORT;
+                                        return -1;
+                                }
+                        }
+                        p = dir;
+                }
+        }
+
+        /*
+         * Make sure that .. and the parent directory are the same;
+         * offer to fix it if not.
+         */
+        if (dir->parent != dir->dotdot) {
+                pctx->ino = dir->ino;
+                pctx->ino2 = dir->dotdot;
+                pctx->dir = dir->parent;
+                if (fix_problem(ctx, PR_3_BAD_DOT_DOT, pctx))
+                        fix_dotdot(ctx, dir, dir->parent);
+        }
+        return 0;
+}
+
+/*
+ * This routine gets the lost_and_found inode, making it a directory
+ * if necessary
+ */
+ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix)
+{
+        ext2_filsys fs = ctx->fs;
+        ext2_ino_t                      ino;
+        blk_t                   blk;
+        errcode_t               retval;
+        struct ext2_inode       inode;
+        char *                  block;
+        static const char       name[] = "lost+found";
+        struct  problem_context pctx;
+        struct dir_info         *dirinfo;
+
+        if (ctx->lost_and_found)
+                return ctx->lost_and_found;
+
+        clear_problem_context(&pctx);
+
+        retval = ext2fs_lookup(fs, EXT2_ROOT_INO, name,
+                               sizeof(name)-1, 0, &ino);
+        if (retval && !fix)
+                return 0;
+        if (!retval) {
+                if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, ino)) {
+                        ctx->lost_and_found = ino;
+                        return ino;
+                }
+
+                /* Lost+found isn't a directory! */
+                if (!fix)
+                        return 0;
+                pctx.ino = ino;
+                if (!fix_problem(ctx, PR_3_LPF_NOTDIR, &pctx))
+                        return 0;
+
+                /* OK, unlink the old /lost+found file. */
+                pctx.errcode = ext2fs_unlink(fs, EXT2_ROOT_INO, name, ino, 0);
+                if (pctx.errcode) {
+                        pctx.str = "ext2fs_unlink";
+                        fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
+                        return 0;
+                }
+                dirinfo = e2fsck_get_dir_info(ctx, ino);
+                if (dirinfo)
+                        dirinfo->parent = 0;
+                e2fsck_adjust_inode_count(ctx, ino, -1);
+        } else if (retval != EXT2_ET_FILE_NOT_FOUND) {
+                pctx.errcode = retval;
+                fix_problem(ctx, PR_3_ERR_FIND_LPF, &pctx);
+        }
+        if (!fix_problem(ctx, PR_3_NO_LF_DIR, 0))
+                return 0;
+
+        /*
+         * Read the inode and block bitmaps in; we'll be messing with
+         * them.
+         */
+        e2fsck_read_bitmaps(ctx);
+
+        /*
+         * First, find a free block
+         */
+        retval = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk);
+        if (retval) {
+                pctx.errcode = retval;
+                fix_problem(ctx, PR_3_ERR_LPF_NEW_BLOCK, &pctx);
+                return 0;
+        }
+        ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
+        ext2fs_block_alloc_stats(fs, blk, +1);
+
+        /*
+         * Next find a free inode.
+         */
+        retval = ext2fs_new_inode(fs, EXT2_ROOT_INO, 040700,
+                                  ctx->inode_used_map, &ino);
+        if (retval) {
+                pctx.errcode = retval;
+                fix_problem(ctx, PR_3_ERR_LPF_NEW_INODE, &pctx);
+                return 0;
+        }
+        ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
+        ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino);
+        ext2fs_inode_alloc_stats2(fs, ino, +1, 1);
+
+        /*
+         * Now let's create the actual data block for the inode
+         */
+        retval = ext2fs_new_dir_block(fs, ino, EXT2_ROOT_INO, &block);
+        if (retval) {
+                pctx.errcode = retval;
+                fix_problem(ctx, PR_3_ERR_LPF_NEW_DIR_BLOCK, &pctx);
+                return 0;
+        }
+
+        retval = ext2fs_write_dir_block(fs, blk, block);
+        ext2fs_free_mem(&block);
+        if (retval) {
+                pctx.errcode = retval;
+                fix_problem(ctx, PR_3_ERR_LPF_WRITE_BLOCK, &pctx);
+                return 0;
+        }
+
+        /*
+         * Set up the inode structure
+         */
+        memset(&inode, 0, sizeof(inode));
+        inode.i_mode = 040700;
+        inode.i_size = fs->blocksize;
+        inode.i_atime = inode.i_ctime = inode.i_mtime = time(0);
+        inode.i_links_count = 2;
+        inode.i_blocks = fs->blocksize / 512;
+        inode.i_block[0] = blk;
+
+        /*
+         * Next, write out the inode.
+         */
+        pctx.errcode = ext2fs_write_new_inode(fs, ino, &inode);
+        if (pctx.errcode) {
+                pctx.str = "ext2fs_write_inode";
+                fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
+                return 0;
+        }
+        /*
+         * Finally, create the directory link
+         */
+        pctx.errcode = ext2fs_link(fs, EXT2_ROOT_INO, name, ino, EXT2_FT_DIR);
+        if (pctx.errcode) {
+                pctx.str = "ext2fs_link";
+                fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
+                return 0;
+        }
+
+        /*
+         * Miscellaneous bookkeeping that needs to be kept straight.
+         */
+        e2fsck_add_dir_info(ctx, ino, EXT2_ROOT_INO);
+        e2fsck_adjust_inode_count(ctx, EXT2_ROOT_INO, 1);
+        ext2fs_icount_store(ctx->inode_count, ino, 2);
+        ext2fs_icount_store(ctx->inode_link_info, ino, 2);
+        ctx->lost_and_found = ino;
+#if 0
+        printf("/lost+found created; inode #%lu\n", ino);
+#endif
+        return ino;
+}
+
+/*
+ * This routine will connect a file to lost+found
+ */
+int e2fsck_reconnect_file(e2fsck_t ctx, ext2_ino_t ino)
+{
+        ext2_filsys fs = ctx->fs;
+        errcode_t       retval;
+        char            name[80];
+        struct problem_context  pctx;
+        struct ext2_inode       inode;
+        int             file_type = 0;
+
+        clear_problem_context(&pctx);
+        pctx.ino = ino;
+
+        if (!ctx->bad_lost_and_found && !ctx->lost_and_found) {
+                if (e2fsck_get_lost_and_found(ctx, 1) == 0)
+                        ctx->bad_lost_and_found++;
+        }
+        if (ctx->bad_lost_and_found) {
+                fix_problem(ctx, PR_3_NO_LPF, &pctx);
+                return 1;
+        }
+
+        sprintf(name, "#%u", ino);
+        if (ext2fs_read_inode(fs, ino, &inode) == 0)
+                file_type = ext2_file_type(inode.i_mode);
+        retval = ext2fs_link(fs, ctx->lost_and_found, name, ino, file_type);
+        if (retval == EXT2_ET_DIR_NO_SPACE) {
+                if (!fix_problem(ctx, PR_3_EXPAND_LF_DIR, &pctx))
+                        return 1;
+                retval = e2fsck_expand_directory(ctx, ctx->lost_and_found,
+                                                 1, 0);
+                if (retval) {
+                        pctx.errcode = retval;
+                        fix_problem(ctx, PR_3_CANT_EXPAND_LPF, &pctx);
+                        return 1;
+                }
+                retval = ext2fs_link(fs, ctx->lost_and_found, name,
+                                     ino, file_type);
+        }
+        if (retval) {
+                pctx.errcode = retval;
+                fix_problem(ctx, PR_3_CANT_RECONNECT, &pctx);
+                return 1;
+        }
+        e2fsck_adjust_inode_count(ctx, ino, 1);
+
+        return 0;
+}
+
+/*
+ * Utility routine to adjust the inode counts on an inode.
+ */
+errcode_t e2fsck_adjust_inode_count(e2fsck_t ctx, ext2_ino_t ino, int adj)
+{
+        ext2_filsys fs = ctx->fs;
+        errcode_t               retval;
+        struct ext2_inode       inode;
+
+        if (!ino)
+                return 0;
+
+        retval = ext2fs_read_inode(fs, ino, &inode);
+        if (retval)
+                return retval;
+
+#if 0
+        printf("Adjusting link count for inode %lu by %d (from %d)\n", ino, adj,
+               inode.i_links_count);
+#endif
+
+        if (adj == 1) {
+                ext2fs_icount_increment(ctx->inode_count, ino, 0);
+                if (inode.i_links_count == (__u16) ~0)
+                        return 0;
+                ext2fs_icount_increment(ctx->inode_link_info, ino, 0);
+                inode.i_links_count++;
+        } else if (adj == -1) {
+                ext2fs_icount_decrement(ctx->inode_count, ino, 0);
+                if (inode.i_links_count == 0)
+                        return 0;
+                ext2fs_icount_decrement(ctx->inode_link_info, ino, 0);
+                inode.i_links_count--;
+        }
+
+        retval = ext2fs_write_inode(fs, ino, &inode);
+        if (retval)
+                return retval;
+
+        return 0;
+}
+
+/*
+ * Fix parent --- this routine fixes up the parent of a directory.
+ */
+struct fix_dotdot_struct {
+        ext2_filsys     fs;
+        ext2_ino_t      parent;
+        int             done;
+        e2fsck_t        ctx;
+};
+
+static int fix_dotdot_proc(struct ext2_dir_entry *dirent,
+                           int  offset EXT2FS_ATTR((unused)),
+                           int  blocksize EXT2FS_ATTR((unused)),
+                           char *buf EXT2FS_ATTR((unused)),
+                           void *priv_data)
+{
+        struct fix_dotdot_struct *fp = (struct fix_dotdot_struct *) priv_data;
+        errcode_t       retval;
+        struct problem_context pctx;
+
+        if ((dirent->name_len & 0xFF) != 2)
+                return 0;
+        if (strncmp(dirent->name, "..", 2))
+                return 0;
+
+        clear_problem_context(&pctx);
+
+        retval = e2fsck_adjust_inode_count(fp->ctx, dirent->inode, -1);
+        if (retval) {
+                pctx.errcode = retval;
+                fix_problem(fp->ctx, PR_3_ADJUST_INODE, &pctx);
+        }
+        retval = e2fsck_adjust_inode_count(fp->ctx, fp->parent, 1);
+        if (retval) {
+                pctx.errcode = retval;
+                fix_problem(fp->ctx, PR_3_ADJUST_INODE, &pctx);
+        }
+        dirent->inode = fp->parent;
+
+        fp->done++;
+        return DIRENT_ABORT | DIRENT_CHANGED;
+}
+
+static void fix_dotdot(e2fsck_t ctx, struct dir_info *dir, ext2_ino_t parent)
+{
+        ext2_filsys fs = ctx->fs;
+        errcode_t       retval;
+        struct fix_dotdot_struct fp;
+        struct problem_context pctx;
+
+        fp.fs = fs;
+        fp.parent = parent;
+        fp.done = 0;
+        fp.ctx = ctx;
+
+#if 0
+        printf("Fixing '..' of inode %lu to be %lu...\n", dir->ino, parent);
+#endif
+
+        retval = ext2fs_dir_iterate(fs, dir->ino, DIRENT_FLAG_INCLUDE_EMPTY,
+                                    0, fix_dotdot_proc, &fp);
+        if (retval || !fp.done) {
+                clear_problem_context(&pctx);
+                pctx.ino = dir->ino;
+                pctx.errcode = retval;
+                fix_problem(ctx, retval ? PR_3_FIX_PARENT_ERR :
+                            PR_3_FIX_PARENT_NOFIND, &pctx);
+                ext2fs_unmark_valid(fs);
+        }
+        dir->dotdot = parent;
+
+        return;
+}
+
+/*
+ * These routines are responsible for expanding a /lost+found if it is
+ * too small.
+ */
+
+struct expand_dir_struct {
+        int                     num;
+        int                     guaranteed_size;
+        int                     newblocks;
+        int                     last_block;
+        errcode_t               err;
+        e2fsck_t                ctx;
+};
+
+static int expand_dir_proc(ext2_filsys fs,
+                           blk_t        *blocknr,
+                           e2_blkcnt_t  blockcnt,
+                           blk_t ref_block EXT2FS_ATTR((unused)),
+                           int ref_offset EXT2FS_ATTR((unused)),
+                           void *priv_data)
+{
+        struct expand_dir_struct *es = (struct expand_dir_struct *) priv_data;
+        blk_t   new_blk;
+        static blk_t    last_blk = 0;
+        char            *block;
+        errcode_t       retval;
+        e2fsck_t        ctx;
+
+        ctx = es->ctx;
+
+        if (es->guaranteed_size && blockcnt >= es->guaranteed_size)
+                return BLOCK_ABORT;
+
+        if (blockcnt > 0)
+                es->last_block = blockcnt;
+        if (*blocknr) {
+                last_blk = *blocknr;
+                return 0;
+        }
+        retval = ext2fs_new_block(fs, last_blk, ctx->block_found_map,
+                                  &new_blk);
+        if (retval) {
+                es->err = retval;
+                return BLOCK_ABORT;
+        }
+        if (blockcnt > 0) {
+                retval = ext2fs_new_dir_block(fs, 0, 0, &block);
+                if (retval) {
+                        es->err = retval;
+                        return BLOCK_ABORT;
+                }
+                es->num--;
+                retval = ext2fs_write_dir_block(fs, new_blk, block);
+        } else {
+                retval = ext2fs_get_mem(fs->blocksize, &block);
+                if (retval) {
+                        es->err = retval;
+                        return BLOCK_ABORT;
+                }
+                memset(block, 0, fs->blocksize);
+                retval = io_channel_write_blk(fs->io, new_blk, 1, block);
+        }
+        if (retval) {
+                es->err = retval;
+                return BLOCK_ABORT;
+        }
+        ext2fs_free_mem(&block);
+        *blocknr = new_blk;
+        ext2fs_mark_block_bitmap(ctx->block_found_map, new_blk);
+        ext2fs_block_alloc_stats(fs, new_blk, +1);
+        es->newblocks++;
+
+        if (es->num == 0)
+                return (BLOCK_CHANGED | BLOCK_ABORT);
+        else
+                return BLOCK_CHANGED;
+}
+
+errcode_t e2fsck_expand_directory(e2fsck_t ctx, ext2_ino_t dir,
+                                  int num, int guaranteed_size)
+{
+        ext2_filsys fs = ctx->fs;
+        errcode_t       retval;
+        struct expand_dir_struct es;
+        struct ext2_inode       inode;
+
+        if (!(fs->flags & EXT2_FLAG_RW))
+                return EXT2_ET_RO_FILSYS;
+
+        /*
+         * Read the inode and block bitmaps in; we'll be messing with
+         * them.
+         */
+        e2fsck_read_bitmaps(ctx);
+
+        retval = ext2fs_check_directory(fs, dir);
+        if (retval)
+                return retval;
+
+        es.num = num;
+        es.guaranteed_size = guaranteed_size;
+        es.last_block = 0;
+        es.err = 0;
+        es.newblocks = 0;
+        es.ctx = ctx;
+
+        retval = ext2fs_block_iterate2(fs, dir, BLOCK_FLAG_APPEND,
+                                       0, expand_dir_proc, &es);
+
+        if (es.err)
+                return es.err;
+
+        /*
+         * Update the size and block count fields in the inode.
+         */
+        retval = ext2fs_read_inode(fs, dir, &inode);
+        if (retval)
+                return retval;
+
+        inode.i_size = (es.last_block + 1) * fs->blocksize;
+        inode.i_blocks += (fs->blocksize / 512) * es.newblocks;
+
+        e2fsck_write_inode(ctx, dir, &inode, "expand_directory");
+
+        return 0;
+}
+
+/*
+ * pass4.c -- pass #4 of e2fsck: Check reference counts
+ *
+ * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ *
+ * Pass 4 frees the following data structures:
+ *      - A bitmap of which inodes are in bad blocks.   (inode_bb_map)
+ *      - A bitmap of which inodes are imagic inodes.   (inode_imagic_map)
+ */
+
+/*
+ * This routine is called when an inode is not connected to the
+ * directory tree.
+ *
+ * This subroutine returns 1 then the caller shouldn't bother with the
+ * rest of the pass 4 tests.
+ */
+static int disconnect_inode(e2fsck_t ctx, ext2_ino_t i)
+{
+        ext2_filsys fs = ctx->fs;
+        struct ext2_inode       inode;
+        struct problem_context  pctx;
+
+        e2fsck_read_inode(ctx, i, &inode, "pass4: disconnect_inode");
+        clear_problem_context(&pctx);
+        pctx.ino = i;
+        pctx.inode = &inode;
+
+        /*
+         * Offer to delete any zero-length files that does not have
+         * blocks.  If there is an EA block, it might have useful
+         * information, so we won't prompt to delete it, but let it be
+         * reconnected to lost+found.
+         */
+        if (!inode.i_blocks && (LINUX_S_ISREG(inode.i_mode) ||
+                                LINUX_S_ISDIR(inode.i_mode))) {
+                if (fix_problem(ctx, PR_4_ZERO_LEN_INODE, &pctx)) {
+                        ext2fs_icount_store(ctx->inode_link_info, i, 0);
+                        inode.i_links_count = 0;
+                        inode.i_dtime = time(0);
+                        e2fsck_write_inode(ctx, i, &inode,
+                                           "disconnect_inode");
+                        /*
+                         * Fix up the bitmaps...
+                         */
+                        e2fsck_read_bitmaps(ctx);
+                        ext2fs_unmark_inode_bitmap(ctx->inode_used_map, i);
+                        ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, i);
+                        ext2fs_inode_alloc_stats2(fs, i, -1,
+                                                  LINUX_S_ISDIR(inode.i_mode));
+                        return 0;
+                }
+        }
+
+        /*
+         * Prompt to reconnect.
+         */
+        if (fix_problem(ctx, PR_4_UNATTACHED_INODE, &pctx)) {
+                if (e2fsck_reconnect_file(ctx, i))
+                        ext2fs_unmark_valid(fs);
+        } else {
+                /*
+                 * If we don't attach the inode, then skip the
+                 * i_links_test since there's no point in trying to
+                 * force i_links_count to zero.
+                 */
+                ext2fs_unmark_valid(fs);
+                return 1;
+        }
+        return 0;
+}
+
+
+void e2fsck_pass4(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        ext2_ino_t      i;
+        struct ext2_inode       inode;
+#ifdef RESOURCE_TRACK
+        struct resource_track   rtrack;
+#endif
+        struct problem_context  pctx;
+        __u16   link_count, link_counted;
+        char    *buf = 0;
+        int     group, maxgroup;
+
+#ifdef RESOURCE_TRACK
+        init_resource_track(&rtrack);
+#endif
+
+#ifdef MTRACE
+        mtrace_print("Pass 4");
+#endif
+
+        clear_problem_context(&pctx);
+
+        if (!(ctx->options & E2F_OPT_PREEN))
+                fix_problem(ctx, PR_4_PASS_HEADER, &pctx);
+
+        group = 0;
+        maxgroup = fs->group_desc_count;
+        if (ctx->progress)
+                if ((ctx->progress)(ctx, 4, 0, maxgroup))
+                        return;
+
+        for (i=1; i <= fs->super->s_inodes_count; i++) {
+                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                        return;
+                if ((i % fs->super->s_inodes_per_group) == 0) {
+                        group++;
+                        if (ctx->progress)
+                                if ((ctx->progress)(ctx, 4, group, maxgroup))
+                                        return;
+                }
+                if (i == EXT2_BAD_INO ||
+                    (i > EXT2_ROOT_INO && i < EXT2_FIRST_INODE(fs->super)))
+                        continue;
+                if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, i)) ||
+                    (ctx->inode_imagic_map &&
+                     ext2fs_test_inode_bitmap(ctx->inode_imagic_map, i)) ||
+                    (ctx->inode_bb_map &&
+                     ext2fs_test_inode_bitmap(ctx->inode_bb_map, i)))
+                        continue;
+                ext2fs_icount_fetch(ctx->inode_link_info, i, &link_count);
+                ext2fs_icount_fetch(ctx->inode_count, i, &link_counted);
+                if (link_counted == 0) {
+                        if (!buf)
+                                buf = e2fsck_allocate_memory(ctx,
+                                     fs->blocksize, "bad_inode buffer");
+                        if (e2fsck_process_bad_inode(ctx, 0, i, buf))
+                                continue;
+                        if (disconnect_inode(ctx, i))
+                                continue;
+                        ext2fs_icount_fetch(ctx->inode_link_info, i,
+                                            &link_count);
+                        ext2fs_icount_fetch(ctx->inode_count, i,
+                                            &link_counted);
+                }
+                if (link_counted != link_count) {
+                        e2fsck_read_inode(ctx, i, &inode, "pass4");
+                        pctx.ino = i;
+                        pctx.inode = &inode;
+                        if (link_count != inode.i_links_count) {
+                                pctx.num = link_count;
+                                fix_problem(ctx,
+                                            PR_4_INCONSISTENT_COUNT, &pctx);
+                        }
+                        pctx.num = link_counted;
+                        if (fix_problem(ctx, PR_4_BAD_REF_COUNT, &pctx)) {
+                                inode.i_links_count = link_counted;
+                                e2fsck_write_inode(ctx, i, &inode, "pass4");
+                        }
+                }
+        }
+        ext2fs_free_icount(ctx->inode_link_info); ctx->inode_link_info = 0;
+        ext2fs_free_icount(ctx->inode_count); ctx->inode_count = 0;
+        ext2fs_free_inode_bitmap(ctx->inode_bb_map);
+        ctx->inode_bb_map = 0;
+        ext2fs_free_inode_bitmap(ctx->inode_imagic_map);
+        ctx->inode_imagic_map = 0;
+        if (buf)
+                ext2fs_free_mem(&buf);
+#ifdef RESOURCE_TRACK
+        if (ctx->options & E2F_OPT_TIME2) {
+                e2fsck_clear_progbar(ctx);
+                print_resource_track(_("Pass 4"), &rtrack);
+        }
+#endif
+}
+
+/*
+ * pass5.c --- check block and inode bitmaps against on-disk bitmaps
+ *
+ * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ *
+ */
+
+static void check_block_bitmaps(e2fsck_t ctx);
+static void check_inode_bitmaps(e2fsck_t ctx);
+static void check_inode_end(e2fsck_t ctx);
+static void check_block_end(e2fsck_t ctx);
+
+void e2fsck_pass5(e2fsck_t ctx)
+{
+#ifdef RESOURCE_TRACK
+        struct resource_track   rtrack;
+#endif
+        struct problem_context  pctx;
+
+#ifdef MTRACE
+        mtrace_print("Pass 5");
+#endif
+
+#ifdef RESOURCE_TRACK
+        init_resource_track(&rtrack);
+#endif
+
+        clear_problem_context(&pctx);
+
+        if (!(ctx->options & E2F_OPT_PREEN))
+                fix_problem(ctx, PR_5_PASS_HEADER, &pctx);
+
+        if (ctx->progress)
+                if ((ctx->progress)(ctx, 5, 0, ctx->fs->group_desc_count*2))
+                        return;
+
+        e2fsck_read_bitmaps(ctx);
+
+        check_block_bitmaps(ctx);
+        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                return;
+        check_inode_bitmaps(ctx);
+        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                return;
+        check_inode_end(ctx);
+        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                return;
+        check_block_end(ctx);
+        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                return;
+
+        ext2fs_free_inode_bitmap(ctx->inode_used_map);
+        ctx->inode_used_map = 0;
+        ext2fs_free_inode_bitmap(ctx->inode_dir_map);
+        ctx->inode_dir_map = 0;
+        ext2fs_free_block_bitmap(ctx->block_found_map);
+        ctx->block_found_map = 0;
+
+#ifdef RESOURCE_TRACK
+        if (ctx->options & E2F_OPT_TIME2) {
+                e2fsck_clear_progbar(ctx);
+                print_resource_track(_("Pass 5"), &rtrack);
+        }
+#endif
+}
+
+#define NO_BLK ((blk_t) -1)
+
+static void print_bitmap_problem(e2fsck_t ctx, int problem,
+                            struct problem_context *pctx)
+{
+        switch (problem) {
+        case PR_5_BLOCK_UNUSED:
+                if (pctx->blk == pctx->blk2)
+                        pctx->blk2 = 0;
+                else
+                        problem = PR_5_BLOCK_RANGE_UNUSED;
+                break;
+        case PR_5_BLOCK_USED:
+                if (pctx->blk == pctx->blk2)
+                        pctx->blk2 = 0;
+                else
+                        problem = PR_5_BLOCK_RANGE_USED;
+                break;
+        case PR_5_INODE_UNUSED:
+                if (pctx->ino == pctx->ino2)
+                        pctx->ino2 = 0;
+                else
+                        problem = PR_5_INODE_RANGE_UNUSED;
+                break;
+        case PR_5_INODE_USED:
+                if (pctx->ino == pctx->ino2)
+                        pctx->ino2 = 0;
+                else
+                        problem = PR_5_INODE_RANGE_USED;
+                break;
+        }
+        fix_problem(ctx, problem, pctx);
+        pctx->blk = pctx->blk2 = NO_BLK;
+        pctx->ino = pctx->ino2 = 0;
+}
+
+static void check_block_bitmaps(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        blk_t   i;
+        int     *free_array;
+        int     group = 0;
+        unsigned int    blocks = 0;
+        unsigned int    free_blocks = 0;
+        int     group_free = 0;
+        int     actual, bitmap;
+        struct problem_context  pctx;
+        int     problem, save_problem, fixit, had_problem;
+        errcode_t       retval;
+
+        clear_problem_context(&pctx);
+        free_array = (int *) e2fsck_allocate_memory(ctx,
+            fs->group_desc_count * sizeof(int), "free block count array");
+
+        if ((fs->super->s_first_data_block <
+             ext2fs_get_block_bitmap_start(ctx->block_found_map)) ||
+            (fs->super->s_blocks_count-1 >
+             ext2fs_get_block_bitmap_end(ctx->block_found_map))) {
+                pctx.num = 1;
+                pctx.blk = fs->super->s_first_data_block;
+                pctx.blk2 = fs->super->s_blocks_count -1;
+                pctx.ino = ext2fs_get_block_bitmap_start(ctx->block_found_map);
+                pctx.ino2 = ext2fs_get_block_bitmap_end(ctx->block_found_map);
+                fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
+
+                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
+                return;
+        }
+
+        if ((fs->super->s_first_data_block <
+             ext2fs_get_block_bitmap_start(fs->block_map)) ||
+            (fs->super->s_blocks_count-1 >
+             ext2fs_get_block_bitmap_end(fs->block_map))) {
+                pctx.num = 2;
+                pctx.blk = fs->super->s_first_data_block;
+                pctx.blk2 = fs->super->s_blocks_count -1;
+                pctx.ino = ext2fs_get_block_bitmap_start(fs->block_map);
+                pctx.ino2 = ext2fs_get_block_bitmap_end(fs->block_map);
+                fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
+
+                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
+                return;
+        }
+
+redo_counts:
+        had_problem = 0;
+        save_problem = 0;
+        pctx.blk = pctx.blk2 = NO_BLK;
+        for (i = fs->super->s_first_data_block;
+             i < fs->super->s_blocks_count;
+             i++) {
+                actual = ext2fs_fast_test_block_bitmap(ctx->block_found_map, i);
+                bitmap = ext2fs_fast_test_block_bitmap(fs->block_map, i);
+
+                if (actual == bitmap)
+                        goto do_counts;
+
+                if (!actual && bitmap) {
+                        /*
+                         * Block not used, but marked in use in the bitmap.
+                         */
+                        problem = PR_5_BLOCK_UNUSED;
+                } else {
+                        /*
+                         * Block used, but not marked in use in the bitmap.
+                         */
+                        problem = PR_5_BLOCK_USED;
+                }
+                if (pctx.blk == NO_BLK) {
+                        pctx.blk = pctx.blk2 = i;
+                        save_problem = problem;
+                } else {
+                        if ((problem == save_problem) &&
+                            (pctx.blk2 == i-1))
+                                pctx.blk2++;
+                        else {
+                                print_bitmap_problem(ctx, save_problem, &pctx);
+                                pctx.blk = pctx.blk2 = i;
+                                save_problem = problem;
+                        }
+                }
+                ctx->flags |= E2F_FLAG_PROG_SUPPRESS;
+                had_problem++;
+
+        do_counts:
+                if (!bitmap) {
+                        group_free++;
+                        free_blocks++;
+                }
+                blocks ++;
+                if ((blocks == fs->super->s_blocks_per_group) ||
+                    (i == fs->super->s_blocks_count-1)) {
+                        free_array[group] = group_free;
+                        group ++;
+                        blocks = 0;
+                        group_free = 0;
+                        if (ctx->progress)
+                                if ((ctx->progress)(ctx, 5, group,
+                                                    fs->group_desc_count*2))
+                                        return;
+                }
+        }
+        if (pctx.blk != NO_BLK)
+                print_bitmap_problem(ctx, save_problem, &pctx);
+        if (had_problem)
+                fixit = end_problem_latch(ctx, PR_LATCH_BBITMAP);
+        else
+                fixit = -1;
+        ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS;
+
+        if (fixit == 1) {
+                ext2fs_free_block_bitmap(fs->block_map);
+                retval = ext2fs_copy_bitmap(ctx->block_found_map,
+                                                  &fs->block_map);
+                if (retval) {
+                        clear_problem_context(&pctx);
+                        fix_problem(ctx, PR_5_COPY_BBITMAP_ERROR, &pctx);
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return;
+                }
+                ext2fs_set_bitmap_padding(fs->block_map);
+                ext2fs_mark_bb_dirty(fs);
+
+                /* Redo the counts */
+                blocks = 0; free_blocks = 0; group_free = 0; group = 0;
+                memset(free_array, 0, fs->group_desc_count * sizeof(int));
+                goto redo_counts;
+        } else if (fixit == 0)
+                ext2fs_unmark_valid(fs);
+
+        for (i = 0; i < fs->group_desc_count; i++) {
+                if (free_array[i] != fs->group_desc[i].bg_free_blocks_count) {
+                        pctx.group = i;
+                        pctx.blk = fs->group_desc[i].bg_free_blocks_count;
+                        pctx.blk2 = free_array[i];
+
+                        if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP,
+                                        &pctx)) {
+                                fs->group_desc[i].bg_free_blocks_count =
+                                        free_array[i];
+                                ext2fs_mark_super_dirty(fs);
+                        } else
+                                ext2fs_unmark_valid(fs);
+                }
+        }
+        if (free_blocks != fs->super->s_free_blocks_count) {
+                pctx.group = 0;
+                pctx.blk = fs->super->s_free_blocks_count;
+                pctx.blk2 = free_blocks;
+
+                if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) {
+                        fs->super->s_free_blocks_count = free_blocks;
+                        ext2fs_mark_super_dirty(fs);
+                } else
+                        ext2fs_unmark_valid(fs);
+        }
+        ext2fs_free_mem(&free_array);
+}
+
+static void check_inode_bitmaps(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        ext2_ino_t      i;
+        unsigned int    free_inodes = 0;
+        int             group_free = 0;
+        int             dirs_count = 0;
+        int             group = 0;
+        unsigned int    inodes = 0;
+        int             *free_array;
+        int             *dir_array;
+        int             actual, bitmap;
+        errcode_t       retval;
+        struct problem_context  pctx;
+        int             problem, save_problem, fixit, had_problem;
+
+        clear_problem_context(&pctx);
+        free_array = (int *) e2fsck_allocate_memory(ctx,
+            fs->group_desc_count * sizeof(int), "free inode count array");
+
+        dir_array = (int *) e2fsck_allocate_memory(ctx,
+           fs->group_desc_count * sizeof(int), "directory count array");
+
+        if ((1 < ext2fs_get_inode_bitmap_start(ctx->inode_used_map)) ||
+            (fs->super->s_inodes_count >
+             ext2fs_get_inode_bitmap_end(ctx->inode_used_map))) {
+                pctx.num = 3;
+                pctx.blk = 1;
+                pctx.blk2 = fs->super->s_inodes_count;
+                pctx.ino = ext2fs_get_inode_bitmap_start(ctx->inode_used_map);
+                pctx.ino2 = ext2fs_get_inode_bitmap_end(ctx->inode_used_map);
+                fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
+
+                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
+                return;
+        }
+        if ((1 < ext2fs_get_inode_bitmap_start(fs->inode_map)) ||
+            (fs->super->s_inodes_count >
+             ext2fs_get_inode_bitmap_end(fs->inode_map))) {
+                pctx.num = 4;
+                pctx.blk = 1;
+                pctx.blk2 = fs->super->s_inodes_count;
+                pctx.ino = ext2fs_get_inode_bitmap_start(fs->inode_map);
+                pctx.ino2 = ext2fs_get_inode_bitmap_end(fs->inode_map);
+                fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
+
+                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
+                return;
+        }
+
+redo_counts:
+        had_problem = 0;
+        save_problem = 0;
+        pctx.ino = pctx.ino2 = 0;
+        for (i = 1; i <= fs->super->s_inodes_count; i++) {
+                actual = ext2fs_fast_test_inode_bitmap(ctx->inode_used_map, i);
+                bitmap = ext2fs_fast_test_inode_bitmap(fs->inode_map, i);
+
+                if (actual == bitmap)
+                        goto do_counts;
+
+                if (!actual && bitmap) {
+                        /*
+                         * Inode wasn't used, but marked in bitmap
+                         */
+                        problem = PR_5_INODE_UNUSED;
+                } else /* if (actual && !bitmap) */ {
+                        /*
+                         * Inode used, but not in bitmap
+                         */
+                        problem = PR_5_INODE_USED;
+                }
+                if (pctx.ino == 0) {
+                        pctx.ino = pctx.ino2 = i;
+                        save_problem = problem;
+                } else {
+                        if ((problem == save_problem) &&
+                            (pctx.ino2 == i-1))
+                                pctx.ino2++;
+                        else {
+                                print_bitmap_problem(ctx, save_problem, &pctx);
+                                pctx.ino = pctx.ino2 = i;
+                                save_problem = problem;
+                        }
+                }
+                ctx->flags |= E2F_FLAG_PROG_SUPPRESS;
+                had_problem++;
+
+do_counts:
+                if (!bitmap) {
+                        group_free++;
+                        free_inodes++;
+                } else {
+                        if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, i))
+                                dirs_count++;
+                }
+                inodes++;
+                if ((inodes == fs->super->s_inodes_per_group) ||
+                    (i == fs->super->s_inodes_count)) {
+                        free_array[group] = group_free;
+                        dir_array[group] = dirs_count;
+                        group ++;
+                        inodes = 0;
+                        group_free = 0;
+                        dirs_count = 0;
+                        if (ctx->progress)
+                                if ((ctx->progress)(ctx, 5,
+                                            group + fs->group_desc_count,
+                                            fs->group_desc_count*2))
+                                        return;
+                }
+        }
+        if (pctx.ino)
+                print_bitmap_problem(ctx, save_problem, &pctx);
+
+        if (had_problem)
+                fixit = end_problem_latch(ctx, PR_LATCH_IBITMAP);
+        else
+                fixit = -1;
+        ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS;
+
+        if (fixit == 1) {
+                ext2fs_free_inode_bitmap(fs->inode_map);
+                retval = ext2fs_copy_bitmap(ctx->inode_used_map,
+                                                  &fs->inode_map);
+                if (retval) {
+                        clear_problem_context(&pctx);
+                        fix_problem(ctx, PR_5_COPY_IBITMAP_ERROR, &pctx);
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return;
+                }
+                ext2fs_set_bitmap_padding(fs->inode_map);
+                ext2fs_mark_ib_dirty(fs);
+
+                /* redo counts */
+                inodes = 0; free_inodes = 0; group_free = 0;
+                dirs_count = 0; group = 0;
+                memset(free_array, 0, fs->group_desc_count * sizeof(int));
+                memset(dir_array, 0, fs->group_desc_count * sizeof(int));
+                goto redo_counts;
+        } else if (fixit == 0)
+                ext2fs_unmark_valid(fs);
+
+        for (i = 0; i < fs->group_desc_count; i++) {
+                if (free_array[i] != fs->group_desc[i].bg_free_inodes_count) {
+                        pctx.group = i;
+                        pctx.ino = fs->group_desc[i].bg_free_inodes_count;
+                        pctx.ino2 = free_array[i];
+                        if (fix_problem(ctx, PR_5_FREE_INODE_COUNT_GROUP,
+                                        &pctx)) {
+                                fs->group_desc[i].bg_free_inodes_count =
+                                        free_array[i];
+                                ext2fs_mark_super_dirty(fs);
+                        } else
+                                ext2fs_unmark_valid(fs);
+                }
+                if (dir_array[i] != fs->group_desc[i].bg_used_dirs_count) {
+                        pctx.group = i;
+                        pctx.ino = fs->group_desc[i].bg_used_dirs_count;
+                        pctx.ino2 = dir_array[i];
+
+                        if (fix_problem(ctx, PR_5_FREE_DIR_COUNT_GROUP,
+                                        &pctx)) {
+                                fs->group_desc[i].bg_used_dirs_count =
+                                        dir_array[i];
+                                ext2fs_mark_super_dirty(fs);
+                        } else
+                                ext2fs_unmark_valid(fs);
+                }
+        }
+        if (free_inodes != fs->super->s_free_inodes_count) {
+                pctx.group = -1;
+                pctx.ino = fs->super->s_free_inodes_count;
+                pctx.ino2 = free_inodes;
+
+                if (fix_problem(ctx, PR_5_FREE_INODE_COUNT, &pctx)) {
+                        fs->super->s_free_inodes_count = free_inodes;
+                        ext2fs_mark_super_dirty(fs);
+                } else
+                        ext2fs_unmark_valid(fs);
+        }
+        ext2fs_free_mem(&free_array);
+        ext2fs_free_mem(&dir_array);
+}
+
+static void check_inode_end(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        ext2_ino_t      end, save_inodes_count, i;
+        struct problem_context  pctx;
+
+        clear_problem_context(&pctx);
+
+        end = EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count;
+        pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, end,
+                                                     &save_inodes_count);
+        if (pctx.errcode) {
+                pctx.num = 1;
+                fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
+                return;
+        }
+        if (save_inodes_count == end)
+                return;
+
+        for (i = save_inodes_count + 1; i <= end; i++) {
+                if (!ext2fs_test_inode_bitmap(fs->inode_map, i)) {
+                        if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) {
+                                for (i = save_inodes_count + 1; i <= end; i++)
+                                        ext2fs_mark_inode_bitmap(fs->inode_map,
+                                                                 i);
+                                ext2fs_mark_ib_dirty(fs);
+                        } else
+                                ext2fs_unmark_valid(fs);
+                        break;
+                }
+        }
+
+        pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map,
+                                                     save_inodes_count, 0);
+        if (pctx.errcode) {
+                pctx.num = 2;
+                fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
+                return;
+        }
+}
+
+static void check_block_end(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        blk_t   end, save_blocks_count, i;
+        struct problem_context  pctx;
+
+        clear_problem_context(&pctx);
+
+        end = fs->block_map->start +
+                (EXT2_BLOCKS_PER_GROUP(fs->super) * fs->group_desc_count) - 1;
+        pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map, end,
+                                                     &save_blocks_count);
+        if (pctx.errcode) {
+                pctx.num = 3;
+                fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
+                return;
+        }
+        if (save_blocks_count == end)
+                return;
+
+        for (i = save_blocks_count + 1; i <= end; i++) {
+                if (!ext2fs_test_block_bitmap(fs->block_map, i)) {
+                        if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) {
+                                for (i = save_blocks_count + 1; i <= end; i++)
+                                        ext2fs_mark_block_bitmap(fs->block_map,
+                                                                 i);
+                                ext2fs_mark_bb_dirty(fs);
+                        } else
+                                ext2fs_unmark_valid(fs);
+                        break;
+                }
+        }
+
+        pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map,
+                                                     save_blocks_count, 0);
+        if (pctx.errcode) {
+                pctx.num = 4;
+                fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
+                return;
+        }
+}
+
+
+
+/*
+ * problem.c --- report filesystem problems to the user
+ *
+ * Copyright 1996, 1997 by Theodore Ts'o
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ */
+
+#define PR_PREEN_OK     0x000001 /* Don't need to do preenhalt */
+#define PR_NO_OK        0x000002 /* If user answers no, don't make fs invalid */
+#define PR_NO_DEFAULT   0x000004 /* Default to no */
+#define PR_MSG_ONLY     0x000008 /* Print message only */
+
+/* Bit positions 0x000ff0 are reserved for the PR_LATCH flags */
+
+#define PR_FATAL        0x001000 /* Fatal error */
+#define PR_AFTER_CODE   0x002000 /* After asking the first question, */
+                                 /* ask another */
+#define PR_PREEN_NOMSG  0x004000 /* Don't print a message if we're preening */
+#define PR_NOCOLLATE    0x008000 /* Don't collate answers for this latch */
+#define PR_NO_NOMSG     0x010000 /* Don't print a message if e2fsck -n */
+#define PR_PREEN_NO     0x020000 /* Use No as an answer if preening */
+#define PR_PREEN_NOHDR  0x040000 /* Don't print the preen header */
+
+
+#define PROMPT_NONE     0
+#define PROMPT_FIX      1
+#define PROMPT_CLEAR    2
+#define PROMPT_RELOCATE 3
+#define PROMPT_ALLOCATE 4
+#define PROMPT_EXPAND   5
+#define PROMPT_CONNECT  6
+#define PROMPT_CREATE   7
+#define PROMPT_SALVAGE  8
+#define PROMPT_TRUNCATE 9
+#define PROMPT_CLEAR_INODE 10
+#define PROMPT_ABORT    11
+#define PROMPT_SPLIT    12
+#define PROMPT_CONTINUE 13
+#define PROMPT_CLONE    14
+#define PROMPT_DELETE   15
+#define PROMPT_SUPPRESS 16
+#define PROMPT_UNLINK   17
+#define PROMPT_CLEAR_HTREE 18
+#define PROMPT_RECREATE 19
+#define PROMPT_NULL     20
+
+struct e2fsck_problem {
+        problem_t       e2p_code;
+        const char *    e2p_description;
+        char            prompt;
+        int             flags;
+        problem_t       second_code;
+};
+
+struct latch_descr {
+        int             latch_code;
+        problem_t       question;
+        problem_t       end_message;
+        int             flags;
+};
+
+/*
+ * These are the prompts which are used to ask the user if they want
+ * to fix a problem.
+ */
+static const char *prompt[] = {
+        N_("(no prompt)"),      /* 0 */
+        N_("Fix"),              /* 1 */
+        N_("Clear"),            /* 2 */
+        N_("Relocate"),         /* 3 */
+        N_("Allocate"),         /* 4 */
+        N_("Expand"),           /* 5 */
+        N_("Connect to /lost+found"), /* 6 */
+        N_("Create"),           /* 7 */
+        N_("Salvage"),          /* 8 */
+        N_("Truncate"),         /* 9 */
+        N_("Clear inode"),      /* 10 */
+        N_("Abort"),            /* 11 */
+        N_("Split"),            /* 12 */
+        N_("Continue"),         /* 13 */
+        N_("Clone duplicate/bad blocks"), /* 14 */
+        N_("Delete file"),      /* 15 */
+        N_("Suppress messages"),/* 16 */
+        N_("Unlink"),           /* 17 */
+        N_("Clear HTree index"),/* 18 */
+        N_("Recreate"),         /* 19 */
+        "",                     /* 20 */
+};
+
+/*
+ * These messages are printed when we are preen mode and we will be
+ * automatically fixing the problem.
+ */
+static const char *preen_msg[] = {
+        N_("(NONE)"),           /* 0 */
+        N_("FIXED"),            /* 1 */
+        N_("CLEARED"),          /* 2 */
+        N_("RELOCATED"),        /* 3 */
+        N_("ALLOCATED"),        /* 4 */
+        N_("EXPANDED"),         /* 5 */
+        N_("RECONNECTED"),      /* 6 */
+        N_("CREATED"),          /* 7 */
+        N_("SALVAGED"),         /* 8 */
+        N_("TRUNCATED"),        /* 9 */
+        N_("INODE CLEARED"),    /* 10 */
+        N_("ABORTED"),          /* 11 */
+        N_("SPLIT"),            /* 12 */
+        N_("CONTINUING"),       /* 13 */
+        N_("DUPLICATE/BAD BLOCKS CLONED"), /* 14 */
+        N_("FILE DELETED"),     /* 15 */
+        N_("SUPPRESSED"),       /* 16 */
+        N_("UNLINKED"),         /* 17 */
+        N_("HTREE INDEX CLEARED"),/* 18 */
+        N_("WILL RECREATE"),    /* 19 */
+        "",                     /* 20 */
+};
+
+static const struct e2fsck_problem problem_table[] = {
+
+        /* Pre-Pass 1 errors */
+
+        /* Block bitmap not in group */
+        { PR_0_BB_NOT_GROUP, N_("@b @B for @g %g is not in @g.  (@b %b)\n"),
+          PROMPT_RELOCATE, PR_LATCH_RELOC },
+
+        /* Inode bitmap not in group */
+        { PR_0_IB_NOT_GROUP, N_("@i @B for @g %g is not in @g.  (@b %b)\n"),
+          PROMPT_RELOCATE, PR_LATCH_RELOC },
+
+        /* Inode table not in group */
+        { PR_0_ITABLE_NOT_GROUP,
+          N_("@i table for @g %g is not in @g.  (@b %b)\n"
+          "WARNING: SEVERE DATA LOSS POSSIBLE.\n"),
+          PROMPT_RELOCATE, PR_LATCH_RELOC },
+
+        /* Superblock corrupt */
+        { PR_0_SB_CORRUPT,
+          N_("\nThe @S could not be read or does not describe a correct ext2\n"
+          "@f.  If the @v is valid and it really contains an ext2\n"
+          "@f (and not swap or ufs or something else), then the @S\n"
+          "is corrupt, and you might try running e2fsck with an alternate @S:\n"
+          "    e2fsck -b %S <@v>\n\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Filesystem size is wrong */
+        { PR_0_FS_SIZE_WRONG,
+          N_("The @f size (according to the @S) is %b @bs\n"
+          "The physical size of the @v is %c @bs\n"
+          "Either the @S or the partition table is likely to be corrupt!\n"),
+          PROMPT_ABORT, 0 },
+
+        /* Fragments not supported */
+        { PR_0_NO_FRAGMENTS,
+          N_("@S @b_size = %b, fragsize = %c.\n"
+          "This version of e2fsck does not support fragment sizes different\n"
+          "from the @b size.\n"),
+          PROMPT_NONE, PR_FATAL },
+
+          /* Bad blocks_per_group */
+        { PR_0_BLOCKS_PER_GROUP,
+          N_("@S @bs_per_group = %b, should have been %c\n"),
+          PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT },
+
+        /* Bad first_data_block */
+        { PR_0_FIRST_DATA_BLOCK,
+          N_("@S first_data_@b = %b, should have been %c\n"),
+          PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT },
+
+        /* Adding UUID to filesystem */
+        { PR_0_ADD_UUID,
+          N_("@f did not have a UUID; generating one.\n\n"),
+          PROMPT_NONE, 0 },
+
+        /* Relocate hint */
+        { PR_0_RELOCATE_HINT,
+          N_("Note: if there is several inode or block bitmap blocks\n"
+          "which require relocation, or one part of the inode table\n"
+          "which must be moved, you may wish to try running e2fsck\n"
+          "with the '-b %S' option first.  The problem may lie only\n"
+          "with the primary block group descriptor, and the backup\n"
+          "block group descriptor may be OK.\n\n"),
+          PROMPT_NONE, PR_PREEN_OK | PR_NOCOLLATE },
+
+        /* Miscellaneous superblock corruption */
+        { PR_0_MISC_CORRUPT_SUPER,
+          N_("Corruption found in @S.  (%s = %N).\n"),
+          PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT },
+
+        /* Error determing physical device size of filesystem */
+        { PR_0_GETSIZE_ERROR,
+          N_("Error determining size of the physical @v: %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Inode count in superblock is incorrect */
+        { PR_0_INODE_COUNT_WRONG,
+          N_("@i count in @S is %i, should be %j.\n"),
+          PROMPT_FIX, 0 },
+
+        { PR_0_HURD_CLEAR_FILETYPE,
+          N_("The Hurd does not support the filetype feature.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* Journal inode is invalid */
+        { PR_0_JOURNAL_BAD_INODE,
+          N_("@S has a bad ext3 @j (@i %i).\n"),
+          PROMPT_CLEAR, PR_PREEN_OK },
+
+        /* The external journal has (unsupported) multiple filesystems */
+        { PR_0_JOURNAL_UNSUPP_MULTIFS,
+          N_("External @j has multiple @f users (unsupported).\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Can't find external journal */
+        { PR_0_CANT_FIND_JOURNAL,
+          N_("Can't find external @j\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* External journal has bad superblock */
+        { PR_0_EXT_JOURNAL_BAD_SUPER,
+          N_("External @j has bad @S\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Superblock has a bad journal UUID */
+        { PR_0_JOURNAL_BAD_UUID,
+          N_("External @j does not support this @f\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Journal has an unknown superblock type */
+        { PR_0_JOURNAL_UNSUPP_SUPER,
+          N_("Ext3 @j @S is unknown type %N (unsupported).\n"
+             "It is likely that your copy of e2fsck is old and/or doesn't "
+             "support this @j format.\n"
+             "It is also possible the @j @S is corrupt.\n"),
+          PROMPT_ABORT, PR_NO_OK | PR_AFTER_CODE, PR_0_JOURNAL_BAD_SUPER },
+
+        /* Journal superblock is corrupt */
+        { PR_0_JOURNAL_BAD_SUPER,
+          N_("Ext3 @j @S is corrupt.\n"),
+          PROMPT_FIX, PR_PREEN_OK },
+
+        /* Superblock flag should be cleared */
+        { PR_0_JOURNAL_HAS_JOURNAL,
+          N_("@S doesn't have has_@j flag, but has ext3 @j %s.\n"),
+          PROMPT_CLEAR, PR_PREEN_OK },
+
+        /* Superblock flag is incorrect */
+        { PR_0_JOURNAL_RECOVER_SET,
+          N_("@S has ext3 needs_recovery flag set, but no @j.\n"),
+          PROMPT_CLEAR, PR_PREEN_OK },
+
+        /* Journal has data, but recovery flag is clear */
+        { PR_0_JOURNAL_RECOVERY_CLEAR,
+          N_("ext3 recovery flag clear, but @j has data.\n"),
+          PROMPT_NONE, 0 },
+
+        /* Ask if we should clear the journal */
+        { PR_0_JOURNAL_RESET_JOURNAL,
+          N_("Clear @j"),
+          PROMPT_NULL, PR_PREEN_NOMSG },
+
+        /* Ask if we should run the journal anyway */
+        { PR_0_JOURNAL_RUN,
+          N_("Run @j anyway"),
+          PROMPT_NULL, 0 },
+
+        /* Run the journal by default */
+        { PR_0_JOURNAL_RUN_DEFAULT,
+          N_("Recovery flag not set in backup @S, so running @j anyway.\n"),
+          PROMPT_NONE, 0 },
+
+        /* Clearing orphan inode */
+        { PR_0_ORPHAN_CLEAR_INODE,
+          N_("%s @o @i %i (uid=%Iu, gid=%Ig, mode=%Im, size=%Is)\n"),
+          PROMPT_NONE, 0 },
+
+        /* Illegal block found in orphaned inode */
+        { PR_0_ORPHAN_ILLEGAL_BLOCK_NUM,
+           N_("@I @b #%B (%b) found in @o @i %i.\n"),
+          PROMPT_NONE, 0 },
+
+        /* Already cleared block found in orphaned inode */
+        { PR_0_ORPHAN_ALREADY_CLEARED_BLOCK,
+           N_("Already cleared @b #%B (%b) found in @o @i %i.\n"),
+          PROMPT_NONE, 0 },
+
+        /* Illegal orphan inode in superblock */
+        { PR_0_ORPHAN_ILLEGAL_HEAD_INODE,
+          N_("@I @o @i %i in @S.\n"),
+          PROMPT_NONE, 0 },
+
+        /* Illegal inode in orphaned inode list */
+        { PR_0_ORPHAN_ILLEGAL_INODE,
+          N_("@I @i %i in @o @i list.\n"),
+          PROMPT_NONE, 0 },
+
+        /* Filesystem revision is 0, but feature flags are set */
+        { PR_0_FS_REV_LEVEL,
+          "@f has feature flag(s) set, but is a revision 0 @f.  ",
+          PROMPT_FIX, PR_PREEN_OK | PR_NO_OK },
+
+        /* Journal superblock has an unknown read-only feature flag set */
+        { PR_0_JOURNAL_UNSUPP_ROCOMPAT,
+          N_("Ext3 @j @S has an unknown read-only feature flag set.\n"),
+          PROMPT_ABORT, 0 },
+
+        /* Journal superblock has an unknown incompatible feature flag set */
+        { PR_0_JOURNAL_UNSUPP_INCOMPAT,
+          N_("Ext3 @j @S has an unknown incompatible feature flag set.\n"),
+          PROMPT_ABORT, 0 },
+
+        /* Journal has unsupported version number */
+        { PR_0_JOURNAL_UNSUPP_VERSION,
+          N_("@j version not supported by this e2fsck.\n"),
+          PROMPT_ABORT, 0 },
+
+        /* Moving journal to hidden file */
+        { PR_0_MOVE_JOURNAL,
+          N_("Moving @j from /%s to hidden inode.\n\n"),
+          PROMPT_NONE, 0 },
+
+        /* Error moving journal to hidden file */
+        { PR_0_ERR_MOVE_JOURNAL,
+          N_("Error moving @j: %m\n\n"),
+          PROMPT_NONE, 0 },
+
+        /* Clearing V2 journal superblock */
+        { PR_0_CLEAR_V2_JOURNAL,
+          N_("Found invalid V2 @j @S fields (from V1 journal).\n"
+             "Clearing fields beyond the V1 @j @S...\n\n"),
+          PROMPT_NONE, 0 },
+
+        /* Backup journal inode blocks */
+        { PR_0_BACKUP_JNL,
+          N_("Backing up @j @i @b information.\n\n"),
+          PROMPT_NONE, 0 },
+
+        /* Reserved blocks w/o resize_inode */
+        { PR_0_NONZERO_RESERVED_GDT_BLOCKS,
+          N_("@f does not have resize_@i enabled, but s_reserved_gdt_@bs\n"
+             "is %N; @s zero.  "),
+          PROMPT_FIX, 0 },
+
+        /* Resize_inode not enabled, but resize inode is non-zero */
+        { PR_0_CLEAR_RESIZE_INODE,
+          N_("Resize_@i not enabled, but the resize inode is non-zero.  "),
+          PROMPT_CLEAR, 0 },
+
+        /* Resize inode invalid */
+        { PR_0_RESIZE_INODE_INVALID,
+          N_("Resize @i not valid.  "),
+          PROMPT_RECREATE, 0 },
+
+        /* Pass 1 errors */
+
+        /* Pass 1: Checking inodes, blocks, and sizes */
+        { PR_1_PASS_HEADER,
+          N_("Pass 1: Checking @is, @bs, and sizes\n"),
+          PROMPT_NONE, 0 },
+
+        /* Root directory is not an inode */
+        { PR_1_ROOT_NO_DIR, N_("@r is not a @d.  "),
+          PROMPT_CLEAR, 0 },
+
+        /* Root directory has dtime set */
+        { PR_1_ROOT_DTIME,
+          N_("@r has dtime set (probably due to old mke2fs).  "),
+          PROMPT_FIX, PR_PREEN_OK },
+
+        /* Reserved inode has bad mode */
+        { PR_1_RESERVED_BAD_MODE,
+          N_("Reserved @i %i %Q has bad mode.  "),
+          PROMPT_CLEAR, PR_PREEN_OK },
+
+        /* Deleted inode has zero dtime */
+        { PR_1_ZERO_DTIME,
+          N_("@D @i %i has zero dtime.  "),
+          PROMPT_FIX, PR_PREEN_OK },
+
+        /* Inode in use, but dtime set */
+        { PR_1_SET_DTIME,
+          N_("@i %i is in use, but has dtime set.  "),
+          PROMPT_FIX, PR_PREEN_OK },
+
+        /* Zero-length directory */
+        { PR_1_ZERO_LENGTH_DIR,
+          N_("@i %i is a @z @d.  "),
+          PROMPT_CLEAR, PR_PREEN_OK },
+
+        /* Block bitmap conflicts with some other fs block */
+        { PR_1_BB_CONFLICT,
+          N_("@g %g's @b @B at %b @C.\n"),
+          PROMPT_RELOCATE, 0 },
+
+        /* Inode bitmap conflicts with some other fs block */
+        { PR_1_IB_CONFLICT,
+          N_("@g %g's @i @B at %b @C.\n"),
+          PROMPT_RELOCATE, 0 },
+
+        /* Inode table conflicts with some other fs block */
+        { PR_1_ITABLE_CONFLICT,
+          N_("@g %g's @i table at %b @C.\n"),
+          PROMPT_RELOCATE, 0 },
+
+        /* Block bitmap is on a bad block */
+        { PR_1_BB_BAD_BLOCK,
+          N_("@g %g's @b @B (%b) is bad.  "),
+          PROMPT_RELOCATE, 0 },
+
+        /* Inode bitmap is on a bad block */
+        { PR_1_IB_BAD_BLOCK,
+          N_("@g %g's @i @B (%b) is bad.  "),
+          PROMPT_RELOCATE, 0 },
+
+        /* Inode has incorrect i_size */
+        { PR_1_BAD_I_SIZE,
+          N_("@i %i, i_size is %Is, @s %N.  "),
+          PROMPT_FIX, PR_PREEN_OK },
+
+        /* Inode has incorrect i_blocks */
+        { PR_1_BAD_I_BLOCKS,
+          N_("@i %i, i_@bs is %Ib, @s %N.  "),
+          PROMPT_FIX, PR_PREEN_OK },
+
+        /* Illegal blocknumber in inode */
+        { PR_1_ILLEGAL_BLOCK_NUM,
+          N_("@I @b #%B (%b) in @i %i.  "),
+          PROMPT_CLEAR, PR_LATCH_BLOCK },
+
+        /* Block number overlaps fs metadata */
+        { PR_1_BLOCK_OVERLAPS_METADATA,
+          N_("@b #%B (%b) overlaps @f metadata in @i %i.  "),
+          PROMPT_CLEAR, PR_LATCH_BLOCK },
+
+        /* Inode has illegal blocks (latch question) */
+        { PR_1_INODE_BLOCK_LATCH,
+          N_("@i %i has illegal @b(s).  "),
+          PROMPT_CLEAR, 0 },
+
+        /* Too many bad blocks in inode */
+        { PR_1_TOO_MANY_BAD_BLOCKS,
+          N_("Too many illegal @bs in @i %i.\n"),
+          PROMPT_CLEAR_INODE, PR_NO_OK },
+
+        /* Illegal block number in bad block inode */
+        { PR_1_BB_ILLEGAL_BLOCK_NUM,
+          N_("@I @b #%B (%b) in bad @b @i.  "),
+          PROMPT_CLEAR, PR_LATCH_BBLOCK },
+
+        /* Bad block inode has illegal blocks (latch question) */
+        { PR_1_INODE_BBLOCK_LATCH,
+          N_("Bad @b @i has illegal @b(s).  "),
+          PROMPT_CLEAR, 0 },
+
+        /* Duplicate or bad blocks in use! */
+        { PR_1_DUP_BLOCKS_PREENSTOP,
+          N_("Duplicate or bad @b in use!\n"),
+          PROMPT_NONE, 0 },
+
+        /* Bad block used as bad block indirect block */
+        { PR_1_BBINODE_BAD_METABLOCK,
+          N_("Bad @b %b used as bad @b @i indirect @b.  "),
+          PROMPT_CLEAR, PR_LATCH_BBLOCK },
+
+        /* Inconsistency can't be fixed prompt */
+        { PR_1_BBINODE_BAD_METABLOCK_PROMPT,
+          N_("\nThe bad @b @i has probably been corrupted.  You probably\n"
+             "should stop now and run ""e2fsck -c"" to scan for bad blocks\n"
+             "in the @f.\n"),
+          PROMPT_CONTINUE, PR_PREEN_NOMSG },
+
+        /* Bad primary block */
+        { PR_1_BAD_PRIMARY_BLOCK,
+          N_("\nIf the @b is really bad, the @f can not be fixed.\n"),
+          PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK_PROMPT },
+
+        /* Bad primary block prompt */
+        { PR_1_BAD_PRIMARY_BLOCK_PROMPT,
+          N_("You can clear the this @b (and hope for the best) from the\n"
+          "bad @b list and hope that @b is really OK, but there are no\n"
+          "guarantees.\n\n"),
+          PROMPT_CLEAR, PR_PREEN_NOMSG },
+
+        /* Bad primary superblock */
+        { PR_1_BAD_PRIMARY_SUPERBLOCK,
+          N_("The primary @S (%b) is on the bad @b list.\n"),
+          PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK },
+
+        /* Bad primary block group descriptors */
+        { PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR,
+          N_("Block %b in the primary @g descriptors "
+          "is on the bad @b list\n"),
+          PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK },
+
+        /* Bad superblock in group */
+        { PR_1_BAD_SUPERBLOCK,
+          N_("Warning: Group %g's @S (%b) is bad.\n"),
+          PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Bad block group descriptors in group */
+        { PR_1_BAD_GROUP_DESCRIPTORS,
+          N_("Warning: Group %g's copy of the @g descriptors has a bad "
+          "@b (%b).\n"),
+          PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Block claimed for no reason */
+        { PR_1_PROGERR_CLAIMED_BLOCK,
+          N_("Programming error?  @b #%b claimed for no reason in "
+          "process_bad_@b.\n"),
+          PROMPT_NONE, PR_PREEN_OK },
+
+        /* Error allocating blocks for relocating metadata */
+        { PR_1_RELOC_BLOCK_ALLOCATE,
+          N_("@A %N contiguous @b(s) in @b @g %g for %s: %m\n"),
+          PROMPT_NONE, PR_PREEN_OK },
+
+        /* Error allocating block buffer during relocation process */
+        { PR_1_RELOC_MEMORY_ALLOCATE,
+          N_("@A @b buffer for relocating %s\n"),
+          PROMPT_NONE, PR_PREEN_OK },
+
+        /* Relocating metadata group information from X to Y */
+        { PR_1_RELOC_FROM_TO,
+          N_("Relocating @g %g's %s from %b to %c...\n"),
+          PROMPT_NONE, PR_PREEN_OK },
+
+        /* Relocating metatdata group information to X */
+        { PR_1_RELOC_TO,
+          N_("Relocating @g %g's %s to %c...\n"), /* xgettext:no-c-format */
+          PROMPT_NONE, PR_PREEN_OK },
+
+        /* Block read error during relocation process */
+        { PR_1_RELOC_READ_ERR,
+          N_("Warning: could not read @b %b of %s: %m\n"),
+          PROMPT_NONE, PR_PREEN_OK },
+
+        /* Block write error during relocation process */
+        { PR_1_RELOC_WRITE_ERR,
+          N_("Warning: could not write @b %b for %s: %m\n"),
+          PROMPT_NONE, PR_PREEN_OK },
+
+        /* Error allocating inode bitmap */
+        { PR_1_ALLOCATE_IBITMAP_ERROR,
+          "@A @i @B (%N): %m\n",
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error allocating block bitmap */
+        { PR_1_ALLOCATE_BBITMAP_ERROR,
+          "@A @b @B (%N): %m\n",
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error allocating icount structure */
+        { PR_1_ALLOCATE_ICOUNT,
+          N_("@A icount link information: %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error allocating dbcount */
+        { PR_1_ALLOCATE_DBCOUNT,
+          N_("@A @d @b array: %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error while scanning inodes */
+        { PR_1_ISCAN_ERROR,
+          N_("Error while scanning @is (%i): %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error while iterating over blocks */
+        { PR_1_BLOCK_ITERATE,
+          N_("Error while iterating over @bs in @i %i: %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error while storing inode count information */
+        { PR_1_ICOUNT_STORE,
+          N_("Error storing @i count information (@i=%i, count=%N): %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error while storing directory block information */
+        { PR_1_ADD_DBLOCK,
+          N_("Error storing @d @b information "
+          "(@i=%i, @b=%b, num=%N): %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error while reading inode (for clearing) */
+        { PR_1_READ_INODE,
+          N_("Error reading @i %i: %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Suppress messages prompt */
+        { PR_1_SUPPRESS_MESSAGES, "", PROMPT_SUPPRESS, PR_NO_OK },
+
+        /* Imagic flag set on an inode when filesystem doesn't support it */
+        { PR_1_SET_IMAGIC,
+          N_("@i %i has imagic flag set.  "),
+          PROMPT_CLEAR, 0 },
+
+        /* Immutable flag set on a device or socket inode */
+        { PR_1_SET_IMMUTABLE,
+          N_("Special (@v/socket/fifo/symlink) file (@i %i) has immutable\n"
+             "or append-only flag set.  "),
+          PROMPT_CLEAR, PR_PREEN_OK | PR_PREEN_NO | PR_NO_OK },
+
+        /* Compression flag set on an inode when filesystem doesn't support it */
+        { PR_1_COMPR_SET,
+          N_("@i %i has @cion flag set on @f without @cion support.  "),
+          PROMPT_CLEAR, 0 },
+
+        /* Non-zero size for device, fifo or socket inode */
+        { PR_1_SET_NONZSIZE,
+          "Special (@v/socket/fifo) @i %i has non-zero size.  ",
+          PROMPT_FIX, PR_PREEN_OK },
+
+        /* Filesystem revision is 0, but feature flags are set */
+        { PR_1_FS_REV_LEVEL,
+          "@f has feature flag(s) set, but is a revision 0 @f.  ",
+          PROMPT_FIX, PR_PREEN_OK | PR_NO_OK },
+
+        /* Journal inode is not in use, but contains data */
+        { PR_1_JOURNAL_INODE_NOT_CLEAR,
+          "@j @i is not in use, but contains data.  ",
+          PROMPT_CLEAR, PR_PREEN_OK },
+
+        /* Journal has bad mode */
+        { PR_1_JOURNAL_BAD_MODE,
+          N_("@j is not regular file.  "),
+          PROMPT_FIX, PR_PREEN_OK },
+
+        /* Deal with inodes that were part of orphan linked list */
+        { PR_1_LOW_DTIME,
+          N_("@i %i was part of the orphaned @i list.  "),
+          PROMPT_FIX, PR_LATCH_LOW_DTIME, 0 },
+
+        /* Deal with inodes that were part of corrupted orphan linked
+           list (latch question) */
+        { PR_1_ORPHAN_LIST_REFUGEES,
+          N_("@is that were part of a corrupted orphan linked list found.  "),
+          PROMPT_FIX, 0 },
+
+        /* Error allocating refcount structure */
+        { PR_1_ALLOCATE_REFCOUNT,
+          "@A refcount structure (%N): %m\n",
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error reading extended attribute block */
+        { PR_1_READ_EA_BLOCK,
+          N_("Error reading @a @b %b for @i %i.  "),
+          PROMPT_CLEAR, 0 },
+
+        /* Invalid extended attribute block */
+        { PR_1_BAD_EA_BLOCK,
+          N_("@i %i has a bad @a @b %b.  "),
+          PROMPT_CLEAR, 0 },
+
+        /* Error reading Extended Attribute block while fixing refcount */
+        { PR_1_EXTATTR_READ_ABORT,
+          N_("Error reading @a @b %b (%m).  "),
+          PROMPT_ABORT, 0 },
+
+        /* Extended attribute reference count incorrect */
+        { PR_1_EXTATTR_REFCOUNT,
+          N_("@a @b %b has reference count %B, should be %N.  "),
+          PROMPT_FIX, 0 },
+
+        /* Error writing Extended Attribute block while fixing refcount */
+        { PR_1_EXTATTR_WRITE,
+          N_("Error writing @a @b %b (%m).  "),
+          PROMPT_ABORT, 0 },
+
+        /* Multiple EA blocks not supported */
+        { PR_1_EA_MULTI_BLOCK,
+          N_("@a @b %b has h_blocks > 1.  "),
+          PROMPT_CLEAR, 0},
+
+        /* Error allocating EA region allocation structure */
+        { PR_1_EA_ALLOC_REGION,
+          N_("Error allocating @a @b %b.  "),
+          PROMPT_ABORT, 0},
+
+        /* Error EA allocation collision */
+        { PR_1_EA_ALLOC_COLLISION,
+          N_("@a @b %b is corrupt (allocation collision).  "),
+          PROMPT_CLEAR, 0},
+
+        /* Bad extended attribute name */
+        { PR_1_EA_BAD_NAME,
+          N_("@a @b %b is corrupt (invalid name).  "),
+          PROMPT_CLEAR, 0},
+
+        /* Bad extended attribute value */
+        { PR_1_EA_BAD_VALUE,
+          N_("@a @b %b is corrupt (invalid value).  "),
+          PROMPT_CLEAR, 0},
+
+        /* Inode too big (latch question) */
+        { PR_1_INODE_TOOBIG,
+          N_("@i %i is too big.  "), PROMPT_TRUNCATE, 0 },
+
+        /* Directory too big */
+        { PR_1_TOOBIG_DIR,
+          N_("@b #%B (%b) causes @d to be too big.  "),
+          PROMPT_CLEAR, PR_LATCH_TOOBIG },
+
+        /* Regular file too big */
+        { PR_1_TOOBIG_REG,
+          N_("@b #%B (%b) causes file to be too big.  "),
+          PROMPT_CLEAR, PR_LATCH_TOOBIG },
+
+        /* Symlink too big */
+        { PR_1_TOOBIG_SYMLINK,
+          N_("@b #%B (%b) causes symlink to be too big.  "),
+          PROMPT_CLEAR, PR_LATCH_TOOBIG },
+
+        /* INDEX_FL flag set on a non-HTREE filesystem */
+        { PR_1_HTREE_SET,
+          N_("@i %i has INDEX_FL flag set on @f without htree support.\n"),
+          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
+
+        /* INDEX_FL flag set on a non-directory */
+        { PR_1_HTREE_NODIR,
+          N_("@i %i has INDEX_FL flag set but is not a @d.\n"),
+          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
+
+        /* Invalid root node in HTREE directory */
+        { PR_1_HTREE_BADROOT,
+          N_("@h %i has an invalid root node.\n"),
+          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
+
+        /* Unsupported hash version in HTREE directory */
+        { PR_1_HTREE_HASHV,
+          N_("@h %i has an unsupported hash version (%N)\n"),
+          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
+
+        /* Incompatible flag in HTREE root node */
+        { PR_1_HTREE_INCOMPAT,
+          N_("@h %i uses an incompatible htree root node flag.\n"),
+          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
+
+        /* HTREE too deep */
+        { PR_1_HTREE_DEPTH,
+          N_("@h %i has a tree depth (%N) which is too big\n"),
+          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
+
+        /* Bad block has indirect block that conflicts with filesystem block */
+        { PR_1_BB_FS_BLOCK,
+          N_("Bad @b @i has an indirect @b (%b) that conflicts with\n"
+             "@f metadata.  "),
+          PROMPT_CLEAR, PR_LATCH_BBLOCK },
+
+        /* Resize inode failed */
+        { PR_1_RESIZE_INODE_CREATE,
+          N_("Resize @i (re)creation failed: %m."),
+          PROMPT_ABORT, 0 },
+
+        /* invalid inode->i_extra_isize */
+        { PR_1_EXTRA_ISIZE,
+          N_("@i %i has a extra size (%IS) which is invalid\n"),
+          PROMPT_FIX, PR_PREEN_OK },
+
+        /* invalid ea entry->e_name_len */
+        { PR_1_ATTR_NAME_LEN,
+          N_("@a in @i %i has a namelen (%N) which is invalid\n"),
+          PROMPT_CLEAR, PR_PREEN_OK },
+
+        /* invalid ea entry->e_value_size */
+        { PR_1_ATTR_VALUE_SIZE,
+          N_("@a in @i %i has a value size (%N) which is invalid\n"),
+          PROMPT_CLEAR, PR_PREEN_OK },
+
+        /* invalid ea entry->e_value_offs */
+        { PR_1_ATTR_VALUE_OFFSET,
+          N_("@a in @i %i has a value offset (%N) which is invalid\n"),
+          PROMPT_CLEAR, PR_PREEN_OK },
+
+        /* invalid ea entry->e_value_block */
+        { PR_1_ATTR_VALUE_BLOCK,
+          N_("@a in @i %i has a value block (%N) which is invalid (must be 0)\n"),
+          PROMPT_CLEAR, PR_PREEN_OK },
+
+        /* invalid ea entry->e_hash */
+        { PR_1_ATTR_HASH,
+          N_("@a in @i %i has a hash (%N) which is invalid (must be 0)\n"),
+          PROMPT_CLEAR, PR_PREEN_OK },
+
+        /* Pass 1b errors */
+
+        /* Pass 1B: Rescan for duplicate/bad blocks */
+        { PR_1B_PASS_HEADER,
+          N_("Duplicate @bs found... invoking duplicate @b passes.\n"
+          "Pass 1B: Rescan for duplicate/bad @bs\n"),
+          PROMPT_NONE, 0 },
+
+        /* Duplicate/bad block(s) header */
+        { PR_1B_DUP_BLOCK_HEADER,
+          N_("Duplicate/bad @b(s) in @i %i:"),
+          PROMPT_NONE, 0 },
+
+        /* Duplicate/bad block(s) in inode */
+        { PR_1B_DUP_BLOCK,
+          " %b",
+          PROMPT_NONE, PR_LATCH_DBLOCK | PR_PREEN_NOHDR },
+
+        /* Duplicate/bad block(s) end */
+        { PR_1B_DUP_BLOCK_END,
+          "\n",
+          PROMPT_NONE, PR_PREEN_NOHDR },
+
+        /* Error while scanning inodes */
+        { PR_1B_ISCAN_ERROR,
+          N_("Error while scanning inodes (%i): %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error allocating inode bitmap */
+        { PR_1B_ALLOCATE_IBITMAP_ERROR,
+          N_("@A @i @B (inode_dup_map): %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error while iterating over blocks */
+        { PR_1B_BLOCK_ITERATE,
+          N_("Error while iterating over @bs in @i %i (%s): %m\n"),
+          PROMPT_NONE, 0 },
+
+        /* Error adjusting EA refcount */
+        { PR_1B_ADJ_EA_REFCOUNT,
+          N_("Error addjusting refcount for @a @b %b (@i %i): %m\n"),
+          PROMPT_NONE, 0 },
+
+
+        /* Pass 1C: Scan directories for inodes with dup blocks. */
+        { PR_1C_PASS_HEADER,
+          N_("Pass 1C: Scan directories for @is with dup @bs.\n"),
+          PROMPT_NONE, 0 },
+
+
+        /* Pass 1D: Reconciling duplicate blocks */
+        { PR_1D_PASS_HEADER,
+          N_("Pass 1D: Reconciling duplicate @bs\n"),
+          PROMPT_NONE, 0 },
+
+        /* File has duplicate blocks */
+        { PR_1D_DUP_FILE,
+          N_("File %Q (@i #%i, mod time %IM) \n"
+          "  has %B duplicate @b(s), shared with %N file(s):\n"),
+          PROMPT_NONE, 0 },
+
+        /* List of files sharing duplicate blocks */
+        { PR_1D_DUP_FILE_LIST,
+          N_("\t%Q (@i #%i, mod time %IM)\n"),
+          PROMPT_NONE, 0 },
+
+        /* File sharing blocks with filesystem metadata  */
+        { PR_1D_SHARE_METADATA,
+          N_("\t<@f metadata>\n"),
+          PROMPT_NONE, 0 },
+
+        /* Report of how many duplicate/bad inodes */
+        { PR_1D_NUM_DUP_INODES,
+          N_("(There are %N @is containing duplicate/bad @bs.)\n\n"),
+          PROMPT_NONE, 0 },
+
+        /* Duplicated blocks already reassigned or cloned. */
+        { PR_1D_DUP_BLOCKS_DEALT,
+          N_("Duplicated @bs already reassigned or cloned.\n\n"),
+          PROMPT_NONE, 0 },
+
+        /* Clone duplicate/bad blocks? */
+        { PR_1D_CLONE_QUESTION,
+          "", PROMPT_CLONE, PR_NO_OK },
+
+        /* Delete file? */
+        { PR_1D_DELETE_QUESTION,
+          "", PROMPT_DELETE, 0 },
+
+        /* Couldn't clone file (error) */
+        { PR_1D_CLONE_ERROR,
+          N_("Couldn't clone file: %m\n"), PROMPT_NONE, 0 },
+
+        /* Pass 2 errors */
+
+        /* Pass 2: Checking directory structure */
+        { PR_2_PASS_HEADER,
+          N_("Pass 2: Checking @d structure\n"),
+          PROMPT_NONE, 0 },
+
+        /* Bad inode number for '.' */
+        { PR_2_BAD_INODE_DOT,
+          N_("Bad @i number for '.' in @d @i %i.\n"),
+          PROMPT_FIX, 0 },
+
+        /* Directory entry has bad inode number */
+        { PR_2_BAD_INO,
+          N_("@E has bad @i #: %Di.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* Directory entry has deleted or unused inode */
+        { PR_2_UNUSED_INODE,
+          N_("@E has @D/unused @i %Di.  "),
+          PROMPT_CLEAR, PR_PREEN_OK },
+
+        /* Directry entry is link to '.' */
+        { PR_2_LINK_DOT,
+          N_("@E @L to '.'  "),
+          PROMPT_CLEAR, 0 },
+
+        /* Directory entry points to inode now located in a bad block */
+        { PR_2_BB_INODE,
+          N_("@E points to @i (%Di) located in a bad @b.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* Directory entry contains a link to a directory */
+        { PR_2_LINK_DIR,
+          N_("@E @L to @d %P (%Di).\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* Directory entry contains a link to the root directry */
+        { PR_2_LINK_ROOT,
+          N_("@E @L to the @r.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* Directory entry has illegal characters in its name */
+        { PR_2_BAD_NAME,
+          N_("@E has illegal characters in its name.\n"),
+          PROMPT_FIX, 0 },
+
+        /* Missing '.' in directory inode */
+        { PR_2_MISSING_DOT,
+          N_("Missing '.' in @d @i %i.\n"),
+          PROMPT_FIX, 0 },
+
+        /* Missing '..' in directory inode */
+        { PR_2_MISSING_DOT_DOT,
+          N_("Missing '..' in @d @i %i.\n"),
+          PROMPT_FIX, 0 },
+
+        /* First entry in directory inode doesn't contain '.' */
+        { PR_2_1ST_NOT_DOT,
+          N_("First @e '%Dn' (inode=%Di) in @d @i %i (%p) @s '.'\n"),
+          PROMPT_FIX, 0 },
+
+        /* Second entry in directory inode doesn't contain '..' */
+        { PR_2_2ND_NOT_DOT_DOT,
+          N_("Second @e '%Dn' (inode=%Di) in @d @i %i @s '..'\n"),
+          PROMPT_FIX, 0 },
+
+        /* i_faddr should be zero */
+        { PR_2_FADDR_ZERO,
+          N_("i_faddr @F %IF, @s zero.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* i_file_acl should be zero */
+        { PR_2_FILE_ACL_ZERO,
+          N_("i_file_acl @F %If, @s zero.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* i_dir_acl should be zero */
+        { PR_2_DIR_ACL_ZERO,
+          N_("i_dir_acl @F %Id, @s zero.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* i_frag should be zero */
+        { PR_2_FRAG_ZERO,
+          N_("i_frag @F %N, @s zero.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* i_fsize should be zero */
+        { PR_2_FSIZE_ZERO,
+          N_("i_fsize @F %N, @s zero.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* inode has bad mode */
+        { PR_2_BAD_MODE,
+          N_("@i %i (%Q) has a bad mode (%Im).\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* directory corrupted */
+        { PR_2_DIR_CORRUPTED,
+          N_("@d @i %i, @b %B, offset %N: @d corrupted\n"),
+          PROMPT_SALVAGE, 0 },
+
+        /* filename too long */
+        { PR_2_FILENAME_LONG,
+          N_("@d @i %i, @b %B, offset %N: filename too long\n"),
+          PROMPT_TRUNCATE, 0 },
+
+        /* Directory inode has a missing block (hole) */
+        { PR_2_DIRECTORY_HOLE,
+          N_("@d @i %i has an unallocated @b #%B.  "),
+          PROMPT_ALLOCATE, 0 },
+
+        /* '.' is not NULL terminated */
+        { PR_2_DOT_NULL_TERM,
+          N_("'.' @d @e in @d @i %i is not NULL terminated\n"),
+          PROMPT_FIX, 0 },
+
+        /* '..' is not NULL terminated */
+        { PR_2_DOT_DOT_NULL_TERM,
+          N_("'..' @d @e in @d @i %i is not NULL terminated\n"),
+          PROMPT_FIX, 0 },
+
+        /* Illegal character device inode */
+        { PR_2_BAD_CHAR_DEV,
+          N_("@i %i (%Q) is an @I character @v.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* Illegal block device inode */
+        { PR_2_BAD_BLOCK_DEV,
+          N_("@i %i (%Q) is an @I @b @v.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* Duplicate '.' entry */
+        { PR_2_DUP_DOT,
+          N_("@E is duplicate '.' @e.\n"),
+          PROMPT_FIX, 0 },
+
+        /* Duplicate '..' entry */
+        { PR_2_DUP_DOT_DOT,
+          N_("@E is duplicate '..' @e.\n"),
+          PROMPT_FIX, 0 },
+
+        /* Internal error: couldn't find dir_info */
+        { PR_2_NO_DIRINFO,
+          N_("Internal error: couldn't find dir_info for %i.\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Final rec_len is wrong */
+        { PR_2_FINAL_RECLEN,
+          N_("@E has rec_len of %Dr, should be %N.\n"),
+          PROMPT_FIX, 0 },
+
+        /* Error allocating icount structure */
+        { PR_2_ALLOCATE_ICOUNT,
+          N_("@A icount structure: %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error iterating over directory blocks */
+        { PR_2_DBLIST_ITERATE,
+          N_("Error iterating over @d @bs: %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error reading directory block */
+        { PR_2_READ_DIRBLOCK,
+          N_("Error reading @d @b %b (@i %i): %m\n"),
+          PROMPT_CONTINUE, 0 },
+
+        /* Error writing directory block */
+        { PR_2_WRITE_DIRBLOCK,
+          N_("Error writing @d @b %b (@i %i): %m\n"),
+          PROMPT_CONTINUE, 0 },
+
+        /* Error allocating new directory block */
+        { PR_2_ALLOC_DIRBOCK,
+          N_("@A new @d @b for @i %i (%s): %m\n"),
+          PROMPT_NONE, 0 },
+
+        /* Error deallocating inode */
+        { PR_2_DEALLOC_INODE,
+          N_("Error deallocating @i %i: %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Directory entry for '.' is big.  Split? */
+        { PR_2_SPLIT_DOT,
+          N_("@d @e for '.' is big.  "),
+          PROMPT_SPLIT, PR_NO_OK },
+
+        /* Illegal FIFO inode */
+        { PR_2_BAD_FIFO,
+          N_("@i %i (%Q) is an @I FIFO.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* Illegal socket inode */
+        { PR_2_BAD_SOCKET,
+          N_("@i %i (%Q) is an @I socket.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* Directory filetype not set */
+        { PR_2_SET_FILETYPE,
+          N_("Setting filetype for @E to %N.\n"),
+          PROMPT_NONE, PR_PREEN_OK | PR_NO_OK | PR_NO_NOMSG },
+
+        /* Directory filetype incorrect */
+        { PR_2_BAD_FILETYPE,
+          N_("@E has an incorrect filetype (was %Dt, should be %N).\n"),
+          PROMPT_FIX, 0 },
+
+        /* Directory filetype set on filesystem */
+        { PR_2_CLEAR_FILETYPE,
+          N_("@E has filetype set.\n"),
+          PROMPT_CLEAR, PR_PREEN_OK },
+
+        /* Directory filename is null */
+        { PR_2_NULL_NAME,
+          N_("@E has a zero-length name.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* Invalid symlink */
+        { PR_2_INVALID_SYMLINK,
+          N_("Symlink %Q (@i #%i) is invalid.\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* i_file_acl (extended attribute block) is bad */
+        { PR_2_FILE_ACL_BAD,
+          N_("@a @b @F invalid (%If).\n"),
+          PROMPT_CLEAR, 0 },
+
+        /* Filesystem contains large files, but has no such flag in sb */
+        { PR_2_FEATURE_LARGE_FILES,
+          N_("@f contains large files, but lacks LARGE_FILE flag in @S.\n"),
+          PROMPT_FIX, 0 },
+
+        /* Node in HTREE directory not referenced */
+        { PR_2_HTREE_NOTREF,
+          N_("@p @h %d: node (%B) not referenced\n"),
+          PROMPT_NONE, 0 },
+
+        /* Node in HTREE directory referenced twice */
+        { PR_2_HTREE_DUPREF,
+          N_("@p @h %d: node (%B) referenced twice\n"),
+          PROMPT_NONE, 0 },
+
+        /* Node in HTREE directory has bad min hash */
+        { PR_2_HTREE_MIN_HASH,
+          N_("@p @h %d: node (%B) has bad min hash\n"),
+          PROMPT_NONE, 0 },
+
+        /* Node in HTREE directory has bad max hash */
+        { PR_2_HTREE_MAX_HASH,
+          N_("@p @h %d: node (%B) has bad max hash\n"),
+          PROMPT_NONE, 0 },
+
+        /* Clear invalid HTREE directory */
+        { PR_2_HTREE_CLEAR,
+          N_("Invalid @h %d (%q).  "), PROMPT_CLEAR, 0 },
+
+        /* Bad block in htree interior node */
+        { PR_2_HTREE_BADBLK,
+          N_("@p @h %d (%q): bad @b number %b.\n"),
+          PROMPT_CLEAR_HTREE, 0 },
+
+        /* Error adjusting EA refcount */
+        { PR_2_ADJ_EA_REFCOUNT,
+          N_("Error addjusting refcount for @a @b %b (@i %i): %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Invalid HTREE root node */
+        { PR_2_HTREE_BAD_ROOT,
+          N_("@p @h %d: root node is invalid\n"),
+          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
+
+        /* Invalid HTREE limit */
+        { PR_2_HTREE_BAD_LIMIT,
+          N_("@p @h %d: node (%B) has bad limit (%N)\n"),
+          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
+
+        /* Invalid HTREE count */
+        { PR_2_HTREE_BAD_COUNT,
+          N_("@p @h %d: node (%B) has bad count (%N)\n"),
+          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
+
+        /* HTREE interior node has out-of-order hashes in table */
+        { PR_2_HTREE_HASH_ORDER,
+          N_("@p @h %d: node (%B) has an unordered hash table\n"),
+          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
+
+        /* Node in HTREE directory has bad depth */
+        { PR_2_HTREE_BAD_DEPTH,
+          N_("@p @h %d: node (%B) has bad depth\n"),
+          PROMPT_NONE, 0 },
+
+        /* Duplicate directory entry found */
+        { PR_2_DUPLICATE_DIRENT,
+          N_("Duplicate @E found.  "),
+          PROMPT_CLEAR, 0 },
+
+        /* Non-unique filename found */
+        { PR_2_NON_UNIQUE_FILE, /* xgettext: no-c-format */
+          N_("@E has a non-unique filename.\nRename to %s"),
+          PROMPT_NULL, 0 },
+
+        /* Duplicate directory entry found */
+        { PR_2_REPORT_DUP_DIRENT,
+          N_("Duplicate @e '%Dn' found.\n\tMarking %p (%i) to be rebuilt.\n\n"),
+          PROMPT_NONE, 0 },
+
+        /* Pass 3 errors */
+
+        /* Pass 3: Checking directory connectivity */
+        { PR_3_PASS_HEADER,
+          N_("Pass 3: Checking @d connectivity\n"),
+          PROMPT_NONE, 0 },
+
+        /* Root inode not allocated */
+        { PR_3_NO_ROOT_INODE,
+          N_("@r not allocated.  "),
+          PROMPT_ALLOCATE, 0 },
+
+        /* No room in lost+found */
+        { PR_3_EXPAND_LF_DIR,
+          N_("No room in @l @d.  "),
+          PROMPT_EXPAND, 0 },
+
+        /* Unconnected directory inode */
+        { PR_3_UNCONNECTED_DIR,
+          N_("Unconnected @d @i %i (%p)\n"),
+          PROMPT_CONNECT, 0 },
+
+        /* /lost+found not found */
+        { PR_3_NO_LF_DIR,
+          N_("/@l not found.  "),
+          PROMPT_CREATE, PR_PREEN_OK },
+
+        /* .. entry is incorrect */
+        { PR_3_BAD_DOT_DOT,
+          N_("'..' in %Q (%i) is %P (%j), @s %q (%d).\n"),
+          PROMPT_FIX, 0 },
+
+        /* Bad or non-existent /lost+found.  Cannot reconnect */
+        { PR_3_NO_LPF,
+          N_("Bad or non-existent /@l.  Cannot reconnect.\n"),
+          PROMPT_NONE, 0 },
+
+        /* Could not expand /lost+found */
+        { PR_3_CANT_EXPAND_LPF,
+          N_("Could not expand /@l: %m\n"),
+          PROMPT_NONE, 0 },
+
+        /* Could not reconnect inode */
+        { PR_3_CANT_RECONNECT,
+          N_("Could not reconnect %i: %m\n"),
+          PROMPT_NONE, 0 },
+
+        /* Error while trying to find /lost+found */
+        { PR_3_ERR_FIND_LPF,
+          N_("Error while trying to find /@l: %m\n"),
+          PROMPT_NONE, 0 },
+
+        /* Error in ext2fs_new_block while creating /lost+found */
+        { PR_3_ERR_LPF_NEW_BLOCK,
+          N_("ext2fs_new_@b: %m while trying to create /@l @d\n"),
+          PROMPT_NONE, 0 },
+
+        /* Error in ext2fs_new_inode while creating /lost+found */
+        { PR_3_ERR_LPF_NEW_INODE,
+          N_("ext2fs_new_@i: %m while trying to create /@l @d\n"),
+          PROMPT_NONE, 0 },
+
+        /* Error in ext2fs_new_dir_block while creating /lost+found */
+        { PR_3_ERR_LPF_NEW_DIR_BLOCK,
+          N_("ext2fs_new_dir_@b: %m while creating new @d @b\n"),
+          PROMPT_NONE, 0 },
+
+        /* Error while writing directory block for /lost+found */
+        { PR_3_ERR_LPF_WRITE_BLOCK,
+          N_("ext2fs_write_dir_@b: %m while writing the @d @b for /@l\n"),
+          PROMPT_NONE, 0 },
+
+        /* Error while adjusting inode count */
+        { PR_3_ADJUST_INODE,
+          N_("Error while adjusting @i count on @i %i\n"),
+          PROMPT_NONE, 0 },
+
+        /* Couldn't fix parent directory -- error */
+        { PR_3_FIX_PARENT_ERR,
+          N_("Couldn't fix parent of @i %i: %m\n\n"),
+          PROMPT_NONE, 0 },
+
+        /* Couldn't fix parent directory -- couldn't find it */
+        { PR_3_FIX_PARENT_NOFIND,
+          N_("Couldn't fix parent of @i %i: Couldn't find parent @d entry\n\n"),
+          PROMPT_NONE, 0 },
+
+        /* Error allocating inode bitmap */
+        { PR_3_ALLOCATE_IBITMAP_ERROR,
+          N_("@A @i @B (%N): %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error creating root directory */
+        { PR_3_CREATE_ROOT_ERROR,
+          N_("Error creating root @d (%s): %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error creating lost and found directory */
+        { PR_3_CREATE_LPF_ERROR,
+          N_("Error creating /@l @d (%s): %m\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Root inode is not directory; aborting */
+        { PR_3_ROOT_NOT_DIR_ABORT,
+          N_("@r is not a @d; aborting.\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Cannot proceed without a root inode. */
+        { PR_3_NO_ROOT_INODE_ABORT,
+          N_("Cannot proceed without a @r.\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Internal error: couldn't find dir_info */
+        { PR_3_NO_DIRINFO,
+          N_("Internal error: couldn't find dir_info for %i.\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Lost+found not a directory */
+        { PR_3_LPF_NOTDIR,
+          N_("/@l is not a @d (ino=%i)\n"),
+          PROMPT_UNLINK, 0 },
+
+        /* Pass 3A Directory Optimization       */
+
+        /* Pass 3A: Optimizing directories */
+        { PR_3A_PASS_HEADER,
+          N_("Pass 3A: Optimizing directories\n"),
+          PROMPT_NONE, PR_PREEN_NOMSG },
+
+        /* Error iterating over directories */
+        { PR_3A_OPTIMIZE_ITER,
+          N_("Failed to create dirs_to_hash iterator: %m"),
+          PROMPT_NONE, 0 },
+
+        /* Error rehash directory */
+        { PR_3A_OPTIMIZE_DIR_ERR,
+          N_("Failed to optimize directory %q (%d): %m"),
+          PROMPT_NONE, 0 },
+
+        /* Rehashing dir header */
+        { PR_3A_OPTIMIZE_DIR_HEADER,
+          N_("Optimizing directories: "),
+          PROMPT_NONE, PR_MSG_ONLY },
+
+        /* Rehashing directory %d */
+        { PR_3A_OPTIMIZE_DIR,
+          " %d",
+          PROMPT_NONE, PR_LATCH_OPTIMIZE_DIR | PR_PREEN_NOHDR},
+
+        /* Rehashing dir end */
+        { PR_3A_OPTIMIZE_DIR_END,
+          "\n",
+          PROMPT_NONE, PR_PREEN_NOHDR },
+
+        /* Pass 4 errors */
+
+        /* Pass 4: Checking reference counts */
+        { PR_4_PASS_HEADER,
+          N_("Pass 4: Checking reference counts\n"),
+          PROMPT_NONE, 0 },
+
+        /* Unattached zero-length inode */
+        { PR_4_ZERO_LEN_INODE,
+          "@u @z @i %i.  ",
+          PROMPT_CLEAR, PR_PREEN_OK|PR_NO_OK },
+
+        /* Unattached inode */
+        { PR_4_UNATTACHED_INODE,
+          "@u @i %i\n",
+          PROMPT_CONNECT, 0 },
+
+        /* Inode ref count wrong */
+        { PR_4_BAD_REF_COUNT,
+          N_("@i %i ref count is %Il, @s %N.  "),
+          PROMPT_FIX, PR_PREEN_OK },
+
+        { PR_4_INCONSISTENT_COUNT,
+          N_("WARNING: PROGRAMMING BUG IN E2FSCK!\n"
+          "\tOR SOME BONEHEAD (YOU) IS CHECKING A MOUNTED (LIVE) FILESYSTEM.\n"
+          "@i_link_info[%i] is %N, @i.i_links_count is %Il.  "
+          "They should be the same!\n"),
+          PROMPT_NONE, 0 },
+
+        /* Pass 5 errors */
+
+        /* Pass 5: Checking group summary information */
+        { PR_5_PASS_HEADER,
+          N_("Pass 5: Checking @g summary information\n"),
+          PROMPT_NONE, 0 },
+
+        /* Padding at end of inode bitmap is not set. */
+        { PR_5_INODE_BMAP_PADDING,
+          N_("Padding at end of @i @B is not set. "),
+          PROMPT_FIX, PR_PREEN_OK },
+
+        /* Padding at end of block bitmap is not set. */
+        { PR_5_BLOCK_BMAP_PADDING,
+          N_("Padding at end of @b @B is not set. "),
+          PROMPT_FIX, PR_PREEN_OK },
+
+        /* Block bitmap differences header */
+        { PR_5_BLOCK_BITMAP_HEADER,
+          N_("@b @B differences: "),
+          PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG},
+
+        /* Block not used, but marked in bitmap */
+        { PR_5_BLOCK_UNUSED,
+          " -%b",
+          PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Block used, but not marked used in bitmap */
+        { PR_5_BLOCK_USED,
+          " +%b",
+          PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Block bitmap differences end */
+        { PR_5_BLOCK_BITMAP_END,
+          "\n",
+          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Inode bitmap differences header */
+        { PR_5_INODE_BITMAP_HEADER,
+          N_("@i @B differences: "),
+          PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Inode not used, but marked in bitmap */
+        { PR_5_INODE_UNUSED,
+          " -%i",
+          PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Inode used, but not marked used in bitmap */
+        { PR_5_INODE_USED,
+          " +%i",
+          PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Inode bitmap differences end */
+        { PR_5_INODE_BITMAP_END,
+          "\n",
+          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Free inodes count for group wrong */
+        { PR_5_FREE_INODE_COUNT_GROUP,
+          N_("Free @is count wrong for @g #%g (%i, counted=%j).\n"),
+          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Directories count for group wrong */
+        { PR_5_FREE_DIR_COUNT_GROUP,
+          N_("Directories count wrong for @g #%g (%i, counted=%j).\n"),
+          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Free inodes count wrong */
+        { PR_5_FREE_INODE_COUNT,
+          N_("Free @is count wrong (%i, counted=%j).\n"),
+          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Free blocks count for group wrong */
+        { PR_5_FREE_BLOCK_COUNT_GROUP,
+          N_("Free @bs count wrong for @g #%g (%b, counted=%c).\n"),
+          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Free blocks count wrong */
+        { PR_5_FREE_BLOCK_COUNT,
+          N_("Free @bs count wrong (%b, counted=%c).\n"),
+          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Programming error: bitmap endpoints don't match */
+        { PR_5_BMAP_ENDPOINTS,
+          N_("PROGRAMMING ERROR: @f (#%N) @B endpoints (%b, %c) don't "
+          "match calculated @B endpoints (%i, %j)\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Internal error: fudging end of bitmap */
+        { PR_5_FUDGE_BITMAP_ERROR,
+          N_("Internal error: fudging end of bitmap (%N)\n"),
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error copying in replacement inode bitmap */
+        { PR_5_COPY_IBITMAP_ERROR,
+          "Error copying in replacement @i @B: %m\n",
+          PROMPT_NONE, PR_FATAL },
+
+        /* Error copying in replacement block bitmap */
+        { PR_5_COPY_BBITMAP_ERROR,
+          "Error copying in replacement @b @B: %m\n",
+          PROMPT_NONE, PR_FATAL },
+
+        /* Block range not used, but marked in bitmap */
+        { PR_5_BLOCK_RANGE_UNUSED,
+          " -(%b--%c)",
+          PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Block range used, but not marked used in bitmap */
+        { PR_5_BLOCK_RANGE_USED,
+          " +(%b--%c)",
+          PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Inode range not used, but marked in bitmap */
+        { PR_5_INODE_RANGE_UNUSED,
+          " -(%i--%j)",
+          PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        /* Inode range used, but not marked used in bitmap */
+        { PR_5_INODE_RANGE_USED,
+          " +(%i--%j)",
+          PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
+
+        { 0 }
+};
+
+/*
+ * This is the latch flags register.  It allows several problems to be
+ * "latched" together.  This means that the user has to answer but one
+ * question for the set of problems, and all of the associated
+ * problems will be either fixed or not fixed.
+ */
+static struct latch_descr pr_latch_info[] = {
+        { PR_LATCH_BLOCK, PR_1_INODE_BLOCK_LATCH, 0 },
+        { PR_LATCH_BBLOCK, PR_1_INODE_BBLOCK_LATCH, 0 },
+        { PR_LATCH_IBITMAP, PR_5_INODE_BITMAP_HEADER, PR_5_INODE_BITMAP_END },
+        { PR_LATCH_BBITMAP, PR_5_BLOCK_BITMAP_HEADER, PR_5_BLOCK_BITMAP_END },
+        { PR_LATCH_RELOC, PR_0_RELOCATE_HINT, 0 },
+        { PR_LATCH_DBLOCK, PR_1B_DUP_BLOCK_HEADER, PR_1B_DUP_BLOCK_END },
+        { PR_LATCH_LOW_DTIME, PR_1_ORPHAN_LIST_REFUGEES, 0 },
+        { PR_LATCH_TOOBIG, PR_1_INODE_TOOBIG, 0 },
+        { PR_LATCH_OPTIMIZE_DIR, PR_3A_OPTIMIZE_DIR_HEADER, PR_3A_OPTIMIZE_DIR_END },
+        { -1, 0, 0 },
+};
+
+static const struct e2fsck_problem *find_problem(problem_t code)
+{
+        int     i;
+
+        for (i=0; problem_table[i].e2p_code; i++) {
+                if (problem_table[i].e2p_code == code)
+                        return &problem_table[i];
+        }
+        return 0;
+}
+
+static struct latch_descr *find_latch(int code)
+{
+        int     i;
+
+        for (i=0; pr_latch_info[i].latch_code >= 0; i++) {
+                if (pr_latch_info[i].latch_code == code)
+                        return &pr_latch_info[i];
+        }
+        return 0;
+}
+
+int end_problem_latch(e2fsck_t ctx, int mask)
+{
+        struct latch_descr *ldesc;
+        struct problem_context pctx;
+        int answer = -1;
+
+        ldesc = find_latch(mask);
+        if (ldesc->end_message && (ldesc->flags & PRL_LATCHED)) {
+                clear_problem_context(&pctx);
+                answer = fix_problem(ctx, ldesc->end_message, &pctx);
+        }
+        ldesc->flags &= ~(PRL_VARIABLE);
+        return answer;
+}
+
+int set_latch_flags(int mask, int setflags, int clearflags)
+{
+        struct latch_descr *ldesc;
+
+        ldesc = find_latch(mask);
+        if (!ldesc)
+                return -1;
+        ldesc->flags |= setflags;
+        ldesc->flags &= ~clearflags;
+        return 0;
+}
+
+void clear_problem_context(struct problem_context *ctx)
+{
+        memset(ctx, 0, sizeof(struct problem_context));
+        ctx->blkcount = -1;
+        ctx->group = -1;
+}
+
+int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx)
+{
+        ext2_filsys fs = ctx->fs;
+        const struct e2fsck_problem *ptr;
+        struct latch_descr *ldesc = 0;
+        const char *message;
+        int             def_yn, answer, ans;
+        int             print_answer = 0;
+        int             suppress = 0;
+
+        ptr = find_problem(code);
+        if (!ptr) {
+                printf(_("Unhandled error code (0x%x)!\n"), code);
+                return 0;
+        }
+        def_yn = 1;
+        if ((ptr->flags & PR_NO_DEFAULT) ||
+            ((ptr->flags & PR_PREEN_NO) && (ctx->options & E2F_OPT_PREEN)) ||
+            (ctx->options & E2F_OPT_NO))
+                def_yn= 0;
+
+        /*
+         * Do special latch processing.  This is where we ask the
+         * latch question, if it exists
+         */
+        if (ptr->flags & PR_LATCH_MASK) {
+                ldesc = find_latch(ptr->flags & PR_LATCH_MASK);
+                if (ldesc->question && !(ldesc->flags & PRL_LATCHED)) {
+                        ans = fix_problem(ctx, ldesc->question, pctx);
+                        if (ans == 1)
+                                ldesc->flags |= PRL_YES;
+                        if (ans == 0)
+                                ldesc->flags |= PRL_NO;
+                        ldesc->flags |= PRL_LATCHED;
+                }
+                if (ldesc->flags & PRL_SUPPRESS)
+                        suppress++;
+        }
+        if ((ptr->flags & PR_PREEN_NOMSG) &&
+            (ctx->options & E2F_OPT_PREEN))
+                suppress++;
+        if ((ptr->flags & PR_NO_NOMSG) &&
+            (ctx->options & E2F_OPT_NO))
+                suppress++;
+        if (!suppress) {
+                message = ptr->e2p_description;
+                if ((ctx->options & E2F_OPT_PREEN) &&
+                    !(ptr->flags & PR_PREEN_NOHDR)) {
+                        printf("%s: ", ctx->device_name ?
+                               ctx->device_name : ctx->filesystem_name);
+                }
+                if (*message)
+                        print_e2fsck_message(ctx, _(message), pctx, 1);
+        }
+        if (!(ptr->flags & PR_PREEN_OK) && (ptr->prompt != PROMPT_NONE))
+                preenhalt(ctx);
+
+        if (ptr->flags & PR_FATAL)
+                fatal_error(ctx, 0);
+
+        if (ptr->prompt == PROMPT_NONE) {
+                if (ptr->flags & PR_NOCOLLATE)
+                        answer = -1;
+                else
+                        answer = def_yn;
+        } else {
+                if (ctx->options & E2F_OPT_PREEN) {
+                        answer = def_yn;
+                        if (!(ptr->flags & PR_PREEN_NOMSG))
+                                print_answer = 1;
+                } else if ((ptr->flags & PR_LATCH_MASK) &&
+                           (ldesc->flags & (PRL_YES | PRL_NO))) {
+                        if (!suppress)
+                                print_answer = 1;
+                        if (ldesc->flags & PRL_YES)
+                                answer = 1;
+                        else
+                                answer = 0;
+                } else
+                        answer = ask(ctx, _(prompt[(int) ptr->prompt]), def_yn);
+                if (!answer && !(ptr->flags & PR_NO_OK))
+                        ext2fs_unmark_valid(fs);
+
+                if (print_answer)
+                        printf("%s.\n", answer ?
+                               _(preen_msg[(int) ptr->prompt]) : _("IGNORED"));
+
+        }
+
+        if ((ptr->prompt == PROMPT_ABORT) && answer)
+                fatal_error(ctx, 0);
+
+        if (ptr->flags & PR_AFTER_CODE)
+                answer = fix_problem(ctx, ptr->second_code, pctx);
+
+        return answer;
+}
+/*
+ * linux/fs/recovery.c
+ *
+ * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
+ *
+ * Copyright 1999-2000 Red Hat Software --- All Rights Reserved
+ *
+ * This file is part of the Linux kernel and is made available under
+ * the terms of the GNU General Public License, version 2, or at your
+ * option, any later version, incorporated herein by reference.
+ *
+ * Journal recovery routines for the generic filesystem journaling code;
+ * part of the ext2fs journaling system.
+ */
+
+/*
+ * Maintain information about the progress of the recovery job, so that
+ * the different passes can carry information between them.
+ */
+struct recovery_info
+{
+        tid_t           start_transaction;
+        tid_t           end_transaction;
+
+        int             nr_replays;
+        int             nr_revokes;
+        int             nr_revoke_hits;
+};
+
+enum passtype {PASS_SCAN, PASS_REVOKE, PASS_REPLAY};
+static int do_one_pass(journal_t *journal,
+                                struct recovery_info *info, enum passtype pass);
+static int scan_revoke_records(journal_t *, struct buffer_head *,
+                                tid_t, struct recovery_info *);
+
+#ifdef __KERNEL__
+
+/* Release readahead buffers after use */
+void journal_brelse_array(struct buffer_head *b[], int n)
+{
+        while (--n >= 0)
+                brelse (b[n]);
+}
+
+
+/*
+ * When reading from the journal, we are going through the block device
+ * layer directly and so there is no readahead being done for us.  We
+ * need to implement any readahead ourselves if we want it to happen at
+ * all.  Recovery is basically one long sequential read, so make sure we
+ * do the IO in reasonably large chunks.
+ *
+ * This is not so critical that we need to be enormously clever about
+ * the readahead size, though.  128K is a purely arbitrary, good-enough
+ * fixed value.
+ */
+
+#define MAXBUF 8
+static int do_readahead(journal_t *journal, unsigned int start)
+{
+        int err;
+        unsigned int max, nbufs, next;
+        unsigned long blocknr;
+        struct buffer_head *bh;
+
+        struct buffer_head * bufs[MAXBUF];
+
+        /* Do up to 128K of readahead */
+        max = start + (128 * 1024 / journal->j_blocksize);
+        if (max > journal->j_maxlen)
+                max = journal->j_maxlen;
+
+        /* Do the readahead itself.  We'll submit MAXBUF buffer_heads at
+         * a time to the block device IO layer. */
+
+        nbufs = 0;
+
+        for (next = start; next < max; next++) {
+                err = journal_bmap(journal, next, &blocknr);
+
+                if (err) {
+                        printk (KERN_ERR "JBD: bad block at offset %u\n",
+                                next);
+                        goto failed;
+                }
+
+                bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
+                if (!bh) {
+                        err = -ENOMEM;
+                        goto failed;
+                }
+
+                if (!buffer_uptodate(bh) && !buffer_locked(bh)) {
+                        bufs[nbufs++] = bh;
+                        if (nbufs == MAXBUF) {
+                                ll_rw_block(READ, nbufs, bufs);
+                                journal_brelse_array(bufs, nbufs);
+                                nbufs = 0;
+                        }
+                } else
+                        brelse(bh);
+        }
+
+        if (nbufs)
+                ll_rw_block(READ, nbufs, bufs);
+        err = 0;
+
+failed:
+        if (nbufs)
+                journal_brelse_array(bufs, nbufs);
+        return err;
+}
+
+#endif /* __KERNEL__ */
+
+
+/*
+ * Read a block from the journal
+ */
+
+static int jread(struct buffer_head **bhp, journal_t *journal,
+                 unsigned int offset)
+{
+        int err;
+        unsigned long blocknr;
+        struct buffer_head *bh;
+
+        *bhp = NULL;
+
+        J_ASSERT (offset < journal->j_maxlen);
+
+        err = journal_bmap(journal, offset, &blocknr);
+
+        if (err) {
+                printk (KERN_ERR "JBD: bad block at offset %u\n",
+                        offset);
+                return err;
+        }
+
+        bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
+        if (!bh)
+                return -ENOMEM;
+
+        if (!buffer_uptodate(bh)) {
+                /* If this is a brand new buffer, start readahead.
+                   Otherwise, we assume we are already reading it.  */
+                if (!buffer_req(bh))
+                        do_readahead(journal, offset);
+                wait_on_buffer(bh);
+        }
+
+        if (!buffer_uptodate(bh)) {
+                printk (KERN_ERR "JBD: Failed to read block at offset %u\n",
+                        offset);
+                brelse(bh);
+                return -EIO;
+        }
+
+        *bhp = bh;
+        return 0;
+}
+
+
+/*
+ * Count the number of in-use tags in a journal descriptor block.
+ */
+
+static int count_tags(struct buffer_head *bh, int size)
+{
+        char *                  tagp;
+        journal_block_tag_t *   tag;
+        int                     nr = 0;
+
+        tagp = &bh->b_data[sizeof(journal_header_t)];
+
+        while ((tagp - bh->b_data + sizeof(journal_block_tag_t)) <= size) {
+                tag = (journal_block_tag_t *) tagp;
+
+                nr++;
+                tagp += sizeof(journal_block_tag_t);
+                if (!(tag->t_flags & htonl(JFS_FLAG_SAME_UUID)))
+                        tagp += 16;
+
+                if (tag->t_flags & htonl(JFS_FLAG_LAST_TAG))
+                        break;
+        }
+
+        return nr;
+}
+
+
+/* Make sure we wrap around the log correctly! */
+#define wrap(journal, var)                                              \
+do {                                                                    \
+        if (var >= (journal)->j_last)                                   \
+                var -= ((journal)->j_last - (journal)->j_first);        \
+} while (0)
+
+/**
+ * int journal_recover(journal_t *journal) - recovers a on-disk journal
+ * @journal: the journal to recover
+ *
+ * The primary function for recovering the log contents when mounting a
+ * journaled device.
+ *
+ * Recovery is done in three passes.  In the first pass, we look for the
+ * end of the log.  In the second, we assemble the list of revoke
+ * blocks.  In the third and final pass, we replay any un-revoked blocks
+ * in the log.
+ */
+int journal_recover(journal_t *journal)
+{
+        int                     err;
+        journal_superblock_t *  sb;
+
+        struct recovery_info    info;
+
+        memset(&info, 0, sizeof(info));
+        sb = journal->j_superblock;
+
+        /*
+         * The journal superblock's s_start field (the current log head)
+         * is always zero if, and only if, the journal was cleanly
+         * unmounted.
+         */
+
+        if (!sb->s_start) {
+                jbd_debug(1, "No recovery required, last transaction %d\n",
+                          ntohl(sb->s_sequence));
+                journal->j_transaction_sequence = ntohl(sb->s_sequence) + 1;
+                return 0;
+        }
+
+        err = do_one_pass(journal, &info, PASS_SCAN);
+        if (!err)
+                err = do_one_pass(journal, &info, PASS_REVOKE);
+        if (!err)
+                err = do_one_pass(journal, &info, PASS_REPLAY);
+
+        jbd_debug(0, "JBD: recovery, exit status %d, "
+                  "recovered transactions %u to %u\n",
+                  err, info.start_transaction, info.end_transaction);
+        jbd_debug(0, "JBD: Replayed %d and revoked %d/%d blocks\n",
+                  info.nr_replays, info.nr_revoke_hits, info.nr_revokes);
+
+        /* Restart the log at the next transaction ID, thus invalidating
+         * any existing commit records in the log. */
+        journal->j_transaction_sequence = ++info.end_transaction;
+
+        journal_clear_revoke(journal);
+        sync_blockdev(journal->j_fs_dev);
+        return err;
+}
+
+static int do_one_pass(journal_t *journal,
+                        struct recovery_info *info, enum passtype pass)
+{
+        unsigned int            first_commit_ID, next_commit_ID;
+        unsigned long           next_log_block;
+        int                     err, success = 0;
+        journal_superblock_t *  sb;
+        journal_header_t *      tmp;
+        struct buffer_head *    bh;
+        unsigned int            sequence;
+        int                     blocktype;
+
+        /* Precompute the maximum metadata descriptors in a descriptor block */
+        int                     MAX_BLOCKS_PER_DESC;
+        MAX_BLOCKS_PER_DESC = ((journal->j_blocksize-sizeof(journal_header_t))
+                               / sizeof(journal_block_tag_t));
+
+        /*
+         * First thing is to establish what we expect to find in the log
+         * (in terms of transaction IDs), and where (in terms of log
+         * block offsets): query the superblock.
+         */
+
+        sb = journal->j_superblock;
+        next_commit_ID = ntohl(sb->s_sequence);
+        next_log_block = ntohl(sb->s_start);
+
+        first_commit_ID = next_commit_ID;
+        if (pass == PASS_SCAN)
+                info->start_transaction = first_commit_ID;
+
+        jbd_debug(1, "Starting recovery pass %d\n", pass);
+
+        /*
+         * Now we walk through the log, transaction by transaction,
+         * making sure that each transaction has a commit block in the
+         * expected place.  Each complete transaction gets replayed back
+         * into the main filesystem.
+         */
+
+        while (1) {
+                int                     flags;
+                char *                  tagp;
+                journal_block_tag_t *   tag;
+                struct buffer_head *    obh;
+                struct buffer_head *    nbh;
+
+                /* If we already know where to stop the log traversal,
+                 * check right now that we haven't gone past the end of
+                 * the log. */
+
+                if (pass != PASS_SCAN)
+                        if (tid_geq(next_commit_ID, info->end_transaction))
+                                break;
+
+                jbd_debug(2, "Scanning for sequence ID %u at %lu/%lu\n",
+                          next_commit_ID, next_log_block, journal->j_last);
+
+                /* Skip over each chunk of the transaction looking
+                 * either the next descriptor block or the final commit
+                 * record. */
+
+                jbd_debug(3, "JBD: checking block %ld\n", next_log_block);
+                err = jread(&bh, journal, next_log_block);
+                if (err)
+                        goto failed;
+
+                next_log_block++;
+                wrap(journal, next_log_block);
+
+                /* What kind of buffer is it?
+                 *
+                 * If it is a descriptor block, check that it has the
+                 * expected sequence number.  Otherwise, we're all done
+                 * here. */
+
+                tmp = (journal_header_t *)bh->b_data;
+
+                if (tmp->h_magic != htonl(JFS_MAGIC_NUMBER)) {
+                        brelse(bh);
+                        break;
+                }
+
+                blocktype = ntohl(tmp->h_blocktype);
+                sequence = ntohl(tmp->h_sequence);
+                jbd_debug(3, "Found magic %d, sequence %d\n",
+                          blocktype, sequence);
+
+                if (sequence != next_commit_ID) {
+                        brelse(bh);
+                        break;
+                }
+
+                /* OK, we have a valid descriptor block which matches
+                 * all of the sequence number checks.  What are we going
+                 * to do with it?  That depends on the pass... */
+
+                switch(blocktype) {
+                case JFS_DESCRIPTOR_BLOCK:
+                        /* If it is a valid descriptor block, replay it
+                         * in pass REPLAY; otherwise, just skip over the
+                         * blocks it describes. */
+                        if (pass != PASS_REPLAY) {
+                                next_log_block +=
+                                        count_tags(bh, journal->j_blocksize);
+                                wrap(journal, next_log_block);
+                                brelse(bh);
+                                continue;
+                        }
+
+                        /* A descriptor block: we can now write all of
+                         * the data blocks.  Yay, useful work is finally
+                         * getting done here! */
+
+                        tagp = &bh->b_data[sizeof(journal_header_t)];
+                        while ((tagp - bh->b_data +sizeof(journal_block_tag_t))
+                               <= journal->j_blocksize) {
+                                unsigned long io_block;
+
+                                tag = (journal_block_tag_t *) tagp;
+                                flags = ntohl(tag->t_flags);
+
+                                io_block = next_log_block++;
+                                wrap(journal, next_log_block);
+                                err = jread(&obh, journal, io_block);
+                                if (err) {
+                                        /* Recover what we can, but
+                                         * report failure at the end. */
+                                        success = err;
+                                        printk (KERN_ERR
+                                                "JBD: IO error %d recovering "
+                                                "block %ld in log\n",
+                                                err, io_block);
+                                } else {
+                                        unsigned long blocknr;
+
+                                        J_ASSERT(obh != NULL);
+                                        blocknr = ntohl(tag->t_blocknr);
+
+                                        /* If the block has been
+                                         * revoked, then we're all done
+                                         * here. */
+                                        if (journal_test_revoke
+                                            (journal, blocknr,
+                                             next_commit_ID)) {
+                                                brelse(obh);
+                                                ++info->nr_revoke_hits;
+                                                goto skip_write;
+                                        }
+
+                                        /* Find a buffer for the new
+                                         * data being restored */
+                                        nbh = __getblk(journal->j_fs_dev,
+                                                       blocknr,
+                                                     journal->j_blocksize);
+                                        if (nbh == NULL) {
+                                                printk(KERN_ERR
+                                                       "JBD: Out of memory "
+                                                       "during recovery.\n");
+                                                err = -ENOMEM;
+                                                brelse(bh);
+                                                brelse(obh);
+                                                goto failed;
+                                        }
+
+                                        lock_buffer(nbh);
+                                        memcpy(nbh->b_data, obh->b_data,
+                                                        journal->j_blocksize);
+                                        if (flags & JFS_FLAG_ESCAPE) {
+                                                *((unsigned int *)bh->b_data) =
+                                                        htonl(JFS_MAGIC_NUMBER);
+                                        }
+
+                                        BUFFER_TRACE(nbh, "marking dirty");
+                                        set_buffer_uptodate(nbh);
+                                        mark_buffer_dirty(nbh);
+                                        BUFFER_TRACE(nbh, "marking uptodate");
+                                        ++info->nr_replays;
+                                        /* ll_rw_block(WRITE, 1, &nbh); */
+                                        unlock_buffer(nbh);
+                                        brelse(obh);
+                                        brelse(nbh);
+                                }
+
+                        skip_write:
+                                tagp += sizeof(journal_block_tag_t);
+                                if (!(flags & JFS_FLAG_SAME_UUID))
+                                        tagp += 16;
+
+                                if (flags & JFS_FLAG_LAST_TAG)
+                                        break;
+                        }
+
+                        brelse(bh);
+                        continue;
+
+                case JFS_COMMIT_BLOCK:
+                        /* Found an expected commit block: not much to
+                         * do other than move on to the next sequence
+                         * number. */
+                        brelse(bh);
+                        next_commit_ID++;
+                        continue;
+
+                case JFS_REVOKE_BLOCK:
+                        /* If we aren't in the REVOKE pass, then we can
+                         * just skip over this block. */
+                        if (pass != PASS_REVOKE) {
+                                brelse(bh);
+                                continue;
+                        }
+
+                        err = scan_revoke_records(journal, bh,
+                                                  next_commit_ID, info);
+                        brelse(bh);
+                        if (err)
+                                goto failed;
+                        continue;
+
+                default:
+                        jbd_debug(3, "Unrecognised magic %d, end of scan.\n",
+                                  blocktype);
+                        goto done;
+                }
+        }
+
+ done:
+        /*
+         * We broke out of the log scan loop: either we came to the
+         * known end of the log or we found an unexpected block in the
+         * log.  If the latter happened, then we know that the "current"
+         * transaction marks the end of the valid log.
+         */
+
+        if (pass == PASS_SCAN)
+                info->end_transaction = next_commit_ID;
+        else {
+                /* It's really bad news if different passes end up at
+                 * different places (but possible due to IO errors). */
+                if (info->end_transaction != next_commit_ID) {
+                        printk (KERN_ERR "JBD: recovery pass %d ended at "
+                                "transaction %u, expected %u\n",
+                                pass, next_commit_ID, info->end_transaction);
+                        if (!success)
+                                success = -EIO;
+                }
+        }
+
+        return success;
+
+ failed:
+        return err;
+}
+
+
+/* Scan a revoke record, marking all blocks mentioned as revoked. */
+
+static int scan_revoke_records(journal_t *journal, struct buffer_head *bh,
+                               tid_t sequence, struct recovery_info *info)
+{
+        journal_revoke_header_t *header;
+        int offset, max;
+
+        header = (journal_revoke_header_t *) bh->b_data;
+        offset = sizeof(journal_revoke_header_t);
+        max = ntohl(header->r_count);
+
+        while (offset < max) {
+                unsigned long blocknr;
+                int err;
+
+                blocknr = ntohl(* ((unsigned int *) (bh->b_data+offset)));
+                offset += 4;
+                err = journal_set_revoke(journal, blocknr, sequence);
+                if (err)
+                        return err;
+                ++info->nr_revokes;
+        }
+        return 0;
+}
+/*
+ * region.c --- code which manages allocations within a region.
+ *
+ * Copyright (C) 2001 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ */
+
+struct region_el {
+        region_addr_t   start;
+        region_addr_t   end;
+        struct region_el *next;
+};
+
+struct region_struct {
+        region_addr_t   min;
+        region_addr_t   max;
+        struct region_el *allocated;
+};
+
+region_t region_create(region_addr_t min, region_addr_t max)
+{
+        region_t        region;
+
+        region = malloc(sizeof(struct region_struct));
+        if (!region)
+                return NULL;
+        memset(region, 0, sizeof(struct region_struct));
+        region->min = min;
+        region->max = max;
+        return region;
+}
+
+void region_free(region_t region)
+{
+        struct region_el        *r, *next;
+
+        for (r = region->allocated; r; r = next) {
+                next = r->next;
+                free(r);
+        }
+        memset(region, 0, sizeof(struct region_struct));
+        free(region);
+}
+
+int region_allocate(region_t region, region_addr_t start, int n)
+{
+        struct region_el        *r, *new_region, *prev, *next;
+        region_addr_t end;
+
+        end = start+n;
+        if ((start < region->min) || (end > region->max))
+                return -1;
+        if (n == 0)
+                return 1;
+
+        /*
+         * Search through the linked list.  If we find that it
+         * conflicts witih something that's already allocated, return
+         * 1; if we can find an existing region which we can grow, do
+         * so.  Otherwise, stop when we find the appropriate place
+         * insert a new region element into the linked list.
+         */
+        for (r = region->allocated, prev=NULL; r; prev = r, r = r->next) {
+                if (((start >= r->start) && (start < r->end)) ||
+                    ((end > r->start) && (end <= r->end)) ||
+                    ((start <= r->start) && (end >= r->end)))
+                        return 1;
+                if (end == r->start) {
+                        r->start = start;
+                        return 0;
+                }
+                if (start == r->end) {
+                        if ((next = r->next)) {
+                                if (end > next->start)
+                                        return 1;
+                                if (end == next->start) {
+                                        r->end = next->end;
+                                        r->next = next->next;
+                                        free(next);
+                                        return 0;
+                                }
+                        }
+                        r->end = end;
+                        return 0;
+                }
+                if (start < r->start)
+                        break;
+        }
+        /*
+         * Insert a new region element structure into the linked list
+         */
+        new_region = malloc(sizeof(struct region_el));
+        if (!new_region)
+                return -1;
+        new_region->start = start;
+        new_region->end = start + n;
+        new_region->next = r;
+        if (prev)
+                prev->next = new_region;
+        else
+                region->allocated = new_region;
+        return 0;
+}
+
+/*
+ * rehash.c --- rebuild hash tree directories
+ *
+ * Copyright (C) 2002 Theodore Ts'o
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ *
+ * This algorithm is designed for simplicity of implementation and to
+ * pack the directory as much as possible.  It however requires twice
+ * as much memory as the size of the directory.  The maximum size
+ * directory supported using a 4k blocksize is roughly a gigabyte, and
+ * so there may very well be problems with machines that don't have
+ * virtual memory, and obscenely large directories.
+ *
+ * An alternate algorithm which is much more disk intensive could be
+ * written, and probably will need to be written in the future.  The
+ * design goals of such an algorithm are: (a) use (roughly) constant
+ * amounts of memory, no matter how large the directory, (b) the
+ * directory must be safe at all times, even if e2fsck is interrupted
+ * in the middle, (c) we must use minimal amounts of extra disk
+ * blocks.  This pretty much requires an incremental approach, where
+ * we are reading from one part of the directory, and inserting into
+ * the front half.  So the algorithm will have to keep track of a
+ * moving block boundary between the new tree and the old tree, and
+ * files will need to be moved from the old directory and inserted
+ * into the new tree.  If the new directory requires space which isn't
+ * yet available, blocks from the beginning part of the old directory
+ * may need to be moved to the end of the directory to make room for
+ * the new tree:
+ *
+ *    --------------------------------------------------------
+ *    |  new tree   |        | old tree                      |
+ *    --------------------------------------------------------
+ *                  ^ ptr    ^ptr
+ *                tail new   head old
+ *
+ * This is going to be a pain in the tuckus to implement, and will
+ * require a lot more disk accesses.  So I'm going to skip it for now;
+ * it's only really going to be an issue for really, really big
+ * filesystems (when we reach the level of tens of millions of files
+ * in a single directory).  It will probably be easier to simply
+ * require that e2fsck use VM first.
+ */
+
+struct fill_dir_struct {
+        char *buf;
+        struct ext2_inode *inode;
+        int err;
+        e2fsck_t ctx;
+        struct hash_entry *harray;
+        int max_array, num_array;
+        int dir_size;
+        int compress;
+        ino_t parent;
+};
+
+struct hash_entry {
+        ext2_dirhash_t  hash;
+        ext2_dirhash_t  minor_hash;
+        struct ext2_dir_entry   *dir;
+};
+
+struct out_dir {
+        int             num;
+        int             max;
+        char            *buf;
+        ext2_dirhash_t  *hashes;
+};
+
+static int fill_dir_block(ext2_filsys fs,
+                          blk_t *block_nr,
+                          e2_blkcnt_t blockcnt,
+                          blk_t ref_block EXT2FS_ATTR((unused)),
+                          int ref_offset EXT2FS_ATTR((unused)),
+                          void *priv_data)
+{
+        struct fill_dir_struct  *fd = (struct fill_dir_struct *) priv_data;
+        struct hash_entry       *new_array, *ent;
+        struct ext2_dir_entry   *dirent;
+        char                    *dir;
+        unsigned int            offset, dir_offset;
+
+        if (blockcnt < 0)
+                return 0;
+
+        offset = blockcnt * fs->blocksize;
+        if (offset + fs->blocksize > fd->inode->i_size) {
+                fd->err = EXT2_ET_DIR_CORRUPTED;
+                return BLOCK_ABORT;
+        }
+        dir = (fd->buf+offset);
+        if (HOLE_BLKADDR(*block_nr)) {
+                memset(dir, 0, fs->blocksize);
+                dirent = (struct ext2_dir_entry *) dir;
+                dirent->rec_len = fs->blocksize;
+        } else {
+                fd->err = ext2fs_read_dir_block(fs, *block_nr, dir);
+                if (fd->err)
+                        return BLOCK_ABORT;
+        }
+        /* While the directory block is "hot", index it. */
+        dir_offset = 0;
+        while (dir_offset < fs->blocksize) {
+                dirent = (struct ext2_dir_entry *) (dir + dir_offset);
+                if (((dir_offset + dirent->rec_len) > fs->blocksize) ||
+                    (dirent->rec_len < 8) ||
+                    ((dirent->rec_len % 4) != 0) ||
+                    (((dirent->name_len & 0xFF)+8) > dirent->rec_len)) {
+                        fd->err = EXT2_ET_DIR_CORRUPTED;
+                        return BLOCK_ABORT;
+                }
+                dir_offset += dirent->rec_len;
+                if (dirent->inode == 0)
+                        continue;
+                if (!fd->compress && ((dirent->name_len&0xFF) == 1) &&
+                    (dirent->name[0] == '.'))
+                        continue;
+                if (!fd->compress && ((dirent->name_len&0xFF) == 2) &&
+                    (dirent->name[0] == '.') && (dirent->name[1] == '.')) {
+                        fd->parent = dirent->inode;
+                        continue;
+                }
+                if (fd->num_array >= fd->max_array) {
+                        new_array = realloc(fd->harray,
+                            sizeof(struct hash_entry) * (fd->max_array+500));
+                        if (!new_array) {
+                                fd->err = ENOMEM;
+                                return BLOCK_ABORT;
+                        }
+                        fd->harray = new_array;
+                        fd->max_array += 500;
+                }
+                ent = fd->harray + fd->num_array++;
+                ent->dir = dirent;
+                fd->dir_size += EXT2_DIR_REC_LEN(dirent->name_len & 0xFF);
+                if (fd->compress)
+                        ent->hash = ent->minor_hash = 0;
+                else {
+                        fd->err = ext2fs_dirhash(fs->super->s_def_hash_version,
+                                                 dirent->name,
+                                                 dirent->name_len & 0xFF,
+                                                 fs->super->s_hash_seed,
+                                                 &ent->hash, &ent->minor_hash);
+                        if (fd->err)
+                                return BLOCK_ABORT;
+                }
+        }
+
+        return 0;
+}
+
+/* Used for sorting the hash entry */
+static EXT2_QSORT_TYPE name_cmp(const void *a, const void *b)
+{
+        const struct hash_entry *he_a = (const struct hash_entry *) a;
+        const struct hash_entry *he_b = (const struct hash_entry *) b;
+        int     ret;
+        int     min_len;
+
+        min_len = he_a->dir->name_len;
+        if (min_len > he_b->dir->name_len)
+                min_len = he_b->dir->name_len;
+
+        ret = strncmp(he_a->dir->name, he_b->dir->name, min_len);
+        if (ret == 0) {
+                if (he_a->dir->name_len > he_b->dir->name_len)
+                        ret = 1;
+                else if (he_a->dir->name_len < he_b->dir->name_len)
+                        ret = -1;
+                else
+                        ret = he_b->dir->inode - he_a->dir->inode;
+        }
+        return ret;
+}
+
+/* Used for sorting the hash entry */
+static EXT2_QSORT_TYPE hash_cmp(const void *a, const void *b)
+{
+        const struct hash_entry *he_a = (const struct hash_entry *) a;
+        const struct hash_entry *he_b = (const struct hash_entry *) b;
+        int     ret;
+
+        if (he_a->hash > he_b->hash)
+                ret = 1;
+        else if (he_a->hash < he_b->hash)
+                ret = -1;
+        else {
+                if (he_a->minor_hash > he_b->minor_hash)
+                        ret = 1;
+                else if (he_a->minor_hash < he_b->minor_hash)
+                        ret = -1;
+                else
+                        ret = name_cmp(a, b);
+        }
+        return ret;
+}
+
+static errcode_t alloc_size_dir(ext2_filsys fs, struct out_dir *outdir,
+                                int blocks)
+{
+        void                    *new_mem;
+
+        if (outdir->max) {
+                new_mem = realloc(outdir->buf, blocks * fs->blocksize);
+                if (!new_mem)
+                        return ENOMEM;
+                outdir->buf = new_mem;
+                new_mem = realloc(outdir->hashes,
+                                  blocks * sizeof(ext2_dirhash_t));
+                if (!new_mem)
+                        return ENOMEM;
+                outdir->hashes = new_mem;
+        } else {
+                outdir->buf = malloc(blocks * fs->blocksize);
+                outdir->hashes = malloc(blocks * sizeof(ext2_dirhash_t));
+                outdir->num = 0;
+        }
+        outdir->max = blocks;
+        return 0;
+}
+
+static void free_out_dir(struct out_dir *outdir)
+{
+        if (outdir->buf)
+                free(outdir->buf);
+        if (outdir->hashes)
+                free(outdir->hashes);
+        outdir->max = 0;
+        outdir->num =0;
+}
+
+static errcode_t get_next_block(ext2_filsys fs, struct out_dir *outdir,
+                         char ** ret)
+{
+        errcode_t       retval;
+
+        if (outdir->num >= outdir->max) {
+                retval = alloc_size_dir(fs, outdir, outdir->max + 50);
+                if (retval)
+                        return retval;
+        }
+        *ret = outdir->buf + (outdir->num++ * fs->blocksize);
+        memset(*ret, 0, fs->blocksize);
+        return 0;
+}
+
+/*
+ * This function is used to make a unique filename.  We do this by
+ * appending ~0, and then incrementing the number.  However, we cannot
+ * expand the length of the filename beyond the padding available in
+ * the directory entry.
+ */
+static void mutate_name(char *str, __u16 *len)
+{
+        int     i;
+        __u16   l = *len & 0xFF, h = *len & 0xff00;
+
+        /*
+         * First check to see if it looks the name has been mutated
+         * already
+         */
+        for (i = l-1; i > 0; i--) {
+                if (!isdigit(str[i]))
+                        break;
+        }
+        if ((i == l-1) || (str[i] != '~')) {
+                if (((l-1) & 3) < 2)
+                        l += 2;
+                else
+                        l = (l+3) & ~3;
+                str[l-2] = '~';
+                str[l-1] = '0';
+                *len = l | h;
+                return;
+        }
+        for (i = l-1; i >= 0; i--) {
+                if (isdigit(str[i])) {
+                        if (str[i] == '9')
+                                str[i] = '0';
+                        else {
+                                str[i]++;
+                                return;
+                        }
+                        continue;
+                }
+                if (i == 1) {
+                        if (str[0] == 'z')
+                                str[0] = 'A';
+                        else if (str[0] == 'Z') {
+                                str[0] = '~';
+                                str[1] = '0';
+                        } else
+                                str[0]++;
+                } else if (i > 0) {
+                        str[i] = '1';
+                        str[i-1] = '~';
+                } else {
+                        if (str[0] == '~')
+                                str[0] = 'a';
+                        else
+                                str[0]++;
+                }
+                break;
+        }
+}
+
+static int duplicate_search_and_fix(e2fsck_t ctx, ext2_filsys fs,
+                                    ext2_ino_t ino,
+                                    struct fill_dir_struct *fd)
+{
+        struct problem_context  pctx;
+        struct hash_entry       *ent, *prev;
+        int                     i, j;
+        int                     fixed = 0;
+        char                    new_name[256];
+        __u16                   new_len;
+
+        clear_problem_context(&pctx);
+        pctx.ino = ino;
+
+        for (i=1; i < fd->num_array; i++) {
+                ent = fd->harray + i;
+                prev = ent - 1;
+                if (!ent->dir->inode ||
+                    ((ent->dir->name_len & 0xFF) !=
+                     (prev->dir->name_len & 0xFF)) ||
+                    (strncmp(ent->dir->name, prev->dir->name,
+                             ent->dir->name_len & 0xFF)))
+                        continue;
+                pctx.dirent = ent->dir;
+                if ((ent->dir->inode == prev->dir->inode) &&
+                    fix_problem(ctx, PR_2_DUPLICATE_DIRENT, &pctx)) {
+                        e2fsck_adjust_inode_count(ctx, ent->dir->inode, -1);
+                        ent->dir->inode = 0;
+                        fixed++;
+                        continue;
+                }
+                memcpy(new_name, ent->dir->name, ent->dir->name_len & 0xFF);
+                new_len = ent->dir->name_len;
+                mutate_name(new_name, &new_len);
+                for (j=0; j < fd->num_array; j++) {
+                        if ((i==j) ||
+                            ((ent->dir->name_len & 0xFF) !=
+                             (fd->harray[j].dir->name_len & 0xFF)) ||
+                            (strncmp(new_name, fd->harray[j].dir->name,
+                                     new_len & 0xFF)))
+                                continue;
+                        mutate_name(new_name, &new_len);
+
+                        j = -1;
+                }
+                new_name[new_len & 0xFF] = 0;
+                pctx.str = new_name;
+                if (fix_problem(ctx, PR_2_NON_UNIQUE_FILE, &pctx)) {
+                        memcpy(ent->dir->name, new_name, new_len & 0xFF);
+                        ent->dir->name_len = new_len;
+                        ext2fs_dirhash(fs->super->s_def_hash_version,
+                                       ent->dir->name,
+                                       ent->dir->name_len & 0xFF,
+                                       fs->super->s_hash_seed,
+                                       &ent->hash, &ent->minor_hash);
+                        fixed++;
+                }
+        }
+        return fixed;
+}
+
+
+static errcode_t copy_dir_entries(ext2_filsys fs,
+                                  struct fill_dir_struct *fd,
+                                  struct out_dir *outdir)
+{
+        errcode_t               retval;
+        char                    *block_start;
+        struct hash_entry       *ent;
+        struct ext2_dir_entry   *dirent;
+        int                     i, rec_len, left;
+        ext2_dirhash_t          prev_hash;
+        int                     offset;
+
+        outdir->max = 0;
+        retval = alloc_size_dir(fs, outdir,
+                                (fd->dir_size / fs->blocksize) + 2);
+        if (retval)
+                return retval;
+        outdir->num = fd->compress ? 0 : 1;
+        offset = 0;
+        outdir->hashes[0] = 0;
+        prev_hash = 1;
+        if ((retval = get_next_block(fs, outdir, &block_start)))
+                return retval;
+        dirent = (struct ext2_dir_entry *) block_start;
+        left = fs->blocksize;
+        for (i=0; i < fd->num_array; i++) {
+                ent = fd->harray + i;
+                if (ent->dir->inode == 0)
+                        continue;
+                rec_len = EXT2_DIR_REC_LEN(ent->dir->name_len & 0xFF);
+                if (rec_len > left) {
+                        if (left)
+                                dirent->rec_len += left;
+                        if ((retval = get_next_block(fs, outdir,
+                                                      &block_start)))
+                                return retval;
+                        offset = 0;
+                }
+                left = fs->blocksize - offset;
+                dirent = (struct ext2_dir_entry *) (block_start + offset);
+                if (offset == 0) {
+                        if (ent->hash == prev_hash)
+                                outdir->hashes[outdir->num-1] = ent->hash | 1;
+                        else
+                                outdir->hashes[outdir->num-1] = ent->hash;
+                }
+                dirent->inode = ent->dir->inode;
+                dirent->name_len = ent->dir->name_len;
+                dirent->rec_len = rec_len;
+                memcpy(dirent->name, ent->dir->name, dirent->name_len & 0xFF);
+                offset += rec_len;
+                left -= rec_len;
+                if (left < 12) {
+                        dirent->rec_len += left;
+                        offset += left;
+                        left = 0;
+                }
+                prev_hash = ent->hash;
+        }
+        if (left)
+                dirent->rec_len += left;
+
+        return 0;
+}
+
+
+static struct ext2_dx_root_info *set_root_node(ext2_filsys fs, char *buf,
+                                    ext2_ino_t ino, ext2_ino_t parent)
+{
+        struct ext2_dir_entry           *dir;
+        struct ext2_dx_root_info        *root;
+        struct ext2_dx_countlimit       *limits;
+        int                             filetype = 0;
+
+        if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_FILETYPE)
+                filetype = EXT2_FT_DIR << 8;
+
+        memset(buf, 0, fs->blocksize);
+        dir = (struct ext2_dir_entry *) buf;
+        dir->inode = ino;
+        dir->name[0] = '.';
+        dir->name_len = 1 | filetype;
+        dir->rec_len = 12;
+        dir = (struct ext2_dir_entry *) (buf + 12);
+        dir->inode = parent;
+        dir->name[0] = '.';
+        dir->name[1] = '.';
+        dir->name_len = 2 | filetype;
+        dir->rec_len = fs->blocksize - 12;
+
+        root = (struct ext2_dx_root_info *) (buf+24);
+        root->reserved_zero = 0;
+        root->hash_version = fs->super->s_def_hash_version;
+        root->info_length = 8;
+        root->indirect_levels = 0;
+        root->unused_flags = 0;
+
+        limits = (struct ext2_dx_countlimit *) (buf+32);
+        limits->limit = (fs->blocksize - 32) / sizeof(struct ext2_dx_entry);
+        limits->count = 0;
+
+        return root;
+}
+
+
+static struct ext2_dx_entry *set_int_node(ext2_filsys fs, char *buf)
+{
+        struct ext2_dir_entry           *dir;
+        struct ext2_dx_countlimit       *limits;
+
+        memset(buf, 0, fs->blocksize);
+        dir = (struct ext2_dir_entry *) buf;
+        dir->inode = 0;
+        dir->rec_len = fs->blocksize;
+
+        limits = (struct ext2_dx_countlimit *) (buf+8);
+        limits->limit = (fs->blocksize - 8) / sizeof(struct ext2_dx_entry);
+        limits->count = 0;
+
+        return (struct ext2_dx_entry *) limits;
+}
+
+/*
+ * This function takes the leaf nodes which have been written in
+ * outdir, and populates the root node and any necessary interior nodes.
+ */
+static errcode_t calculate_tree(ext2_filsys fs,
+                                struct out_dir *outdir,
+                                ext2_ino_t ino,
+                                ext2_ino_t parent)
+{
+        struct ext2_dx_root_info        *root_info;
+        struct ext2_dx_entry            *root, *dx_ent = 0;
+        struct ext2_dx_countlimit       *root_limit, *limit;
+        errcode_t                       retval;
+        char                            * block_start;
+        int                             i, c1, c2, nblks;
+        int                             limit_offset, root_offset;
+
+        root_info = set_root_node(fs, outdir->buf, ino, parent);
+        root_offset = limit_offset = ((char *) root_info - outdir->buf) +
+                root_info->info_length;
+        root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset);
+        c1 = root_limit->limit;
+        nblks = outdir->num;
+
+        /* Write out the pointer blocks */
+        if (nblks-1 <= c1) {
+                /* Just write out the root block, and we're done */
+                root = (struct ext2_dx_entry *) (outdir->buf + root_offset);
+                for (i=1; i < nblks; i++) {
+                        root->block = ext2fs_cpu_to_le32(i);
+                        if (i != 1)
+                                root->hash =
+                                        ext2fs_cpu_to_le32(outdir->hashes[i]);
+                        root++;
+                        c1--;
+                }
+        } else {
+                c2 = 0;
+                limit = 0;
+                root_info->indirect_levels = 1;
+                for (i=1; i < nblks; i++) {
+                        if (c1 == 0)
+                                return ENOSPC;
+                        if (c2 == 0) {
+                                if (limit)
+                                        limit->limit = limit->count =
+                ext2fs_cpu_to_le16(limit->limit);
+                                root = (struct ext2_dx_entry *)
+                                        (outdir->buf + root_offset);
+                                root->block = ext2fs_cpu_to_le32(outdir->num);
+                                if (i != 1)
+                                        root->hash =
+                        ext2fs_cpu_to_le32(outdir->hashes[i]);
+                                if ((retval =  get_next_block(fs, outdir,
+                                                              &block_start)))
+                                        return retval;
+                                dx_ent = set_int_node(fs, block_start);
+                                limit = (struct ext2_dx_countlimit *) dx_ent;
+                                c2 = limit->limit;
+                                root_offset += sizeof(struct ext2_dx_entry);
+                                c1--;
+                        }
+                        dx_ent->block = ext2fs_cpu_to_le32(i);
+                        if (c2 != limit->limit)
+                                dx_ent->hash =
+                                        ext2fs_cpu_to_le32(outdir->hashes[i]);
+                        dx_ent++;
+                        c2--;
+                }
+                limit->count = ext2fs_cpu_to_le16(limit->limit - c2);
+                limit->limit = ext2fs_cpu_to_le16(limit->limit);
+        }
+        root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset);
+        root_limit->count = ext2fs_cpu_to_le16(root_limit->limit - c1);
+        root_limit->limit = ext2fs_cpu_to_le16(root_limit->limit);
+
+        return 0;
+}
+
+struct write_dir_struct {
+        struct out_dir *outdir;
+        errcode_t       err;
+        e2fsck_t        ctx;
+        int             cleared;
+};
+
+/*
+ * Helper function which writes out a directory block.
+ */
+static int write_dir_block(ext2_filsys fs,
+                           blk_t        *block_nr,
+                           e2_blkcnt_t blockcnt,
+                           blk_t ref_block EXT2FS_ATTR((unused)),
+                           int ref_offset EXT2FS_ATTR((unused)),
+                           void *priv_data)
+{
+        struct write_dir_struct *wd = (struct write_dir_struct *) priv_data;
+        blk_t   blk;
+        char    *dir;
+
+        if (*block_nr == 0)
+                return 0;
+        if (blockcnt >= wd->outdir->num) {
+                e2fsck_read_bitmaps(wd->ctx);
+                blk = *block_nr;
+                ext2fs_unmark_block_bitmap(wd->ctx->block_found_map, blk);
+                ext2fs_block_alloc_stats(fs, blk, -1);
+                *block_nr = 0;
+                wd->cleared++;
+                return BLOCK_CHANGED;
+        }
+        if (blockcnt < 0)
+                return 0;
+
+        dir = wd->outdir->buf + (blockcnt * fs->blocksize);
+        wd->err = ext2fs_write_dir_block(fs, *block_nr, dir);
+        if (wd->err)
+                return BLOCK_ABORT;
+        return 0;
+}
+
+static errcode_t write_directory(e2fsck_t ctx, ext2_filsys fs,
+                                 struct out_dir *outdir,
+                                 ext2_ino_t ino, int compress)
+{
+        struct write_dir_struct wd;
+        errcode_t       retval;
+        struct ext2_inode       inode;
+
+        retval = e2fsck_expand_directory(ctx, ino, -1, outdir->num);
+        if (retval)
+                return retval;
+
+        wd.outdir = outdir;
+        wd.err = 0;
+        wd.ctx = ctx;
+        wd.cleared = 0;
+
+        retval = ext2fs_block_iterate2(fs, ino, 0, 0,
+                                       write_dir_block, &wd);
+        if (retval)
+                return retval;
+        if (wd.err)
+                return wd.err;
+
+        e2fsck_read_inode(ctx, ino, &inode, "rehash_dir");
+        if (compress)
+                inode.i_flags &= ~EXT2_INDEX_FL;
+        else
+                inode.i_flags |= EXT2_INDEX_FL;
+        inode.i_size = outdir->num * fs->blocksize;
+        inode.i_blocks -= (fs->blocksize / 512) * wd.cleared;
+        e2fsck_write_inode(ctx, ino, &inode, "rehash_dir");
+
+        return 0;
+}
+
+errcode_t e2fsck_rehash_dir(e2fsck_t ctx, ext2_ino_t ino)
+{
+        ext2_filsys             fs = ctx->fs;
+        errcode_t               retval;
+        struct ext2_inode       inode;
+        char                    *dir_buf = 0;
+        struct fill_dir_struct  fd;
+        struct out_dir          outdir;
+
+        outdir.max = outdir.num = 0;
+        outdir.buf = 0;
+        outdir.hashes = 0;
+        e2fsck_read_inode(ctx, ino, &inode, "rehash_dir");
+
+        retval = ENOMEM;
+        fd.harray = 0;
+        dir_buf = malloc(inode.i_size);
+        if (!dir_buf)
+                goto errout;
+
+        fd.max_array = inode.i_size / 32;
+        fd.num_array = 0;
+        fd.harray = malloc(fd.max_array * sizeof(struct hash_entry));
+        if (!fd.harray)
+                goto errout;
+
+        fd.ctx = ctx;
+        fd.buf = dir_buf;
+        fd.inode = &inode;
+        fd.err = 0;
+        fd.dir_size = 0;
+        fd.compress = 0;
+        if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) ||
+            (inode.i_size / fs->blocksize) < 2)
+                fd.compress = 1;
+        fd.parent = 0;
+
+        /* Read in the entire directory into memory */
+        retval = ext2fs_block_iterate2(fs, ino, 0, 0,
+                                       fill_dir_block, &fd);
+        if (fd.err) {
+                retval = fd.err;
+                goto errout;
+        }
+
+#if 0
+        printf("%d entries (%d bytes) found in inode %d\n",
+               fd.num_array, fd.dir_size, ino);
+#endif
+
+        /* Sort the list */
+resort:
+        if (fd.compress)
+                qsort(fd.harray+2, fd.num_array-2,
+                      sizeof(struct hash_entry), name_cmp);
+        else
+                qsort(fd.harray, fd.num_array,
+                      sizeof(struct hash_entry), hash_cmp);
+
+        /*
+         * Look for duplicates
+         */
+        if (duplicate_search_and_fix(ctx, fs, ino, &fd))
+                goto resort;
+
+        if (ctx->options & E2F_OPT_NO) {
+                retval = 0;
+                goto errout;
+        }
+
+        /*
+         * Copy the directory entries.  In a htree directory these
+         * will become the leaf nodes.
+         */
+        retval = copy_dir_entries(fs, &fd, &outdir);
+        if (retval)
+                goto errout;
+
+        free(dir_buf); dir_buf = 0;
+
+        if (!fd.compress) {
+                /* Calculate the interior nodes */
+                retval = calculate_tree(fs, &outdir, ino, fd.parent);
+                if (retval)
+                        goto errout;
+        }
+
+        retval = write_directory(ctx, fs, &outdir, ino, fd.compress);
+        if (retval)
+                goto errout;
+
+errout:
+        if (dir_buf)
+                free(dir_buf);
+        if (fd.harray)
+                free(fd.harray);
+
+        free_out_dir(&outdir);
+        return retval;
+}
+
+void e2fsck_rehash_directories(e2fsck_t ctx)
+{
+        struct problem_context  pctx;
+#ifdef RESOURCE_TRACK
+        struct resource_track   rtrack;
+#endif
+        struct dir_info         *dir;
+        ext2_u32_iterate        iter;
+        ext2_ino_t              ino;
+        errcode_t               retval;
+        int                     i, cur, max, all_dirs, dir_index, first = 1;
+
+#ifdef RESOURCE_TRACK
+        init_resource_track(&rtrack);
+#endif
+
+        all_dirs = ctx->options & E2F_OPT_COMPRESS_DIRS;
+
+        if (!ctx->dirs_to_hash && !all_dirs)
+                return;
+
+        e2fsck_get_lost_and_found(ctx, 0);
+
+        clear_problem_context(&pctx);
+
+        dir_index = ctx->fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX;
+        cur = 0;
+        if (all_dirs) {
+                i = 0;
+                max = e2fsck_get_num_dirinfo(ctx);
+        } else {
+                retval = ext2fs_u32_list_iterate_begin(ctx->dirs_to_hash,
+                                                       &iter);
+                if (retval) {
+                        pctx.errcode = retval;
+                        fix_problem(ctx, PR_3A_OPTIMIZE_ITER, &pctx);
+                        return;
+                }
+                max = ext2fs_u32_list_count(ctx->dirs_to_hash);
+        }
+        while (1) {
+                if (all_dirs) {
+                        if ((dir = e2fsck_dir_info_iter(ctx, &i)) == 0)
+                                break;
+                        ino = dir->ino;
+                } else {
+                        if (!ext2fs_u32_list_iterate(iter, &ino))
+                                break;
+                }
+                if (ino == ctx->lost_and_found)
+                        continue;
+                pctx.dir = ino;
+                if (first) {
+                        fix_problem(ctx, PR_3A_PASS_HEADER, &pctx);
+                        first = 0;
+                }
+#if 0
+                fix_problem(ctx, PR_3A_OPTIMIZE_DIR, &pctx);
+#endif
+                pctx.errcode = e2fsck_rehash_dir(ctx, ino);
+                if (pctx.errcode) {
+                        end_problem_latch(ctx, PR_LATCH_OPTIMIZE_DIR);
+                        fix_problem(ctx, PR_3A_OPTIMIZE_DIR_ERR, &pctx);
+                }
+                if (ctx->progress && !ctx->progress_fd)
+                        e2fsck_simple_progress(ctx, "Rebuilding directory",
+                               100.0 * (float) (++cur) / (float) max, ino);
+        }
+        end_problem_latch(ctx, PR_LATCH_OPTIMIZE_DIR);
+        if (!all_dirs)
+                ext2fs_u32_list_iterate_end(iter);
+
+        if (ctx->dirs_to_hash)
+                ext2fs_u32_list_free(ctx->dirs_to_hash);
+        ctx->dirs_to_hash = 0;
+
+#ifdef RESOURCE_TRACK
+        if (ctx->options & E2F_OPT_TIME2) {
+                e2fsck_clear_progbar(ctx);
+                print_resource_track("Pass 3A", &rtrack);
+        }
+#endif
+}
+/*
+ * linux/fs/revoke.c
+ *
+ * Written by Stephen C. Tweedie <sct@redhat.com>, 2000
+ *
+ * Copyright 2000 Red Hat corp --- All Rights Reserved
+ *
+ * This file is part of the Linux kernel and is made available under
+ * the terms of the GNU General Public License, version 2, or at your
+ * option, any later version, incorporated herein by reference.
+ *
+ * Journal revoke routines for the generic filesystem journaling code;
+ * part of the ext2fs journaling system.
+ *
+ * Revoke is the mechanism used to prevent old log records for deleted
+ * metadata from being replayed on top of newer data using the same
+ * blocks.  The revoke mechanism is used in two separate places:
+ *
+ * + Commit: during commit we write the entire list of the current
+ *   transaction's revoked blocks to the journal
+ *
+ * + Recovery: during recovery we record the transaction ID of all
+ *   revoked blocks.  If there are multiple revoke records in the log
+ *   for a single block, only the last one counts, and if there is a log
+ *   entry for a block beyond the last revoke, then that log entry still
+ *   gets replayed.
+ *
+ * We can get interactions between revokes and new log data within a
+ * single transaction:
+ *
+ * Block is revoked and then journaled:
+ *   The desired end result is the journaling of the new block, so we
+ *   cancel the revoke before the transaction commits.
+ *
+ * Block is journaled and then revoked:
+ *   The revoke must take precedence over the write of the block, so we
+ *   need either to cancel the journal entry or to write the revoke
+ *   later in the log than the log block.  In this case, we choose the
+ *   latter: journaling a block cancels any revoke record for that block
+ *   in the current transaction, so any revoke for that block in the
+ *   transaction must have happened after the block was journaled and so
+ *   the revoke must take precedence.
+ *
+ * Block is revoked and then written as data:
+ *   The data write is allowed to succeed, but the revoke is _not_
+ *   cancelled.  We still need to prevent old log records from
+ *   overwriting the new data.  We don't even need to clear the revoke
+ *   bit here.
+ *
+ * Revoke information on buffers is a tri-state value:
+ *
+ * RevokeValid clear:   no cached revoke status, need to look it up
+ * RevokeValid set, Revoked clear:
+ *                      buffer has not been revoked, and cancel_revoke
+ *                      need do nothing.
+ * RevokeValid set, Revoked set:
+ *                      buffer has been revoked.
+ */
+
+static kmem_cache_t *revoke_record_cache;
+static kmem_cache_t *revoke_table_cache;
+
+/* Each revoke record represents one single revoked block.  During
+   journal replay, this involves recording the transaction ID of the
+   last transaction to revoke this block. */
+
+struct jbd_revoke_record_s
+{
+        struct list_head  hash;
+        tid_t             sequence;     /* Used for recovery only */
+        unsigned long     blocknr;
+};
+
+
+/* The revoke table is just a simple hash table of revoke records. */
+struct jbd_revoke_table_s
+{
+        /* It is conceivable that we might want a larger hash table
+         * for recovery.  Must be a power of two. */
+        int               hash_size;
+        int               hash_shift;
+        struct list_head *hash_table;
+};
+
+
+#ifdef __KERNEL__
+static void write_one_revoke_record(journal_t *, transaction_t *,
+                                    struct journal_head **, int *,
+                                    struct jbd_revoke_record_s *);
+static void flush_descriptor(journal_t *, struct journal_head *, int);
+#endif
+
+/* Utility functions to maintain the revoke table */
+
+/* Borrowed from buffer.c: this is a tried and tested block hash function */
+static inline int hash(journal_t *journal, unsigned long block)
+{
+        struct jbd_revoke_table_s *table = journal->j_revoke;
+        int hash_shift = table->hash_shift;
+
+        return ((block << (hash_shift - 6)) ^
+                (block >> 13) ^
+                (block << (hash_shift - 12))) & (table->hash_size - 1);
+}
+
+static int insert_revoke_hash(journal_t *journal, unsigned long blocknr,
+                              tid_t seq)
+{
+        struct list_head *hash_list;
+        struct jbd_revoke_record_s *record;
+
+#ifdef __KERNEL__
+repeat:
+#endif
+        record = kmem_cache_alloc(revoke_record_cache, GFP_NOFS);
+        if (!record)
+                goto oom;
+
+        record->sequence = seq;
+        record->blocknr = blocknr;
+        hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];
+        list_add(&record->hash, hash_list);
+        return 0;
+
+oom:
+#ifdef __KERNEL__
+        if (!journal_oom_retry)
+                return -ENOMEM;
+        jbd_debug(1, "ENOMEM in " __FUNCTION__ ", retrying.\n");
+        current->policy |= SCHED_YIELD;
+        schedule();
+        goto repeat;
+#else
+        return -ENOMEM;
+#endif
+}
+
+/* Find a revoke record in the journal's hash table. */
+
+static struct jbd_revoke_record_s *find_revoke_record(journal_t *journal,
+                                                      unsigned long blocknr)
+{
+        struct list_head *hash_list;
+        struct jbd_revoke_record_s *record;
+
+        hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];
+
+        record = (struct jbd_revoke_record_s *) hash_list->next;
+        while (&(record->hash) != hash_list) {
+                if (record->blocknr == blocknr)
+                        return record;
+                record = (struct jbd_revoke_record_s *) record->hash.next;
+        }
+        return NULL;
+}
+
+int journal_init_revoke_caches(void)
+{
+        revoke_record_cache = kmem_cache_create("revoke_record",
+                                           sizeof(struct jbd_revoke_record_s),
+                                           0, SLAB_HWCACHE_ALIGN, NULL, NULL);
+        if (revoke_record_cache == 0)
+                return -ENOMEM;
+
+        revoke_table_cache = kmem_cache_create("revoke_table",
+                                           sizeof(struct jbd_revoke_table_s),
+                                           0, 0, NULL, NULL);
+        if (revoke_table_cache == 0) {
+                kmem_cache_destroy(revoke_record_cache);
+                revoke_record_cache = NULL;
+                return -ENOMEM;
+        }
+        return 0;
+}
+
+void journal_destroy_revoke_caches(void)
+{
+        kmem_cache_destroy(revoke_record_cache);
+        revoke_record_cache = 0;
+        kmem_cache_destroy(revoke_table_cache);
+        revoke_table_cache = 0;
+}
+
+/* Initialise the revoke table for a given journal to a given size. */
+
+int journal_init_revoke(journal_t *journal, int hash_size)
+{
+        int shift, tmp;
+
+        J_ASSERT (journal->j_revoke == NULL);
+
+        journal->j_revoke = kmem_cache_alloc(revoke_table_cache, GFP_KERNEL);
+        if (!journal->j_revoke)
+                return -ENOMEM;
+
+        /* Check that the hash_size is a power of two */
+        J_ASSERT ((hash_size & (hash_size-1)) == 0);
+
+        journal->j_revoke->hash_size = hash_size;
+
+        shift = 0;
+        tmp = hash_size;
+        while((tmp >>= 1UL) != 0UL)
+                shift++;
+        journal->j_revoke->hash_shift = shift;
+
+        journal->j_revoke->hash_table =
+                kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL);
+        if (!journal->j_revoke->hash_table) {
+                kmem_cache_free(revoke_table_cache, journal->j_revoke);
+                journal->j_revoke = NULL;
+                return -ENOMEM;
+        }
+
+        for (tmp = 0; tmp < hash_size; tmp++)
+                INIT_LIST_HEAD(&journal->j_revoke->hash_table[tmp]);
+
+        return 0;
+}
+
+/* Destoy a journal's revoke table.  The table must already be empty! */
+
+void journal_destroy_revoke(journal_t *journal)
+{
+        struct jbd_revoke_table_s *table;
+        struct list_head *hash_list;
+        int i;
+
+        table = journal->j_revoke;
+        if (!table)
+                return;
+
+        for (i=0; i<table->hash_size; i++) {
+                hash_list = &table->hash_table[i];
+                J_ASSERT (list_empty(hash_list));
+        }
+
+        kfree(table->hash_table);
+        kmem_cache_free(revoke_table_cache, table);
+        journal->j_revoke = NULL;
+}
+
+
+#ifdef __KERNEL__
+
+/*
+ * journal_revoke: revoke a given buffer_head from the journal.  This
+ * prevents the block from being replayed during recovery if we take a
+ * crash after this current transaction commits.  Any subsequent
+ * metadata writes of the buffer in this transaction cancel the
+ * revoke.
+ *
+ * Note that this call may block --- it is up to the caller to make
+ * sure that there are no further calls to journal_write_metadata
+ * before the revoke is complete.  In ext3, this implies calling the
+ * revoke before clearing the block bitmap when we are deleting
+ * metadata.
+ *
+ * Revoke performs a journal_forget on any buffer_head passed in as a
+ * parameter, but does _not_ forget the buffer_head if the bh was only
+ * found implicitly.
+ *
+ * bh_in may not be a journalled buffer - it may have come off
+ * the hash tables without an attached journal_head.
+ *
+ * If bh_in is non-zero, journal_revoke() will decrement its b_count
+ * by one.
+ */
+
+int journal_revoke(handle_t *handle, unsigned long blocknr,
+                   struct buffer_head *bh_in)
+{
+        struct buffer_head *bh = NULL;
+        journal_t *journal;
+        kdev_t dev;
+        int err;
+
+        if (bh_in)
+                BUFFER_TRACE(bh_in, "enter");
+
+        journal = handle->h_transaction->t_journal;
+        if (!journal_set_features(journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)){
+                J_ASSERT (!"Cannot set revoke feature!");
+                return -EINVAL;
+        }
+
+        dev = journal->j_fs_dev;
+        bh = bh_in;
+
+        if (!bh) {
+                bh = get_hash_table(dev, blocknr, journal->j_blocksize);
+                if (bh)
+                        BUFFER_TRACE(bh, "found on hash");
+        }
+#ifdef JBD_EXPENSIVE_CHECKING
+        else {
+                struct buffer_head *bh2;
+
+                /* If there is a different buffer_head lying around in
+                 * memory anywhere... */
+                bh2 = get_hash_table(dev, blocknr, journal->j_blocksize);
+                if (bh2) {
+                        /* ... and it has RevokeValid status... */
+                        if ((bh2 != bh) &&
+                            test_bit(BH_RevokeValid, &bh2->b_state))
+                                /* ...then it better be revoked too,
+                                 * since it's illegal to create a revoke
+                                 * record against a buffer_head which is
+                                 * not marked revoked --- that would
+                                 * risk missing a subsequent revoke
+                                 * cancel. */
+                                J_ASSERT_BH(bh2, test_bit(BH_Revoked, &
+                                                          bh2->b_state));
+                        __brelse(bh2);
+                }
+        }
+#endif
+
+        /* We really ought not ever to revoke twice in a row without
+           first having the revoke cancelled: it's illegal to free a
+           block twice without allocating it in between! */
+        if (bh) {
+                J_ASSERT_BH(bh, !test_bit(BH_Revoked, &bh->b_state));
+                set_bit(BH_Revoked, &bh->b_state);
+                set_bit(BH_RevokeValid, &bh->b_state);
+                if (bh_in) {
+                        BUFFER_TRACE(bh_in, "call journal_forget");
+                        journal_forget(handle, bh_in);
+                } else {
+                        BUFFER_TRACE(bh, "call brelse");
+                        __brelse(bh);
+                }
+        }
+
+        lock_journal(journal);
+        jbd_debug(2, "insert revoke for block %lu, bh_in=%p\n", blocknr, bh_in);
+        err = insert_revoke_hash(journal, blocknr,
+                                handle->h_transaction->t_tid);
+        unlock_journal(journal);
+        BUFFER_TRACE(bh_in, "exit");
+        return err;
+}
+
+/*
+ * Cancel an outstanding revoke.  For use only internally by the
+ * journaling code (called from journal_get_write_access).
+ *
+ * We trust the BH_Revoked bit on the buffer if the buffer is already
+ * being journaled: if there is no revoke pending on the buffer, then we
+ * don't do anything here.
+ *
+ * This would break if it were possible for a buffer to be revoked and
+ * discarded, and then reallocated within the same transaction.  In such
+ * a case we would have lost the revoked bit, but when we arrived here
+ * the second time we would still have a pending revoke to cancel.  So,
+ * do not trust the Revoked bit on buffers unless RevokeValid is also
+ * set.
+ *
+ * The caller must have the journal locked.
+ */
+int journal_cancel_revoke(handle_t *handle, struct journal_head *jh)
+{
+        struct jbd_revoke_record_s *record;
+        journal_t *journal = handle->h_transaction->t_journal;
+        int need_cancel;
+        int did_revoke = 0;     /* akpm: debug */
+        struct buffer_head *bh = jh2bh(jh);
+
+        jbd_debug(4, "journal_head %p, cancelling revoke\n", jh);
+
+        /* Is the existing Revoke bit valid?  If so, we trust it, and
+         * only perform the full cancel if the revoke bit is set.  If
+         * not, we can't trust the revoke bit, and we need to do the
+         * full search for a revoke record. */
+        if (test_and_set_bit(BH_RevokeValid, &bh->b_state))
+                need_cancel = (test_and_clear_bit(BH_Revoked, &bh->b_state));
+        else {
+                need_cancel = 1;
+                clear_bit(BH_Revoked, &bh->b_state);
+        }
+
+        if (need_cancel) {
+                record = find_revoke_record(journal, bh->b_blocknr);
+                if (record) {
+                        jbd_debug(4, "cancelled existing revoke on "
+                                  "blocknr %lu\n", bh->b_blocknr);
+                        list_del(&record->hash);
+                        kmem_cache_free(revoke_record_cache, record);
+                        did_revoke = 1;
+                }
+        }
+
+#ifdef JBD_EXPENSIVE_CHECKING
+        /* There better not be one left behind by now! */
+        record = find_revoke_record(journal, bh->b_blocknr);
+        J_ASSERT_JH(jh, record == NULL);
+#endif
+
+        /* Finally, have we just cleared revoke on an unhashed
+         * buffer_head?  If so, we'd better make sure we clear the
+         * revoked status on any hashed alias too, otherwise the revoke
+         * state machine will get very upset later on. */
+        if (need_cancel && !bh->b_pprev) {
+                struct buffer_head *bh2;
+                bh2 = get_hash_table(bh->b_dev, bh->b_blocknr, bh->b_size);
+                if (bh2) {
+                        clear_bit(BH_Revoked, &bh2->b_state);
+                        __brelse(bh2);
+                }
+        }
+
+        return did_revoke;
+}
+
+
+/*
+ * Write revoke records to the journal for all entries in the current
+ * revoke hash, deleting the entries as we go.
+ *
+ * Called with the journal lock held.
+ */
+
+void journal_write_revoke_records(journal_t *journal,
+                                  transaction_t *transaction)
+{
+        struct journal_head *descriptor;
+        struct jbd_revoke_record_s *record;
+        struct jbd_revoke_table_s *revoke;
+        struct list_head *hash_list;
+        int i, offset, count;
+
+        descriptor = NULL;
+        offset = 0;
+        count = 0;
+        revoke = journal->j_revoke;
+
+        for (i = 0; i < revoke->hash_size; i++) {
+                hash_list = &revoke->hash_table[i];
+
+                while (!list_empty(hash_list)) {
+                        record = (struct jbd_revoke_record_s *)
+                                hash_list->next;
+                        write_one_revoke_record(journal, transaction,
+                                                &descriptor, &offset,
+                                                record);
+                        count++;
+                        list_del(&record->hash);
+                        kmem_cache_free(revoke_record_cache, record);
+                }
+        }
+        if (descriptor)
+                flush_descriptor(journal, descriptor, offset);
+        jbd_debug(1, "Wrote %d revoke records\n", count);
+}
+
+/*
+ * Write out one revoke record.  We need to create a new descriptor
+ * block if the old one is full or if we have not already created one.
+ */
+
+static void write_one_revoke_record(journal_t *journal,
+                                    transaction_t *transaction,
+                                    struct journal_head **descriptorp,
+                                    int *offsetp,
+                                    struct jbd_revoke_record_s *record)
+{
+        struct journal_head *descriptor;
+        int offset;
+        journal_header_t *header;
+
+        /* If we are already aborting, this all becomes a noop.  We
+           still need to go round the loop in
+           journal_write_revoke_records in order to free all of the
+           revoke records: only the IO to the journal is omitted. */
+        if (is_journal_aborted(journal))
+                return;
+
+        descriptor = *descriptorp;
+        offset = *offsetp;
+
+        /* Make sure we have a descriptor with space left for the record */
+        if (descriptor) {
+                if (offset == journal->j_blocksize) {
+                        flush_descriptor(journal, descriptor, offset);
+                        descriptor = NULL;
+                }
+        }
+
+        if (!descriptor) {
+                descriptor = journal_get_descriptor_buffer(journal);
+                if (!descriptor)
+                        return;
+                header = (journal_header_t *) &jh2bh(descriptor)->b_data[0];
+                header->h_magic     = htonl(JFS_MAGIC_NUMBER);
+                header->h_blocktype = htonl(JFS_REVOKE_BLOCK);
+                header->h_sequence  = htonl(transaction->t_tid);
+
+                /* Record it so that we can wait for IO completion later */
+                JBUFFER_TRACE(descriptor, "file as BJ_LogCtl");
+                journal_file_buffer(descriptor, transaction, BJ_LogCtl);
+
+                offset = sizeof(journal_revoke_header_t);
+                *descriptorp = descriptor;
+        }
+
+        * ((unsigned int *)(&jh2bh(descriptor)->b_data[offset])) =
+                htonl(record->blocknr);
+        offset += 4;
+        *offsetp = offset;
+}
+
+/*
+ * Flush a revoke descriptor out to the journal.  If we are aborting,
+ * this is a noop; otherwise we are generating a buffer which needs to
+ * be waited for during commit, so it has to go onto the appropriate
+ * journal buffer list.
+ */
+
+static void flush_descriptor(journal_t *journal,
+                             struct journal_head *descriptor,
+                             int offset)
+{
+        journal_revoke_header_t *header;
+
+        if (is_journal_aborted(journal)) {
+                JBUFFER_TRACE(descriptor, "brelse");
+                __brelse(jh2bh(descriptor));
+                return;
+        }
+
+        header = (journal_revoke_header_t *) jh2bh(descriptor)->b_data;
+        header->r_count = htonl(offset);
+        set_bit(BH_JWrite, &jh2bh(descriptor)->b_state);
+        {
+                struct buffer_head *bh = jh2bh(descriptor);
+                BUFFER_TRACE(bh, "write");
+                ll_rw_block (WRITE, 1, &bh);
+        }
+}
+
+#endif
+
+/*
+ * Revoke support for recovery.
+ *
+ * Recovery needs to be able to:
+ *
+ *  record all revoke records, including the tid of the latest instance
+ *  of each revoke in the journal
+ *
+ *  check whether a given block in a given transaction should be replayed
+ *  (ie. has not been revoked by a revoke record in that or a subsequent
+ *  transaction)
+ *
+ *  empty the revoke table after recovery.
+ */
+
+/*
+ * First, setting revoke records.  We create a new revoke record for
+ * every block ever revoked in the log as we scan it for recovery, and
+ * we update the existing records if we find multiple revokes for a
+ * single block.
+ */
+
+int journal_set_revoke(journal_t *journal,
+                       unsigned long blocknr,
+                       tid_t sequence)
+{
+        struct jbd_revoke_record_s *record;
+
+        record = find_revoke_record(journal, blocknr);
+        if (record) {
+                /* If we have multiple occurences, only record the
+                 * latest sequence number in the hashed record */
+                if (tid_gt(sequence, record->sequence))
+                        record->sequence = sequence;
+                return 0;
+        }
+        return insert_revoke_hash(journal, blocknr, sequence);
+}
+
+/*
+ * Test revoke records.  For a given block referenced in the log, has
+ * that block been revoked?  A revoke record with a given transaction
+ * sequence number revokes all blocks in that transaction and earlier
+ * ones, but later transactions still need replayed.
+ */
+
+int journal_test_revoke(journal_t *journal,
+                        unsigned long blocknr,
+                        tid_t sequence)
+{
+        struct jbd_revoke_record_s *record;
+
+        record = find_revoke_record(journal, blocknr);
+        if (!record)
+                return 0;
+        if (tid_gt(sequence, record->sequence))
+                return 0;
+        return 1;
+}
+
+/*
+ * Finally, once recovery is over, we need to clear the revoke table so
+ * that it can be reused by the running filesystem.
+ */
+
+void journal_clear_revoke(journal_t *journal)
+{
+        int i;
+        struct list_head *hash_list;
+        struct jbd_revoke_record_s *record;
+        struct jbd_revoke_table_s *revoke_var;
+
+        revoke_var = journal->j_revoke;
+
+        for (i = 0; i < revoke_var->hash_size; i++) {
+                hash_list = &revoke_var->hash_table[i];
+                while (!list_empty(hash_list)) {
+                        record = (struct jbd_revoke_record_s*) hash_list->next;
+                        list_del(&record->hash);
+                        kmem_cache_free(revoke_record_cache, record);
+                }
+        }
+}
+
+/*
+ * e2fsck.c - superblock checks
+ *
+ * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ */
+
+#define MIN_CHECK 1
+#define MAX_CHECK 2
+
+static void check_super_value(e2fsck_t ctx, const char *descr,
+                              unsigned long value, int flags,
+                              unsigned long min_val, unsigned long max_val)
+{
+        struct          problem_context pctx;
+
+        if (((flags & MIN_CHECK) && (value < min_val)) ||
+            ((flags & MAX_CHECK) && (value > max_val))) {
+                clear_problem_context(&pctx);
+                pctx.num = value;
+                pctx.str = descr;
+                fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT; /* never get here! */
+        }
+}
+
+/*
+ * This routine may get stubbed out in special compilations of the
+ * e2fsck code..
+ */
+#ifndef EXT2_SPECIAL_DEVICE_SIZE
+errcode_t e2fsck_get_device_size(e2fsck_t ctx)
+{
+        return (ext2fs_get_device_size(ctx->filesystem_name,
+                                       EXT2_BLOCK_SIZE(ctx->fs->super),
+                                       &ctx->num_blocks));
+}
+#endif
+
+/*
+ * helper function to release an inode
+ */
+struct process_block_struct {
+        e2fsck_t        ctx;
+        char            *buf;
+        struct problem_context *pctx;
+        int             truncating;
+        int             truncate_offset;
+        e2_blkcnt_t     truncate_block;
+        int             truncated_blocks;
+        int             abort;
+        errcode_t       errcode;
+};
+
+static int release_inode_block(ext2_filsys fs,
+                               blk_t    *block_nr,
+                               e2_blkcnt_t blockcnt,
+                               blk_t    ref_blk EXT2FS_ATTR((unused)),
+                               int      ref_offset EXT2FS_ATTR((unused)),
+                               void *priv_data)
+{
+        struct process_block_struct *pb;
+        e2fsck_t                ctx;
+        struct problem_context  *pctx;
+        blk_t                   blk = *block_nr;
+        int                     retval = 0;
+
+        pb = (struct process_block_struct *) priv_data;
+        ctx = pb->ctx;
+        pctx = pb->pctx;
+
+        pctx->blk = blk;
+        pctx->blkcount = blockcnt;
+
+        if (HOLE_BLKADDR(blk))
+                return 0;
+
+        if ((blk < fs->super->s_first_data_block) ||
+            (blk >= fs->super->s_blocks_count)) {
+                fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, pctx);
+        return_abort:
+                pb->abort = 1;
+                return BLOCK_ABORT;
+        }
+
+        if (!ext2fs_test_block_bitmap(fs->block_map, blk)) {
+                fix_problem(ctx, PR_0_ORPHAN_ALREADY_CLEARED_BLOCK, pctx);
+                goto return_abort;
+        }
+
+        /*
+         * If we are deleting an orphan, then we leave the fields alone.
+         * If we are truncating an orphan, then update the inode fields
+         * and clean up any partial block data.
+         */
+        if (pb->truncating) {
+                /*
+                 * We only remove indirect blocks if they are
+                 * completely empty.
+                 */
+                if (blockcnt < 0) {
+                        int     i, limit;
+                        blk_t   *bp;
+
+                        pb->errcode = io_channel_read_blk(fs->io, blk, 1,
+                                                        pb->buf);
+                        if (pb->errcode)
+                                goto return_abort;
+
+                        limit = fs->blocksize >> 2;
+                        for (i = 0, bp = (blk_t *) pb->buf;
+                             i < limit;  i++, bp++)
+                                if (*bp)
+                                        return 0;
+                }
+                /*
+                 * We don't remove direct blocks until we've reached
+                 * the truncation block.
+                 */
+                if (blockcnt >= 0 && blockcnt < pb->truncate_block)
+                        return 0;
+                /*
+                 * If part of the last block needs truncating, we do
+                 * it here.
+                 */
+                if ((blockcnt == pb->truncate_block) && pb->truncate_offset) {
+                        pb->errcode = io_channel_read_blk(fs->io, blk, 1,
+                                                        pb->buf);
+                        if (pb->errcode)
+                                goto return_abort;
+                        memset(pb->buf + pb->truncate_offset, 0,
+                               fs->blocksize - pb->truncate_offset);
+                        pb->errcode = io_channel_write_blk(fs->io, blk, 1,
+                                                         pb->buf);
+                        if (pb->errcode)
+                                goto return_abort;
+                }
+                pb->truncated_blocks++;
+                *block_nr = 0;
+                retval |= BLOCK_CHANGED;
+        }
+
+        ext2fs_block_alloc_stats(fs, blk, -1);
+        return retval;
+}
+
+/*
+ * This function releases an inode.  Returns 1 if an inconsistency was
+ * found.  If the inode has a link count, then it is being truncated and
+ * not deleted.
+ */
+static int release_inode_blocks(e2fsck_t ctx, ext2_ino_t ino,
+                                struct ext2_inode *inode, char *block_buf,
+                                struct problem_context *pctx)
+{
+        struct process_block_struct     pb;
+        ext2_filsys                     fs = ctx->fs;
+        errcode_t                       retval;
+        __u32                           count;
+
+        if (!ext2fs_inode_has_valid_blocks(inode))
+                return 0;
+
+        pb.buf = block_buf + 3 * ctx->fs->blocksize;
+        pb.ctx = ctx;
+        pb.abort = 0;
+        pb.errcode = 0;
+        pb.pctx = pctx;
+        if (inode->i_links_count) {
+                pb.truncating = 1;
+                pb.truncate_block = (e2_blkcnt_t)
+                        ((((long long)inode->i_size_high << 32) +
+                          inode->i_size + fs->blocksize - 1) /
+                         fs->blocksize);
+                pb.truncate_offset = inode->i_size % fs->blocksize;
+        } else {
+                pb.truncating = 0;
+                pb.truncate_block = 0;
+                pb.truncate_offset = 0;
+        }
+        pb.truncated_blocks = 0;
+        retval = ext2fs_block_iterate2(fs, ino, BLOCK_FLAG_DEPTH_TRAVERSE,
+                                      block_buf, release_inode_block, &pb);
+        if (retval) {
+                com_err("release_inode_blocks", retval,
+                        _("while calling ext2fs_block_iterate for inode %d"),
+                        ino);
+                return 1;
+        }
+        if (pb.abort)
+                return 1;
+
+        /* Refresh the inode since ext2fs_block_iterate may have changed it */
+        e2fsck_read_inode(ctx, ino, inode, "release_inode_blocks");
+
+        if (pb.truncated_blocks)
+                inode->i_blocks -= pb.truncated_blocks *
+                        (fs->blocksize / 512);
+
+        if (inode->i_file_acl) {
+                retval = ext2fs_adjust_ea_refcount(fs, inode->i_file_acl,
+                                                   block_buf, -1, &count);
+                if (retval == EXT2_ET_BAD_EA_BLOCK_NUM) {
+                        retval = 0;
+                        count = 1;
+                }
+                if (retval) {
+                        com_err("release_inode_blocks", retval,
+                _("while calling ext2fs_adjust_ea_refocunt for inode %d"),
+                                ino);
+                        return 1;
+                }
+                if (count == 0)
+                        ext2fs_block_alloc_stats(fs, inode->i_file_acl, -1);
+                inode->i_file_acl = 0;
+        }
+        return 0;
+}
+
+/*
+ * This function releases all of the orphan inodes.  It returns 1 if
+ * it hit some error, and 0 on success.
+ */
+static int release_orphan_inodes(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        ext2_ino_t      ino, next_ino;
+        struct ext2_inode inode;
+        struct problem_context pctx;
+        char *block_buf;
+
+        if ((ino = fs->super->s_last_orphan) == 0)
+                return 0;
+
+        /*
+         * Win or lose, we won't be using the head of the orphan inode
+         * list again.
+         */
+        fs->super->s_last_orphan = 0;
+        ext2fs_mark_super_dirty(fs);
+
+        /*
+         * If the filesystem contains errors, don't run the orphan
+         * list, since the orphan list can't be trusted; and we're
+         * going to be running a full e2fsck run anyway...
+         */
+        if (fs->super->s_state & EXT2_ERROR_FS)
+                return 0;
+
+        if ((ino < EXT2_FIRST_INODE(fs->super)) ||
+            (ino > fs->super->s_inodes_count)) {
+                clear_problem_context(&pctx);
+                pctx.ino = ino;
+                fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_HEAD_INODE, &pctx);
+                return 1;
+        }
+
+        block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4,
+                                                    "block iterate buffer");
+        e2fsck_read_bitmaps(ctx);
+
+        while (ino) {
+                e2fsck_read_inode(ctx, ino, &inode, "release_orphan_inodes");
+                clear_problem_context(&pctx);
+                pctx.ino = ino;
+                pctx.inode = &inode;
+                pctx.str = inode.i_links_count ? _("Truncating") :
+                        _("Clearing");
+
+                fix_problem(ctx, PR_0_ORPHAN_CLEAR_INODE, &pctx);
+
+                next_ino = inode.i_dtime;
+                if (next_ino &&
+                    ((next_ino < EXT2_FIRST_INODE(fs->super)) ||
+                     (next_ino > fs->super->s_inodes_count))) {
+                        pctx.ino = next_ino;
+                        fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_INODE, &pctx);
+                        goto return_abort;
+                }
+
+                if (release_inode_blocks(ctx, ino, &inode, block_buf, &pctx))
+                        goto return_abort;
+
+                if (!inode.i_links_count) {
+                        ext2fs_inode_alloc_stats2(fs, ino, -1,
+                                                  LINUX_S_ISDIR(inode.i_mode));
+                        inode.i_dtime = time(0);
+                } else {
+                        inode.i_dtime = 0;
+                }
+                e2fsck_write_inode(ctx, ino, &inode, "delete_file");
+                ino = next_ino;
+        }
+        ext2fs_free_mem(&block_buf);
+        return 0;
+return_abort:
+        ext2fs_free_mem(&block_buf);
+        return 1;
+}
+
+/*
+ * Check the resize inode to make sure it is sane.  We check both for
+ * the case where on-line resizing is not enabled (in which case the
+ * resize inode should be cleared) as well as the case where on-line
+ * resizing is enabled.
+ */
+static void check_resize_inode(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        struct ext2_inode inode;
+        struct problem_context  pctx;
+        int             i, j, gdt_off, ind_off;
+        blk_t           blk, pblk, expect;
+        __u32           *dind_buf = 0, *ind_buf;
+        errcode_t       retval;
+
+        clear_problem_context(&pctx);
+
+        /*
+         * If the resize inode feature isn't set, then
+         * s_reserved_gdt_blocks must be zero.
+         */
+        if (!(fs->super->s_feature_compat &
+              EXT2_FEATURE_COMPAT_RESIZE_INODE)) {
+                if (fs->super->s_reserved_gdt_blocks) {
+                        pctx.num = fs->super->s_reserved_gdt_blocks;
+                        if (fix_problem(ctx, PR_0_NONZERO_RESERVED_GDT_BLOCKS,
+                                        &pctx)) {
+                                fs->super->s_reserved_gdt_blocks = 0;
+                                ext2fs_mark_super_dirty(fs);
+                        }
+                }
+        }
+
+        /* Read the resizde inode */
+        pctx.ino = EXT2_RESIZE_INO;
+        retval = ext2fs_read_inode(fs, EXT2_RESIZE_INO, &inode);
+        if (retval) {
+                if (fs->super->s_feature_compat &
+                    EXT2_FEATURE_COMPAT_RESIZE_INODE)
+                        ctx->flags |= E2F_FLAG_RESIZE_INODE;
+                return;
+        }
+
+        /*
+         * If the resize inode feature isn't set, check to make sure
+         * the resize inode is cleared; then we're done.
+         */
+        if (!(fs->super->s_feature_compat &
+              EXT2_FEATURE_COMPAT_RESIZE_INODE)) {
+                for (i=0; i < EXT2_N_BLOCKS; i++) {
+                        if (inode.i_block[i])
+                                break;
+                }
+                if ((i < EXT2_N_BLOCKS) &&
+                    fix_problem(ctx, PR_0_CLEAR_RESIZE_INODE, &pctx)) {
+                        memset(&inode, 0, sizeof(inode));
+                        e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode,
+                                           "clear_resize");
+                }
+                return;
+        }
+
+        /*
+         * The resize inode feature is enabled; check to make sure the
+         * only block in use is the double indirect block
+         */
+        blk = inode.i_block[EXT2_DIND_BLOCK];
+        for (i=0; i < EXT2_N_BLOCKS; i++) {
+                if (i != EXT2_DIND_BLOCK && inode.i_block[i])
+                        break;
+        }
+        if ((i < EXT2_N_BLOCKS) || !blk || !inode.i_links_count ||
+            !(inode.i_mode & LINUX_S_IFREG) ||
+            (blk < fs->super->s_first_data_block ||
+             blk >= fs->super->s_blocks_count)) {
+        resize_inode_invalid:
+                if (fix_problem(ctx, PR_0_RESIZE_INODE_INVALID, &pctx)) {
+                        memset(&inode, 0, sizeof(inode));
+                        e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode,
+                                           "clear_resize");
+                        ctx->flags |= E2F_FLAG_RESIZE_INODE;
+                }
+                if (!(ctx->options & E2F_OPT_READONLY)) {
+                        fs->super->s_state &= ~EXT2_VALID_FS;
+                        ext2fs_mark_super_dirty(fs);
+                }
+                goto cleanup;
+        }
+        dind_buf = (__u32 *) e2fsck_allocate_memory(ctx, fs->blocksize * 2,
+                                                    "resize dind buffer");
+        ind_buf = (__u32 *) ((char *) dind_buf + fs->blocksize);
+
+        retval = ext2fs_read_ind_block(fs, blk, dind_buf);
+        if (retval)
+                goto resize_inode_invalid;
+
+        gdt_off = fs->desc_blocks;
+        pblk = fs->super->s_first_data_block + 1 + fs->desc_blocks;
+        for (i = 0; i < fs->super->s_reserved_gdt_blocks / 4;
+             i++, gdt_off++, pblk++) {
+                gdt_off %= fs->blocksize/4;
+                if (dind_buf[gdt_off] != pblk)
+                        goto resize_inode_invalid;
+                retval = ext2fs_read_ind_block(fs, pblk, ind_buf);
+                if (retval)
+                        goto resize_inode_invalid;
+                ind_off = 0;
+                for (j = 1; j < fs->group_desc_count; j++) {
+                        if (!ext2fs_bg_has_super(fs, j))
+                                continue;
+                        expect = pblk + (j * fs->super->s_blocks_per_group);
+                        if (ind_buf[ind_off] != expect)
+                                goto resize_inode_invalid;
+                        ind_off++;
+                }
+        }
+
+cleanup:
+        if (dind_buf)
+                ext2fs_free_mem(&dind_buf);
+
+ }
+
+void check_super_block(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        blk_t   first_block, last_block;
+        struct ext2_super_block *sb = fs->super;
+        struct ext2_group_desc *gd;
+        blk_t   blocks_per_group = fs->super->s_blocks_per_group;
+        blk_t   bpg_max;
+        int     inodes_per_block;
+        int     ipg_max;
+        int     inode_size;
+        dgrp_t  i;
+        blk_t   should_be;
+        struct problem_context  pctx;
+        __u32   free_blocks = 0, free_inodes = 0;
+
+        inodes_per_block = EXT2_INODES_PER_BLOCK(fs->super);
+        ipg_max = inodes_per_block * (blocks_per_group - 4);
+        if (ipg_max > EXT2_MAX_INODES_PER_GROUP(sb))
+                ipg_max = EXT2_MAX_INODES_PER_GROUP(sb);
+        bpg_max = 8 * EXT2_BLOCK_SIZE(sb);
+        if (bpg_max > EXT2_MAX_BLOCKS_PER_GROUP(sb))
+                bpg_max = EXT2_MAX_BLOCKS_PER_GROUP(sb);
+
+        ctx->invalid_inode_bitmap_flag = (int *) e2fsck_allocate_memory(ctx,
+                 sizeof(int) * fs->group_desc_count, "invalid_inode_bitmap");
+        ctx->invalid_block_bitmap_flag = (int *) e2fsck_allocate_memory(ctx,
+                 sizeof(int) * fs->group_desc_count, "invalid_block_bitmap");
+        ctx->invalid_inode_table_flag = (int *) e2fsck_allocate_memory(ctx,
+                sizeof(int) * fs->group_desc_count, "invalid_inode_table");
+
+        clear_problem_context(&pctx);
+
+        /*
+         * Verify the super block constants...
+         */
+        check_super_value(ctx, "inodes_count", sb->s_inodes_count,
+                          MIN_CHECK, 1, 0);
+        check_super_value(ctx, "blocks_count", sb->s_blocks_count,
+                          MIN_CHECK, 1, 0);
+        check_super_value(ctx, "first_data_block", sb->s_first_data_block,
+                          MAX_CHECK, 0, sb->s_blocks_count);
+        check_super_value(ctx, "log_block_size", sb->s_log_block_size,
+                          MIN_CHECK | MAX_CHECK, 0,
+                          EXT2_MAX_BLOCK_LOG_SIZE - EXT2_MIN_BLOCK_LOG_SIZE);
+        check_super_value(ctx, "log_frag_size", sb->s_log_frag_size,
+                          MIN_CHECK | MAX_CHECK, 0, sb->s_log_block_size);
+        check_super_value(ctx, "frags_per_group", sb->s_frags_per_group,
+                          MIN_CHECK | MAX_CHECK, sb->s_blocks_per_group,
+                          bpg_max);
+        check_super_value(ctx, "blocks_per_group", sb->s_blocks_per_group,
+                          MIN_CHECK | MAX_CHECK, 8, bpg_max);
+        check_super_value(ctx, "inodes_per_group", sb->s_inodes_per_group,
+                          MIN_CHECK | MAX_CHECK, inodes_per_block, ipg_max);
+        check_super_value(ctx, "r_blocks_count", sb->s_r_blocks_count,
+                          MAX_CHECK, 0, sb->s_blocks_count / 2);
+        check_super_value(ctx, "reserved_gdt_blocks",
+                          sb->s_reserved_gdt_blocks, MAX_CHECK, 0,
+                          fs->blocksize/4);
+        inode_size = EXT2_INODE_SIZE(sb);
+        check_super_value(ctx, "inode_size",
+                          inode_size, MIN_CHECK | MAX_CHECK,
+                          EXT2_GOOD_OLD_INODE_SIZE, fs->blocksize);
+        if (inode_size & (inode_size - 1)) {
+                pctx.num = inode_size;
+                pctx.str = "inode_size";
+                fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT; /* never get here! */
+                return;
+        }
+
+        if (!ctx->num_blocks) {
+                pctx.errcode = e2fsck_get_device_size(ctx);
+                if (pctx.errcode && pctx.errcode != EXT2_ET_UNIMPLEMENTED) {
+                        fix_problem(ctx, PR_0_GETSIZE_ERROR, &pctx);
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return;
+                }
+                if ((pctx.errcode != EXT2_ET_UNIMPLEMENTED) &&
+                    (ctx->num_blocks < sb->s_blocks_count)) {
+                        pctx.blk = sb->s_blocks_count;
+                        pctx.blk2 = ctx->num_blocks;
+                        if (fix_problem(ctx, PR_0_FS_SIZE_WRONG, &pctx)) {
+                                ctx->flags |= E2F_FLAG_ABORT;
+                                return;
+                        }
+                }
+        }
+
+        if (sb->s_log_block_size != (__u32) sb->s_log_frag_size) {
+                pctx.blk = EXT2_BLOCK_SIZE(sb);
+                pctx.blk2 = EXT2_FRAG_SIZE(sb);
+                fix_problem(ctx, PR_0_NO_FRAGMENTS, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+
+        should_be = sb->s_frags_per_group >>
+                (sb->s_log_block_size - sb->s_log_frag_size);
+        if (sb->s_blocks_per_group != should_be) {
+                pctx.blk = sb->s_blocks_per_group;
+                pctx.blk2 = should_be;
+                fix_problem(ctx, PR_0_BLOCKS_PER_GROUP, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+
+        should_be = (sb->s_log_block_size == 0) ? 1 : 0;
+        if (sb->s_first_data_block != should_be) {
+                pctx.blk = sb->s_first_data_block;
+                pctx.blk2 = should_be;
+                fix_problem(ctx, PR_0_FIRST_DATA_BLOCK, &pctx);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+
+        should_be = sb->s_inodes_per_group * fs->group_desc_count;
+        if (sb->s_inodes_count != should_be) {
+                pctx.ino = sb->s_inodes_count;
+                pctx.ino2 = should_be;
+                if (fix_problem(ctx, PR_0_INODE_COUNT_WRONG, &pctx)) {
+                        sb->s_inodes_count = should_be;
+                        ext2fs_mark_super_dirty(fs);
+                }
+        }
+
+        /*
+         * Verify the group descriptors....
+         */
+        first_block =  sb->s_first_data_block;
+        last_block = first_block + blocks_per_group;
+
+        for (i = 0, gd=fs->group_desc; i < fs->group_desc_count; i++, gd++) {
+                pctx.group = i;
+
+                if (i == fs->group_desc_count - 1)
+                        last_block = sb->s_blocks_count;
+                if ((gd->bg_block_bitmap < first_block) ||
+                    (gd->bg_block_bitmap >= last_block)) {
+                        pctx.blk = gd->bg_block_bitmap;
+                        if (fix_problem(ctx, PR_0_BB_NOT_GROUP, &pctx))
+                                gd->bg_block_bitmap = 0;
+                }
+                if (gd->bg_block_bitmap == 0) {
+                        ctx->invalid_block_bitmap_flag[i]++;
+                        ctx->invalid_bitmaps++;
+                }
+                if ((gd->bg_inode_bitmap < first_block) ||
+                    (gd->bg_inode_bitmap >= last_block)) {
+                        pctx.blk = gd->bg_inode_bitmap;
+                        if (fix_problem(ctx, PR_0_IB_NOT_GROUP, &pctx))
+                                gd->bg_inode_bitmap = 0;
+                }
+                if (gd->bg_inode_bitmap == 0) {
+                        ctx->invalid_inode_bitmap_flag[i]++;
+                        ctx->invalid_bitmaps++;
+                }
+                if ((gd->bg_inode_table < first_block) ||
+                    ((gd->bg_inode_table +
+                      fs->inode_blocks_per_group - 1) >= last_block)) {
+                        pctx.blk = gd->bg_inode_table;
+                        if (fix_problem(ctx, PR_0_ITABLE_NOT_GROUP, &pctx))
+                                gd->bg_inode_table = 0;
+                }
+                if (gd->bg_inode_table == 0) {
+                        ctx->invalid_inode_table_flag[i]++;
+                        ctx->invalid_bitmaps++;
+                }
+                free_blocks += gd->bg_free_blocks_count;
+                free_inodes += gd->bg_free_inodes_count;
+                first_block += sb->s_blocks_per_group;
+                last_block += sb->s_blocks_per_group;
+
+                if ((gd->bg_free_blocks_count > sb->s_blocks_per_group) ||
+                    (gd->bg_free_inodes_count > sb->s_inodes_per_group) ||
+                    (gd->bg_used_dirs_count > sb->s_inodes_per_group))
+                        ext2fs_unmark_valid(fs);
+
+        }
+
+        /*
+         * Update the global counts from the block group counts.  This
+         * is needed for an experimental patch which eliminates
+         * locking the entire filesystem when allocating blocks or
+         * inodes; if the filesystem is not unmounted cleanly, the
+         * global counts may not be accurate.
+         */
+        if ((free_blocks != sb->s_free_blocks_count) ||
+            (free_inodes != sb->s_free_inodes_count)) {
+                if (ctx->options & E2F_OPT_READONLY)
+                        ext2fs_unmark_valid(fs);
+                else {
+                        sb->s_free_blocks_count = free_blocks;
+                        sb->s_free_inodes_count = free_inodes;
+                        ext2fs_mark_super_dirty(fs);
+                }
+        }
+
+        if ((sb->s_free_blocks_count > sb->s_blocks_count) ||
+            (sb->s_free_inodes_count > sb->s_inodes_count))
+                ext2fs_unmark_valid(fs);
+
+
+        /*
+         * If we have invalid bitmaps, set the error state of the
+         * filesystem.
+         */
+        if (ctx->invalid_bitmaps && !(ctx->options & E2F_OPT_READONLY)) {
+                sb->s_state &= ~EXT2_VALID_FS;
+                ext2fs_mark_super_dirty(fs);
+        }
+
+        clear_problem_context(&pctx);
+
+#ifndef EXT2_SKIP_UUID
+        /*
+         * If the UUID field isn't assigned, assign it.
+         */
+        if (!(ctx->options & E2F_OPT_READONLY) && uuid_is_null(sb->s_uuid)) {
+                if (fix_problem(ctx, PR_0_ADD_UUID, &pctx)) {
+                        uuid_generate(sb->s_uuid);
+                        ext2fs_mark_super_dirty(fs);
+                        fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
+                }
+        }
+#endif
+
+        /*
+         * For the Hurd, check to see if the filetype option is set,
+         * since it doesn't support it.
+         */
+        if (!(ctx->options & E2F_OPT_READONLY) &&
+            fs->super->s_creator_os == EXT2_OS_HURD &&
+            (fs->super->s_feature_incompat &
+             EXT2_FEATURE_INCOMPAT_FILETYPE)) {
+                if (fix_problem(ctx, PR_0_HURD_CLEAR_FILETYPE, &pctx)) {
+                        fs->super->s_feature_incompat &=
+                                ~EXT2_FEATURE_INCOMPAT_FILETYPE;
+                        ext2fs_mark_super_dirty(fs);
+
+                }
+        }
+
+        /*
+         * If we have any of the compatibility flags set, we need to have a
+         * revision 1 filesystem.  Most kernels will not check the flags on
+         * a rev 0 filesystem and we may have corruption issues because of
+         * the incompatible changes to the filesystem.
+         */
+        if (!(ctx->options & E2F_OPT_READONLY) &&
+            fs->super->s_rev_level == EXT2_GOOD_OLD_REV &&
+            (fs->super->s_feature_compat ||
+             fs->super->s_feature_ro_compat ||
+             fs->super->s_feature_incompat) &&
+            fix_problem(ctx, PR_0_FS_REV_LEVEL, &pctx)) {
+                ext2fs_update_dynamic_rev(fs);
+                ext2fs_mark_super_dirty(fs);
+        }
+
+        check_resize_inode(ctx);
+
+        /*
+         * Clean up any orphan inodes, if present.
+         */
+        if (!(ctx->options & E2F_OPT_READONLY) && release_orphan_inodes(ctx)) {
+                fs->super->s_state &= ~EXT2_VALID_FS;
+                ext2fs_mark_super_dirty(fs);
+        }
+
+        /*
+         * Move the ext3 journal file, if necessary.
+         */
+        e2fsck_move_ext3_journal(ctx);
+        return;
+}
+/*
+ * swapfs.c --- byte-swap an ext2 filesystem
+ *
+ * Copyright 1996, 1997 by Theodore Ts'o
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ *
+ */
+
+#ifdef ENABLE_SWAPFS
+
+struct swap_block_struct {
+        ext2_ino_t      ino;
+        int             isdir;
+        errcode_t       errcode;
+        char            *dir_buf;
+        struct ext2_inode *inode;
+};
+
+/*
+ * This is a helper function for block_iterate.  We mark all of the
+ * indirect and direct blocks as changed, so that block_iterate will
+ * write them out.
+ */
+static int swap_block(ext2_filsys fs, blk_t *block_nr, int blockcnt,
+                      void *priv_data)
+{
+        errcode_t       retval;
+
+        struct swap_block_struct *sb = (struct swap_block_struct *) priv_data;
+
+        if (sb->isdir && (blockcnt >= 0) && *block_nr) {
+                retval = ext2fs_read_dir_block(fs, *block_nr, sb->dir_buf);
+                if (retval) {
+                        sb->errcode = retval;
+                        return BLOCK_ABORT;
+                }
+                retval = ext2fs_write_dir_block(fs, *block_nr, sb->dir_buf);
+                if (retval) {
+                        sb->errcode = retval;
+                        return BLOCK_ABORT;
+                }
+        }
+        if (blockcnt >= 0) {
+                if (blockcnt < EXT2_NDIR_BLOCKS)
+                        return 0;
+                return BLOCK_CHANGED;
+        }
+        if (blockcnt == BLOCK_COUNT_IND) {
+                if (*block_nr == sb->inode->i_block[EXT2_IND_BLOCK])
+                        return 0;
+                return BLOCK_CHANGED;
+        }
+        if (blockcnt == BLOCK_COUNT_DIND) {
+                if (*block_nr == sb->inode->i_block[EXT2_DIND_BLOCK])
+                        return 0;
+                return BLOCK_CHANGED;
+        }
+        if (blockcnt == BLOCK_COUNT_TIND) {
+                if (*block_nr == sb->inode->i_block[EXT2_TIND_BLOCK])
+                        return 0;
+                return BLOCK_CHANGED;
+        }
+        return BLOCK_CHANGED;
+}
+
+/*
+ * This function is responsible for byte-swapping all of the indirect,
+ * block pointers.  It is also responsible for byte-swapping directories.
+ */
+static void swap_inode_blocks(e2fsck_t ctx, ext2_ino_t ino, char *block_buf,
+                              struct ext2_inode *inode)
+{
+        errcode_t                       retval;
+        struct swap_block_struct        sb;
+
+        sb.ino = ino;
+        sb.inode = inode;
+        sb.dir_buf = block_buf + ctx->fs->blocksize*3;
+        sb.errcode = 0;
+        sb.isdir = 0;
+        if (LINUX_S_ISDIR(inode->i_mode))
+                sb.isdir = 1;
+
+        retval = ext2fs_block_iterate(ctx->fs, ino, 0, block_buf,
+                                      swap_block, &sb);
+        if (retval) {
+                com_err("swap_inode_blocks", retval,
+                        _("while calling ext2fs_block_iterate"));
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+        if (sb.errcode) {
+                com_err("swap_inode_blocks", sb.errcode,
+                        _("while calling iterator function"));
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+}
+
+static void swap_inodes(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        dgrp_t                  group;
+        unsigned int            i;
+        ext2_ino_t              ino = 1;
+        char                    *buf, *block_buf;
+        errcode_t               retval;
+        struct ext2_inode *     inode;
+
+        e2fsck_use_inode_shortcuts(ctx, 1);
+
+        retval = ext2fs_get_mem(fs->blocksize * fs->inode_blocks_per_group,
+                                &buf);
+        if (retval) {
+                com_err("swap_inodes", retval,
+                        _("while allocating inode buffer"));
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+        block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4,
+                                                    "block interate buffer");
+        for (group = 0; group < fs->group_desc_count; group++) {
+                retval = io_channel_read_blk(fs->io,
+                      fs->group_desc[group].bg_inode_table,
+                      fs->inode_blocks_per_group, buf);
+                if (retval) {
+                        com_err("swap_inodes", retval,
+                                _("while reading inode table (group %d)"),
+                                group);
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return;
+                }
+                inode = (struct ext2_inode *) buf;
+                for (i=0; i < fs->super->s_inodes_per_group;
+                     i++, ino++, inode++) {
+                        ctx->stashed_ino = ino;
+                        ctx->stashed_inode = inode;
+
+                        if (fs->flags & EXT2_FLAG_SWAP_BYTES_READ)
+                                ext2fs_swap_inode(fs, inode, inode, 0);
+
+                        /*
+                         * Skip deleted files.
+                         */
+                        if (inode->i_links_count == 0)
+                                continue;
+
+                        if (LINUX_S_ISDIR(inode->i_mode) ||
+                            ((inode->i_block[EXT2_IND_BLOCK] ||
+                              inode->i_block[EXT2_DIND_BLOCK] ||
+                              inode->i_block[EXT2_TIND_BLOCK]) &&
+                             ext2fs_inode_has_valid_blocks(inode)))
+                                swap_inode_blocks(ctx, ino, block_buf, inode);
+
+                        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                                return;
+
+                        if (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE)
+                                ext2fs_swap_inode(fs, inode, inode, 1);
+                }
+                retval = io_channel_write_blk(fs->io,
+                      fs->group_desc[group].bg_inode_table,
+                      fs->inode_blocks_per_group, buf);
+                if (retval) {
+                        com_err("swap_inodes", retval,
+                                _("while writing inode table (group %d)"),
+                                group);
+                        ctx->flags |= E2F_FLAG_ABORT;
+                        return;
+                }
+        }
+        ext2fs_free_mem(&buf);
+        ext2fs_free_mem(&block_buf);
+        e2fsck_use_inode_shortcuts(ctx, 0);
+        ext2fs_flush_icache(fs);
+}
+
+#if defined(__powerpc__) && defined(EXT2FS_ENABLE_SWAPFS)
+/*
+ * On the PowerPC, the big-endian variant of the ext2 filesystem
+ * has its bitmaps stored as 32-bit words with bit 0 as the LSB
+ * of each word.  Thus a bitmap with only bit 0 set would be, as
+ * a string of bytes, 00 00 00 01 00 ...
+ * To cope with this, we byte-reverse each word of a bitmap if
+ * we have a big-endian filesystem, that is, if we are *not*
+ * byte-swapping other word-sized numbers.
+ */
+#define EXT2_BIG_ENDIAN_BITMAPS
+#endif
+
+#ifdef EXT2_BIG_ENDIAN_BITMAPS
+static void ext2fs_swap_bitmap(ext2fs_generic_bitmap bmap)
+{
+        __u32 *p = (__u32 *) bmap->bitmap;
+        int n, nbytes = (bmap->end - bmap->start + 7) / 8;
+
+        for (n = nbytes / sizeof(__u32); n > 0; --n, ++p)
+                *p = ext2fs_swab32(*p);
+}
+#endif
+
+
+#ifdef ENABLE_SWAPFS
+void swap_filesys(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+#ifdef RESOURCE_TRACK
+        struct resource_track   rtrack;
+
+        init_resource_track(&rtrack);
+#endif
+
+        if (!(ctx->options & E2F_OPT_PREEN))
+                printf(_("Pass 0: Doing byte-swap of filesystem\n"));
+
+#ifdef MTRACE
+        mtrace_print("Byte swap");
+#endif
+
+        if (fs->super->s_mnt_count) {
+                fprintf(stderr, _("%s: the filesystem must be freshly "
+                        "checked using fsck\n"
+                        "and not mounted before trying to "
+                        "byte-swap it.\n"), ctx->device_name);
+                ctx->flags |= E2F_FLAG_ABORT;
+                return;
+        }
+        if (fs->flags & EXT2_FLAG_SWAP_BYTES) {
+                fs->flags &= ~(EXT2_FLAG_SWAP_BYTES|
+                               EXT2_FLAG_SWAP_BYTES_WRITE);
+                fs->flags |= EXT2_FLAG_SWAP_BYTES_READ;
+        } else {
+                fs->flags &= ~EXT2_FLAG_SWAP_BYTES_READ;
+                fs->flags |= EXT2_FLAG_SWAP_BYTES_WRITE;
+        }
+        swap_inodes(ctx);
+        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
+                return;
+        if (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE)
+                fs->flags |= EXT2_FLAG_SWAP_BYTES;
+        fs->flags &= ~(EXT2_FLAG_SWAP_BYTES_READ|
+                       EXT2_FLAG_SWAP_BYTES_WRITE);
+
+#ifdef EXT2_BIG_ENDIAN_BITMAPS
+        e2fsck_read_bitmaps(ctx);
+        ext2fs_swap_bitmap(fs->inode_map);
+        ext2fs_swap_bitmap(fs->block_map);
+        fs->flags |= EXT2_FLAG_BB_DIRTY | EXT2_FLAG_IB_DIRTY;
+#endif
+        fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
+        ext2fs_flush(fs);
+        fs->flags |= EXT2_FLAG_MASTER_SB_ONLY;
+
+#ifdef RESOURCE_TRACK
+        if (ctx->options & E2F_OPT_TIME2)
+                print_resource_track(_("Byte swap"), &rtrack);
+#endif
+}
+#endif  /* ENABLE_SWAPFS */
+
+#endif
+/*
+ * util.c --- miscellaneous utilities
+ *
+ * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ */
+
+#ifdef HAVE_CONIO_H
+#undef HAVE_TERMIOS_H
+#include <conio.h>
+#define read_a_char()   getch()
+#else
+#ifdef HAVE_TERMIOS_H
+#include <termios.h>
+#endif
+#endif
+
+#if 0
+void fatal_error(e2fsck_t ctx, const char *msg)
+{
+        if (msg)
+                fprintf (stderr, "e2fsck: %s\n", msg);
+        if (ctx->fs && ctx->fs->io) {
+                if (ctx->fs->io->magic == EXT2_ET_MAGIC_IO_CHANNEL)
+                        io_channel_flush(ctx->fs->io);
+                else
+                        fprintf(stderr, "e2fsck: io manager magic bad!\n");
+        }
+        ctx->flags |= E2F_FLAG_ABORT;
+        if (ctx->flags & E2F_FLAG_SETJMP_OK)
+                longjmp(ctx->abort_loc, 1);
+        exit(FSCK_ERROR);
+}
+#endif
+
+void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size,
+                             const char *description)
+{
+        void *ret;
+        char buf[256];
+
+#ifdef DEBUG_ALLOCATE_MEMORY
+        printf("Allocating %d bytes for %s...\n", size, description);
+#endif
+        ret = malloc(size);
+        if (!ret) {
+                sprintf(buf, "Can't allocate %s\n", description);
+                fatal_error(ctx, buf);
+        }
+        memset(ret, 0, size);
+        return ret;
+}
+
+char *string_copy(e2fsck_t ctx EXT2FS_ATTR((unused)),
+                  const char *str, int len)
+{
+        char    *ret;
+
+        if (!str)
+                return NULL;
+        if (!len)
+                len = strlen(str);
+        ret = malloc(len+1);
+        if (ret) {
+                strncpy(ret, str, len);
+                ret[len] = 0;
+        }
+        return ret;
+}
+
+#ifndef HAVE_CONIO_H
+static int read_a_char(void)
+{
+        char    c;
+        int     r;
+        int     fail = 0;
+
+        while(1) {
+                if (e2fsck_global_ctx &&
+                    (e2fsck_global_ctx->flags & E2F_FLAG_CANCEL)) {
+                        return 3;
+                }
+                r = read(0, &c, 1);
+                if (r == 1)
+                        return c;
+                if (fail++ > 100)
+                        break;
+        }
+        return EOF;
+}
+#endif
+
+int ask_yn(const char * string, int def)
+{
+        int             c;
+        const char      *defstr;
+        const char      *short_yes = _("yY");
+        const char      *short_no = _("nN");
+
+#ifdef HAVE_TERMIOS_H
+        struct termios  termios, tmp;
+
+        tcgetattr (0, &termios);
+        tmp = termios;
+        tmp.c_lflag &= ~(ICANON | ECHO);
+        tmp.c_cc[VMIN] = 1;
+        tmp.c_cc[VTIME] = 0;
+        tcsetattr (0, TCSANOW, &tmp);
+#endif
+
+        if (def == 1)
+                defstr = _(_("<y>"));
+        else if (def == 0)
+                defstr = _(_("<n>"));
+        else
+                defstr = _(" (y/n)");
+        printf("%s%s? ", string, defstr);
+        while (1) {
+                fflush (stdout);
+                if ((c = read_a_char()) == EOF)
+                        break;
+                if (c == 3) {
+#ifdef HAVE_TERMIOS_H
+                        tcsetattr (0, TCSANOW, &termios);
+#endif
+                        if (e2fsck_global_ctx &&
+                            e2fsck_global_ctx->flags & E2F_FLAG_SETJMP_OK) {
+                                puts("\n");
+                                longjmp(e2fsck_global_ctx->abort_loc, 1);
+                        }
+                        puts(_("cancelled!\n"));
+                        return 0;
+                }
+                if (strchr(short_yes, (char) c)) {
+                        def = 1;
+                        break;
+                }
+                else if (strchr(short_no, (char) c)) {
+                        def = 0;
+                        break;
+                }
+                else if ((c == ' ' || c == '\n') && (def != -1))
+                        break;
+        }
+        if (def)
+                puts(_("yes\n"));
+        else
+                puts (_("no\n"));
+#ifdef HAVE_TERMIOS_H
+        tcsetattr (0, TCSANOW, &termios);
+#endif
+        return def;
+}
+
+int ask (e2fsck_t ctx, const char * string, int def)
+{
+        if (ctx->options & E2F_OPT_NO) {
+                printf (_("%s? no\n\n"), string);
+                return 0;
+        }
+        if (ctx->options & E2F_OPT_YES) {
+                printf (_("%s? yes\n\n"), string);
+                return 1;
+        }
+        if (ctx->options & E2F_OPT_PREEN) {
+                printf ("%s? %s\n\n", string, def ? _("yes") : _("no"));
+                return def;
+        }
+        return ask_yn(string, def);
+}
+
+void e2fsck_read_bitmaps(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        errcode_t       retval;
+
+        if (ctx->invalid_bitmaps) {
+                com_err(ctx->program_name, 0,
+                    _("e2fsck_read_bitmaps: illegal bitmap block(s) for %s"),
+                        ctx->device_name);
+                fatal_error(ctx, 0);
+        }
+
+        ehandler_operation(_("reading inode and block bitmaps"));
+        retval = ext2fs_read_bitmaps(fs);
+        ehandler_operation(0);
+        if (retval) {
+                com_err(ctx->program_name, retval,
+                        _("while retrying to read bitmaps for %s"),
+                        ctx->device_name);
+                fatal_error(ctx, 0);
+        }
+}
+
+void e2fsck_write_bitmaps(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+        errcode_t       retval;
+
+        if (ext2fs_test_bb_dirty(fs)) {
+                ehandler_operation(_("writing block bitmaps"));
+                retval = ext2fs_write_block_bitmap(fs);
+                ehandler_operation(0);
+                if (retval) {
+                        com_err(ctx->program_name, retval,
+                            _("while retrying to write block bitmaps for %s"),
+                                ctx->device_name);
+                        fatal_error(ctx, 0);
+                }
+        }
+
+        if (ext2fs_test_ib_dirty(fs)) {
+                ehandler_operation(_("writing inode bitmaps"));
+                retval = ext2fs_write_inode_bitmap(fs);
+                ehandler_operation(0);
+                if (retval) {
+                        com_err(ctx->program_name, retval,
+                            _("while retrying to write inode bitmaps for %s"),
+                                ctx->device_name);
+                        fatal_error(ctx, 0);
+                }
+        }
+}
+
+void preenhalt(e2fsck_t ctx)
+{
+        ext2_filsys fs = ctx->fs;
+
+        if (!(ctx->options & E2F_OPT_PREEN))
+                return;
+        fprintf(stderr, _("\n\n%s: UNEXPECTED INCONSISTENCY; "
+                "RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"),
+               ctx->device_name);
+        if (fs != NULL) {
+                fs->super->s_state |= EXT2_ERROR_FS;
+                ext2fs_mark_super_dirty(fs);
+                ext2fs_close(fs);
+        }
+        exit(FSCK_UNCORRECTED);
+}
+
+#ifdef RESOURCE_TRACK
+void init_resource_track(struct resource_track *track)
+{
+#ifdef HAVE_GETRUSAGE
+        struct rusage r;
+#endif
+
+        track->brk_start = sbrk(0);
+        gettimeofday(&track->time_start, 0);
+#ifdef HAVE_GETRUSAGE
+#ifdef sun
+        memset(&r, 0, sizeof(struct rusage));
+#endif
+        getrusage(RUSAGE_SELF, &r);
+        track->user_start = r.ru_utime;
+        track->system_start = r.ru_stime;
+#else
+        track->user_start.tv_sec = track->user_start.tv_usec = 0;
+        track->system_start.tv_sec = track->system_start.tv_usec = 0;
+#endif
+}
+
+static _INLINE_ float timeval_subtract(struct timeval *tv1,
+                                       struct timeval *tv2)
+{
+        return ((tv1->tv_sec - tv2->tv_sec) +
+                ((float) (tv1->tv_usec - tv2->tv_usec)) / 1000000);
+}
+
+void print_resource_track(const char *desc, struct resource_track *track)
+{
+#ifdef HAVE_GETRUSAGE
+        struct rusage r;
+#endif
+#ifdef HAVE_MALLINFO
+        struct mallinfo malloc_info;
+#endif
+        struct timeval time_end;
+
+        gettimeofday(&time_end, 0);
+
+        if (desc)
+                printf("%s: ", desc);
+
+#ifdef HAVE_MALLINFO
+#define kbytes(x)       (((x) + 1023) / 1024)
+
+        malloc_info = mallinfo();
+        printf(_("Memory used: %dk/%dk (%dk/%dk), "),
+               kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd),
+               kbytes(malloc_info.uordblks), kbytes(malloc_info.fordblks));
+#else
+        printf(_("Memory used: %d, "),
+               (int) (((char *) sbrk(0)) - ((char *) track->brk_start)));
+#endif
+#ifdef HAVE_GETRUSAGE
+        getrusage(RUSAGE_SELF, &r);
+
+        printf(_("time: %5.2f/%5.2f/%5.2f\n"),
+               timeval_subtract(&time_end, &track->time_start),
+               timeval_subtract(&r.ru_utime, &track->user_start),
+               timeval_subtract(&r.ru_stime, &track->system_start));
+#else
+        printf(_("elapsed time: %6.3f\n"),
+               timeval_subtract(&time_end, &track->time_start));
+#endif
+}
+#endif /* RESOURCE_TRACK */
+
+void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino,
+                              struct ext2_inode * inode, const char *proc)
+{
+        int retval;
+
+        retval = ext2fs_read_inode(ctx->fs, ino, inode);
+        if (retval) {
+                com_err("ext2fs_read_inode", retval,
+                        _("while reading inode %ld in %s"), ino, proc);
+                fatal_error(ctx, 0);
+        }
+}
+
+extern void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino,
+                               struct ext2_inode * inode, int bufsize,
+                               const char *proc)
+{
+        int retval;
+
+        retval = ext2fs_write_inode_full(ctx->fs, ino, inode, bufsize);
+        if (retval) {
+                com_err("ext2fs_write_inode", retval,
+                        _("while writing inode %ld in %s"), ino, proc);
+                fatal_error(ctx, 0);
+        }
+}
+
+extern void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino,
+                               struct ext2_inode * inode, const char *proc)
+{
+        int retval;
+
+        retval = ext2fs_write_inode(ctx->fs, ino, inode);
+        if (retval) {
+                com_err("ext2fs_write_inode", retval,
+                        _("while writing inode %ld in %s"), ino, proc);
+                fatal_error(ctx, 0);
+        }
+}
+
+#ifdef MTRACE
+void mtrace_print(char *mesg)
+{
+        FILE    *malloc_get_mallstream();
+        FILE    *f = malloc_get_mallstream();
+
+        if (f)
+                fprintf(f, "============= %s\n", mesg);
+}
+#endif
+
+blk_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, const char *name,
+                   io_manager manager)
+{
+        struct ext2_super_block *sb;
+        io_channel              io = NULL;
+        void                    *buf = NULL;
+        int                     blocksize;
+        blk_t                   superblock, ret_sb = 8193;
+
+        if (fs && fs->super) {
+                ret_sb = (fs->super->s_blocks_per_group +
+                          fs->super->s_first_data_block);
+                if (ctx) {
+                        ctx->superblock = ret_sb;
+                        ctx->blocksize = fs->blocksize;
+                }
+                return ret_sb;
+        }
+
+        if (ctx) {
+                if (ctx->blocksize) {
+                        ret_sb = ctx->blocksize * 8;
+                        if (ctx->blocksize == 1024)
+                                ret_sb++;
+                        ctx->superblock = ret_sb;
+                        return ret_sb;
+                }
+                ctx->superblock = ret_sb;
+                ctx->blocksize = 1024;
+        }
+
+        if (!name || !manager)
+                goto cleanup;
+
+        if (manager->open(name, 0, &io) != 0)
+                goto cleanup;
+
+        if (ext2fs_get_mem(SUPERBLOCK_SIZE, &buf))
+                goto cleanup;
+        sb = (struct ext2_super_block *) buf;
+
+        for (blocksize = EXT2_MIN_BLOCK_SIZE;
+             blocksize <= EXT2_MAX_BLOCK_SIZE ; blocksize *= 2) {
+                superblock = blocksize*8;
+                if (blocksize == 1024)
+                        superblock++;
+                io_channel_set_blksize(io, blocksize);
+                if (io_channel_read_blk(io, superblock,
+                                        -SUPERBLOCK_SIZE, buf))
+                        continue;
+#ifdef EXT2FS_ENABLE_SWAPFS
+                if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
+                        ext2fs_swap_super(sb);
+#endif
+                if (sb->s_magic == EXT2_SUPER_MAGIC) {
+                        ret_sb = superblock;
+                        if (ctx) {
+                                ctx->superblock = superblock;
+                                ctx->blocksize = blocksize;
+                        }
+                        break;
+                }
+        }
+
+cleanup:
+        if (io)
+                io_channel_close(io);
+        if (buf)
+                ext2fs_free_mem(&buf);
+        return (ret_sb);
+}
+
+/*
+ * Given a mode, return the ext2 file type
+ */
+int ext2_file_type(unsigned int mode)
+{
+        if (LINUX_S_ISREG(mode))
+                return EXT2_FT_REG_FILE;
+
+        if (LINUX_S_ISDIR(mode))
+                return EXT2_FT_DIR;
+
+        if (LINUX_S_ISCHR(mode))
+                return EXT2_FT_CHRDEV;
+
+        if (LINUX_S_ISBLK(mode))
+                return EXT2_FT_BLKDEV;
+
+        if (LINUX_S_ISLNK(mode))
+                return EXT2_FT_SYMLINK;
+
+        if (LINUX_S_ISFIFO(mode))
+                return EXT2_FT_FIFO;
+
+        if (LINUX_S_ISSOCK(mode))
+                return EXT2_FT_SOCK;
+
+        return 0;
+}
+/*
+ * unix.c - The unix-specific code for e2fsck
+ *
+ * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ */
+
 
-#include "e2fsbb.h"
-#include "e2fsck/e2fsck.h"
-#include "e2fsck/problem.h"
 
 /* Command line options */
 static int swapfs;
 #ifdef ENABLE_SWAPFS
 static int normalize_swapfs;
 #endif
-static int cflag;               /* check disk */
+static int cflag;               /* check disk */
 static int show_version_only;
 static int verbose;
 
@@ -61,9 +15415,7 @@ static int replace_bad_blocks;
 static int keep_bad_blocks;
 static char *bad_blocks_file;
 
-e2fsck_t e2fsck_global_ctx;     /* Try your very best not to use this! */
-
-#ifdef __CONFIG_JBD_DEBUG__E2FS         /* Enabled by configure --enable-jfs-debug */
+#ifdef __CONFIG_JBD_DEBUG__E2FS         /* Enabled by configure --enable-jfs-debug */
 int journal_enable_debug = -1;
 #endif
 
@@ -96,7 +15448,7 @@ static void usage(e2fsck_t ctx)
 }
 #endif
 
-static void show_stats(e2fsck_t ctx)
+static void show_stats(e2fsck_t ctx)
 {
         ext2_filsys fs = ctx->fs;
         int inodes, inodes_used, blocks, blocks_used;
@@ -116,7 +15468,7 @@ static void show_stats(e2fsck_t	ctx)
 
         frag_percent = (10000 * ctx->fs_fragmented) / inodes_used;
         frag_percent = (frag_percent + 5) / 10;
-        
+
         if (!verbose) {
                 printf("%s: %d/%d files (%0d.%d%% non-contiguous), %d/%d blocks\n",
                        ctx->device_name, inodes_used, inodes,
@@ -167,8 +15519,8 @@ static void show_stats(e2fsck_t	ctx)
 
 static void check_mount(e2fsck_t ctx)
 {
-        errcode_t       retval;
-        int             cont;
+        errcode_t       retval;
+        int             cont;
 
         retval = ext2fs_check_if_mounted(ctx->filesystem_name,
                                          &ctx->mount_flags);
@@ -209,15 +15561,15 @@ static void check_mount(e2fsck_t ctx)
 
 static int is_on_batt(void)
 {
-        FILE    *f;
-        DIR     *d;
-        char    tmp[80], tmp2[80], fname[80];
-        unsigned int    acflag;
-        struct dirent*  de;
+        FILE    *f;
+        DIR     *d;
+        char    tmp[80], tmp2[80], fname[80];
+        unsigned int    acflag;
+        struct dirent*  de;
 
         f = fopen("/proc/apm", "r");
         if (f) {
-                if (fscanf(f, "%s %s %s %x", tmp, tmp, tmp, &acflag) != 4) 
+                if (fscanf(f, "%s %s %s %x", tmp, tmp, tmp, &acflag) != 4)
                         acflag = 1;
                 fclose(f);
                 return (acflag != 1);
@@ -227,7 +15579,7 @@ static int is_on_batt(void)
                 while ((de=readdir(d)) != NULL) {
                         if (!strncmp(".", de->d_name, 1))
                                 continue;
-                        snprintf(fname, 80, "/proc/acpi/ac_adapter/%s/state", 
+                        snprintf(fname, 80, "/proc/acpi/ac_adapter/%s/state",
                                  de->d_name);
                         f = fopen(fname, "r");
                         if (!f)
@@ -258,11 +15610,11 @@ static void check_if_skip(e2fsck_t ctx)
         long next_check;
         int batt = is_on_batt();
         time_t now = time(0);
-        
+
         if ((ctx->options & E2F_OPT_FORCE) || bad_blocks_file ||
             cflag || swapfs)
                 return;
-        
+
         if ((fs->super->s_state & EXT2_ERROR_FS) ||
             !ext2fs_test_valid(fs))
                 reason = _(" contains a file system with errors");
@@ -273,15 +15625,15 @@ static void check_if_skip(e2fsck_t ctx)
                   (unsigned) fs->super->s_max_mnt_count)) {
                 reason = _(" has been mounted %u times without being checked");
                 reason_arg = fs->super->s_mnt_count;
-                if (batt && (fs->super->s_mnt_count < 
+                if (batt && (fs->super->s_mnt_count <
                              (unsigned) fs->super->s_max_mnt_count*2))
                         reason = 0;
         } else if (fs->super->s_checkinterval &&
-                   ((now - fs->super->s_lastcheck) >= 
+                   ((now - fs->super->s_lastcheck) >=
                     fs->super->s_checkinterval)) {
                 reason = _(" has gone %u days without being checked");
                 reason_arg = (now - fs->super->s_lastcheck)/(3600*24);
-                if (batt && ((now - fs->super->s_lastcheck) < 
+                if (batt && ((now - fs->super->s_lastcheck) <
                              fs->super->s_checkinterval*2))
                         reason = 0;
         }
@@ -299,7 +15651,7 @@ static void check_if_skip(e2fsck_t ctx)
         next_check = 100000;
         if (fs->super->s_max_mnt_count > 0) {
                 next_check = fs->super->s_max_mnt_count - fs->super->s_mnt_count;
-                if (next_check <= 0) 
+                if (next_check <= 0)
                         next_check = 1;
         }
         if (fs->super->s_checkinterval &&
@@ -322,10 +15674,10 @@ static void check_if_skip(e2fsck_t ctx)
  * For completion notice
  */
 struct percent_tbl {
-        int     max_pass;
-        int     table[32];
+        int     max_pass;
+        int     table[32];
 };
-struct percent_tbl e2fsck_tbl = {
+static struct percent_tbl e2fsck_tbl = {
         5, { 0, 70, 90, 92,  95, 100 }
 };
 static char bar[128], spaces[128];
@@ -333,8 +15685,8 @@ static char bar[128], spaces[128];
 static float calc_percent(struct percent_tbl *tbl, int pass, int curr,
                           int max)
 {
-        float   percent;
-        
+        float   percent;
+
         if (pass <= 0)
                 return 0.0;
         if (pass > tbl->max_pass || max == 0)
@@ -348,7 +15700,7 @@ extern void e2fsck_clear_progbar(e2fsck_t ctx)
 {
         if (!(ctx->flags & E2F_FLAG_PROG_BAR))
                 return;
-        
+
         printf("%s%s\r%s", ctx->start_meta, spaces + (sizeof(spaces) - 80),
                ctx->stop_meta);
         fflush(stdout);
@@ -359,9 +15711,9 @@ int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent,
                            unsigned int dpynum)
 {
         static const char spinner[] = "\\|/-";
-        int     i;
-        unsigned int    tick;
-        struct timeval  tv;
+        int     i;
+        unsigned int    tick;
+        struct timeval  tv;
         int dpywidth;
         int fixed_percent;
 
@@ -371,7 +15723,7 @@ int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent,
         /*
          * Calculate the new progress position.  If the
          * percentage hasn't changed, then we skip out right
-         * away. 
+         * away.
          */
         fixed_percent = (int) ((10 * percent) + 0.5);
         if (ctx->progress_last_percent == fixed_percent)
@@ -416,7 +15768,7 @@ int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent,
         else
                 fputs(" \r", stdout);
         fputs(ctx->stop_meta, stdout);
-        
+
         if (fixed_percent == 1000)
                 e2fsck_clear_progbar(ctx);
         fflush(stdout);
@@ -432,7 +15784,7 @@ static int e2fsck_update_progress(e2fsck_t ctx, int pass,
 
         if (pass == 0)
                 return 0;
-        
+
         if (ctx->progress_fd) {
                 sprintf(buf, "%d %lu %lu\n", pass, cur, max);
                 write(ctx->progress_fd, buf, strlen(buf));
@@ -448,7 +15800,7 @@ static int e2fsck_update_progress(e2fsck_t ctx, int pass,
 
 static void reserve_stdio_fds(void)
 {
-        int     fd;
+        int     fd;
 
         while (1) {
                 fd = open("/dev/null", O_RDWR);
@@ -464,7 +15816,6 @@ static void reserve_stdio_fds(void)
         close(fd);
 }
 
-#ifdef HAVE_SIGNAL_H
 static void signal_progress_on(int sig EXT2FS_ATTR((unused)))
 {
         e2fsck_t ctx = e2fsck_global_ctx;
@@ -496,13 +15847,12 @@ static void signal_cancel(int sig EXT2FS_ATTR((unused)))
 
         ctx->flags |= E2F_FLAG_CANCEL;
 }
-#endif
 
 static void parse_extended_opts(e2fsck_t ctx, const char *opts)
 {
-        char    *buf, *token, *next, *p, *arg;
-        int     ea_ver;
-        int     extended_usage = 0;
+        char    *buf, *token, *next, *p, *arg;
+        int     ea_ver;
+        int     extended_usage = 0;
 
         buf = string_copy(ctx, opts, 0);
         for (token = buf; token && *token; token = next) {
@@ -511,7 +15861,7 @@ static void parse_extended_opts(e2fsck_t ctx, const char *opts)
                 if (p) {
                         *p = 0;
                         next = p+1;
-                } 
+                }
                 arg = strchr(token, '=');
                 if (arg) {
                         *arg = 0;
@@ -542,22 +15892,20 @@ static void parse_extended_opts(e2fsck_t ctx, const char *opts)
                         "\tea_ver=<ea_version (1 or 2)\n\n"));
                 exit(1);
         }
-}       
+}
 
 
 static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
 {
-        int             flush = 0;
-        int             c, fd;
+        int             flush = 0;
+        int             c, fd;
 #ifdef MTRACE
-        extern void     *mallwatch;
+        extern void     *mallwatch;
 #endif
-        e2fsck_t        ctx;
-        errcode_t       retval;
-#ifdef HAVE_SIGNAL_H
-        struct sigaction        sa;
-#endif
-        char            *extended_opts = 0;
+        e2fsck_t        ctx;
+        errcode_t       retval;
+        struct sigaction        sa;
+        char            *extended_opts = 0;
 
         retval = e2fsck_allocate_context(&ctx);
         if (retval)
@@ -576,7 +15924,7 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
         memset(bar, '=', sizeof(bar)-1);
         memset(spaces, ' ', sizeof(spaces)-1);
         blkid_get_cache(&ctx->blkid, NULL);
-        
+
         if (argc && *argv)
                 ctx->program_name = *argv;
         else
@@ -610,7 +15958,7 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
                 case 'a':
                         if (ctx->options & (E2F_OPT_YES|E2F_OPT_NO)) {
                         conflict_opt:
-                                fatal_error(ctx, 
+                                fatal_error(ctx,
         _("Only one the options -p/-a, -n or -y may be specified."));
                         }
                         ctx->options |= E2F_OPT_PREEN;
@@ -716,17 +16064,17 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
             !cflag && !swapfs && !(ctx->options & E2F_OPT_COMPRESS_DIRS))
                 ctx->options |= E2F_OPT_READONLY;
         ctx->io_options = strchr(argv[optind], '?');
-        if (ctx->io_options) 
+        if (ctx->io_options)
                 *ctx->io_options++ = 0;
         ctx->filesystem_name = blkid_get_devname(ctx->blkid, argv[optind], 0);
         if (!ctx->filesystem_name) {
-                com_err(ctx->program_name, 0, _("Unable to resolve '%s'"), 
+                com_err(ctx->program_name, 0, _("Unable to resolve '%s'"),
                         argv[optind]);
                 fatal_error(ctx, 0);
         }
         if (extended_opts)
                 parse_extended_opts(ctx, extended_opts);
-        
+
         if (flush) {
                 fd = open(ctx->filesystem_name, O_RDONLY, 0);
                 if (fd < 0) {
@@ -757,7 +16105,6 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
                                   "not be both used at the same time.\n"));
                 exit(FSCK_USAGE);
         }
-#ifdef HAVE_SIGNAL_H
         /*
          * Set up signal action
          */
@@ -773,7 +16120,6 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
         sigaction(SIGUSR1, &sa, 0);
         sa.sa_handler = signal_progress_off;
         sigaction(SIGUSR2, &sa, 0);
-#endif
 
         /* Update our PATH to include /sbin if we need to run badblocks  */
         if (cflag) {
@@ -801,20 +16147,20 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
 
 static const char *my_ver_string = E2FSPROGS_VERSION;
 static const char *my_ver_date = E2FSPROGS_DATE;
-                                        
+
 int e2fsck_main (int argc, char *argv[])
 {
-        errcode_t       retval = 0;
-        int             exit_value = FSCK_OK;
-        ext2_filsys     fs = 0;
-        io_manager      io_ptr;
+        errcode_t       retval = 0;
+        int             exit_value = FSCK_OK;
+        ext2_filsys     fs = 0;
+        io_manager      io_ptr;
         struct ext2_super_block *sb;
-        const char      *lib_ver_date;
-        int             my_ver, lib_ver;
-        e2fsck_t        ctx;
+        const char      *lib_ver_date;
+        int             my_ver, lib_ver;
+        e2fsck_t        ctx;
         struct problem_context pctx;
         int flags, run_result;
-        
+
         clear_problem_context(&pctx);
 #ifdef MTRACE
         mtrace();
@@ -835,7 +16181,7 @@ int e2fsck_main (int argc, char *argv[])
                         "out of date!\n"));
                 show_version_only++;
         }
-        
+
         retval = PRS(argc, argv, &ctx);
         if (retval) {
                 com_err("e2fsck", retval,
@@ -843,7 +16189,7 @@ int e2fsck_main (int argc, char *argv[])
                 exit(FSCK_ERROR);
         }
         reserve_stdio_fds();
-        
+
 #ifdef RESOURCE_TRACK
         init_resource_track(&ctx->global_rtrack);
 #endif
@@ -857,9 +16203,9 @@ int e2fsck_main (int argc, char *argv[])
                         error_message(EXT2_ET_BASE), lib_ver_date);
                 exit(FSCK_OK);
         }
-        
+
         check_mount(ctx);
-        
+
         if (!(ctx->options & E2F_OPT_PREEN) &&
             !(ctx->options & E2F_OPT_NO) &&
             !(ctx->options & E2F_OPT_YES)) {
@@ -880,22 +16226,22 @@ restart:
                 flags |= EXT2_FLAG_RW;
 
         if (ctx->superblock && ctx->blocksize) {
-                retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, 
+                retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options,
                                       flags, ctx->superblock, ctx->blocksize,
                                       io_ptr, &fs);
         } else if (ctx->superblock) {
                 int blocksize;
                 for (blocksize = EXT2_MIN_BLOCK_SIZE;
                      blocksize <= EXT2_MAX_BLOCK_SIZE; blocksize *= 2) {
-                        retval = ext2fs_open2(ctx->filesystem_name, 
+                        retval = ext2fs_open2(ctx->filesystem_name,
                                               ctx->io_options, flags,
                                               ctx->superblock, blocksize,
                                               io_ptr, &fs);
                         if (!retval)
                                 break;
                 }
-        } else 
-                retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, 
+        } else
+                retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options,
                                       flags, 0, 0, io_ptr, &fs);
         if (!ctx->superblock && !(ctx->options & E2F_OPT_PREEN) &&
             !(ctx->flags & E2F_FLAG_SB_SPECIFIED) &&
@@ -1161,13 +16507,13 @@ restart:
         }
 
         e2fsck_write_bitmaps(ctx);
-        
+
         ext2fs_close(fs);
         ctx->fs = NULL;
         free(ctx->filesystem_name);
         free(ctx->journal_name);
         e2fsck_free_context(ctx);
-        
+
 #ifdef RESOURCE_TRACK
         if (ctx->options & E2F_OPT_TIME)
                 print_resource_track(NULL, &ctx->global_rtrack);
diff --git a/e2fsprogs/e2fsck/badblocks.c b/e2fsprogs/e2fsck/badblocks.c
deleted file mode 100644
index 1ab76a091..000000000
--- a/e2fsprogs/e2fsck/badblocks.c
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * badblocks.c --- replace/append bad blocks to the bad block inode
- * 
- * Copyright (C) 1993, 1994 Theodore Ts'o.  This file may be
- * redistributed under the terms of the GNU Public License.
- */
-
-#include <time.h>
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#endif
-
-#include "e2fsck.h"
-
-static int check_bb_inode_blocks(ext2_filsys fs, blk_t *block_nr, int blockcnt,
-                                 void *priv_data);
-
-
-static void invalid_block(ext2_filsys fs EXT2FS_ATTR((unused)), blk_t blk)
-{
-        printf(_("Bad block %u out of range; ignored.\n"), blk);
-        return;
-}
-
-void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
-                          int replace_bad_blocks)
-{
-        ext2_filsys fs = ctx->fs;
-        errcode_t       retval;
-        badblocks_list  bb_list = 0;
-        FILE            *f;
-        char            buf[1024];
-
-        e2fsck_read_bitmaps(ctx);
-
-        /*
-         * Make sure the bad block inode is sane.  If there are any
-         * illegal blocks, clear them.
-         */
-        retval = ext2fs_block_iterate(fs, EXT2_BAD_INO, 0, 0,
-                                      check_bb_inode_blocks, 0);
-        if (retval) {
-                com_err("ext2fs_block_iterate", retval,
-                        _("while sanity checking the bad blocks inode"));
-                goto fatal;
-        }
-        
-        /*
-         * If we're appending to the bad blocks inode, read in the
-         * current bad blocks.
-         */
-        if (!replace_bad_blocks) {
-                retval = ext2fs_read_bb_inode(fs, &bb_list);
-                if (retval) {
-                        com_err("ext2fs_read_bb_inode", retval,
-                                _("while reading the bad blocks inode"));
-                        goto fatal;
-                }
-        }
-        
-        /*
-         * Now read in the bad blocks from the file; if
-         * bad_blocks_file is null, then try to run the badblocks
-         * command.
-         */
-        if (bad_blocks_file) {
-                f = fopen(bad_blocks_file, "r");
-                if (!f) {
-                        com_err("read_bad_blocks_file", errno,
-                                _("while trying to open %s"), bad_blocks_file);
-                        goto fatal;
-                }
-        } else {
-                sprintf(buf, "badblocks -b %d %s%s%s %d", fs->blocksize,
-                        (ctx->options & E2F_OPT_PREEN) ? "" : "-s ",
-                        (ctx->options & E2F_OPT_WRITECHECK) ? "-n " : "",
-                        fs->device_name, fs->super->s_blocks_count);
-                f = popen(buf, "r");
-                if (!f) {
-                        com_err("read_bad_blocks_file", errno,
-                                _("while trying popen '%s'"), buf);
-                        goto fatal;
-                }
-        }
-        retval = ext2fs_read_bb_FILE(fs, f, &bb_list, invalid_block);
-        if (bad_blocks_file) 
-                fclose(f);
-        else
-                pclose(f);
-        if (retval) {
-                com_err("ext2fs_read_bb_FILE", retval,
-                        _("while reading in list of bad blocks from file"));
-                goto fatal;
-        }
-        
-        /*
-         * Finally, update the bad blocks from the bad_block_map
-         */
-        retval = ext2fs_update_bb_inode(fs, bb_list);
-        if (retval) {
-                com_err("ext2fs_update_bb_inode", retval,
-                        _("while updating bad block inode"));
-                goto fatal;
-        }
-
-        ext2fs_badblocks_list_free(bb_list);
-        return;
-        
-fatal:
-        ctx->flags |= E2F_FLAG_ABORT;
-        return;
-        
-}
-
-static int check_bb_inode_blocks(ext2_filsys fs, 
-                                 blk_t *block_nr, 
-                                 int blockcnt EXT2FS_ATTR((unused)),
-                                 void *priv_data EXT2FS_ATTR((unused)))
-{
-        if (!*block_nr)
-                return 0;
-
-        /*
-         * If the block number is outrageous, clear it and ignore it.
-         */
-        if (*block_nr >= fs->super->s_blocks_count ||
-            *block_nr < fs->super->s_first_data_block) {
-                printf(_("Warning illegal block %u found in bad block inode.  Cleared.\n"), *block_nr);
-                *block_nr = 0;
-                return BLOCK_CHANGED;
-        }
-
-        return 0;
-}
-
diff --git a/e2fsprogs/e2fsck/dict.c b/e2fsprogs/e2fsck/dict.c
deleted file mode 100644
index b0809a76d..000000000
--- a/e2fsprogs/e2fsck/dict.c
+++ /dev/null
@@ -1,1529 +0,0 @@
-/*
- * Dictionary Abstract Data Type
- * Copyright (C) 1997 Kaz Kylheku <kaz@ashi.footprints.net>
- *
- * Free Software License:
- *
- * All rights are reserved by the author, with the following exceptions:
- * Permission is granted to freely reproduce and distribute this software,
- * possibly in exchange for a fee, provided that this copyright notice appears
- * intact. Permission is also granted to adapt this software to produce
- * derivative works, as long as the modified versions carry this copyright
- * notice and additional notices stating that the work has been modified.
- * This source code may be translated into executable form and incorporated
- * into proprietary software; there is no requirement for such software to
- * contain a copyright notice related to this source.
- *
- * $Id: dict.c,v 1.40.2.7 2000/11/13 01:36:44 kaz Exp $
- * $Name: kazlib_1_20 $
- */
-
-#ifdef __GNUC__
-#define EXT2FS_ATTR(x) __attribute__(x)
-#else
-#define EXT2FS_ATTR(x)
-#endif
-
-#include <stdlib.h>
-#include <stddef.h>
-#include <assert.h>
-#define DICT_IMPLEMENTATION
-#include "dict.h"
-
-#ifndef NDEBUG
-# define NDEBUG
-#endif
-
-/*
- * These macros provide short convenient names for structure members,
- * which are embellished with dict_ prefixes so that they are
- * properly confined to the documented namespace. It's legal for a 
- * program which uses dict to define, for instance, a macro called ``parent''.
- * Such a macro would interfere with the dnode_t struct definition.
- * In general, highly portable and reusable C modules which expose their
- * structures need to confine structure member names to well-defined spaces.
- * The resulting identifiers aren't necessarily convenient to use, nor
- * readable, in the implementation, however!
- */
-
-#define left dict_left
-#define right dict_right
-#define parent dict_parent
-#define color dict_color
-#define key dict_key
-#define data dict_data
-
-#define nilnode dict_nilnode
-#define nodecount dict_nodecount
-#define maxcount dict_maxcount
-#define compare dict_compare
-#define allocnode dict_allocnode
-#define freenode dict_freenode
-#define context dict_context
-#define dupes dict_dupes
-
-#define dictptr dict_dictptr
-
-#define dict_root(D) ((D)->nilnode.left)
-#define dict_nil(D) (&(D)->nilnode)
-#define DICT_DEPTH_MAX 64
-
-static dnode_t *dnode_alloc(void *context);
-static void dnode_free(dnode_t *node, void *context);
-
-/*
- * Perform a ``left rotation'' adjustment on the tree.  The given node P and
- * its right child C are rearranged so that the P instead becomes the left
- * child of C.   The left subtree of C is inherited as the new right subtree
- * for P.  The ordering of the keys within the tree is thus preserved.
- */
-
-static void rotate_left(dnode_t *upper)
-{
-    dnode_t *lower, *lowleft, *upparent;
-
-    lower = upper->right;
-    upper->right = lowleft = lower->left;
-    lowleft->parent = upper;
-
-    lower->parent = upparent = upper->parent;
-
-    /* don't need to check for root node here because root->parent is
-       the sentinel nil node, and root->parent->left points back to root */
-
-    if (upper == upparent->left) {
-        upparent->left = lower;
-    } else {
-        assert (upper == upparent->right);
-        upparent->right = lower;
-    }
-
-    lower->left = upper;
-    upper->parent = lower;
-}
-
-/*
- * This operation is the ``mirror'' image of rotate_left. It is
- * the same procedure, but with left and right interchanged.
- */
-
-static void rotate_right(dnode_t *upper)
-{
-    dnode_t *lower, *lowright, *upparent;
-
-    lower = upper->left;
-    upper->left = lowright = lower->right;
-    lowright->parent = upper;
-
-    lower->parent = upparent = upper->parent;
-
-    if (upper == upparent->right) {
-        upparent->right = lower;
-    } else {
-        assert (upper == upparent->left);
-        upparent->left = lower;
-    }
-
-    lower->right = upper;
-    upper->parent = lower;
-}
-
-/*
- * Do a postorder traversal of the tree rooted at the specified
- * node and free everything under it.  Used by dict_free().
- */
-
-static void free_nodes(dict_t *dict, dnode_t *node, dnode_t *nil)
-{
-    if (node == nil)
-        return;
-    free_nodes(dict, node->left, nil);
-    free_nodes(dict, node->right, nil);
-    dict->freenode(node, dict->context);
-}
-
-/*
- * This procedure performs a verification that the given subtree is a binary
- * search tree. It performs an inorder traversal of the tree using the
- * dict_next() successor function, verifying that the key of each node is
- * strictly lower than that of its successor, if duplicates are not allowed,
- * or lower or equal if duplicates are allowed.  This function is used for
- * debugging purposes. 
- */
-#ifndef NDEBUG
-static int verify_bintree(dict_t *dict)
-{
-    dnode_t *first, *next;
-
-    first = dict_first(dict);
-
-    if (dict->dupes) {
-        while (first && (next = dict_next(dict, first))) {
-            if (dict->compare(first->key, next->key) > 0)
-                return 0;
-            first = next;
-        }
-    } else {
-        while (first && (next = dict_next(dict, first))) {
-            if (dict->compare(first->key, next->key) >= 0)
-                return 0;
-            first = next;
-        }
-    }
-    return 1;
-}
-
-/*
- * This function recursively verifies that the given binary subtree satisfies
- * three of the red black properties. It checks that every red node has only
- * black children. It makes sure that each node is either red or black. And it
- * checks that every path has the same count of black nodes from root to leaf.
- * It returns the blackheight of the given subtree; this allows blackheights to
- * be computed recursively and compared for left and right siblings for
- * mismatches. It does not check for every nil node being black, because there
- * is only one sentinel nil node. The return value of this function is the
- * black height of the subtree rooted at the node ``root'', or zero if the
- * subtree is not red-black.
- */
-
-static unsigned int verify_redblack(dnode_t *nil, dnode_t *root)
-{
-    unsigned height_left, height_right;
-
-    if (root != nil) {
-        height_left = verify_redblack(nil, root->left);
-        height_right = verify_redblack(nil, root->right);
-        if (height_left == 0 || height_right == 0)
-            return 0;
-        if (height_left != height_right)
-            return 0;
-        if (root->color == dnode_red) {
-            if (root->left->color != dnode_black)
-                return 0;
-            if (root->right->color != dnode_black)
-                return 0;
-            return height_left;
-        }
-        if (root->color != dnode_black)
-            return 0;
-        return height_left + 1;
-    } 
-    return 1;
-}
-
-/*
- * Compute the actual count of nodes by traversing the tree and
- * return it. This could be compared against the stored count to
- * detect a mismatch.
- */
-
-static dictcount_t verify_node_count(dnode_t *nil, dnode_t *root)
-{
-    if (root == nil)
-        return 0;
-    else
-        return 1 + verify_node_count(nil, root->left)
-            + verify_node_count(nil, root->right);
-}
-#endif
-
-/*
- * Verify that the tree contains the given node. This is done by
- * traversing all of the nodes and comparing their pointers to the
- * given pointer. Returns 1 if the node is found, otherwise
- * returns zero. It is intended for debugging purposes.
- */
-
-static int verify_dict_has_node(dnode_t *nil, dnode_t *root, dnode_t *node)
-{
-    if (root != nil) {
-        return root == node
-                || verify_dict_has_node(nil, root->left, node)
-                || verify_dict_has_node(nil, root->right, node);
-    }
-    return 0;
-}
-
-
-#ifdef E2FSCK_NOTUSED
-/*
- * Dynamically allocate and initialize a dictionary object.
- */
-
-dict_t *dict_create(dictcount_t maxcount, dict_comp_t comp)
-{
-    dict_t *new = malloc(sizeof *new);
-
-    if (new) {
-        new->compare = comp;
-        new->allocnode = dnode_alloc;
-        new->freenode = dnode_free;
-        new->context = NULL;
-        new->nodecount = 0;
-        new->maxcount = maxcount;
-        new->nilnode.left = &new->nilnode;
-        new->nilnode.right = &new->nilnode;
-        new->nilnode.parent = &new->nilnode;
-        new->nilnode.color = dnode_black;
-        new->dupes = 0;
-    }
-    return new;
-}
-#endif /* E2FSCK_NOTUSED */
-
-/*
- * Select a different set of node allocator routines.
- */
-
-void dict_set_allocator(dict_t *dict, dnode_alloc_t al,
-        dnode_free_t fr, void *context)
-{
-    assert (dict_count(dict) == 0);
-    assert ((al == NULL && fr == NULL) || (al != NULL && fr != NULL));
-
-    dict->allocnode = al ? al : dnode_alloc;
-    dict->freenode = fr ? fr : dnode_free;
-    dict->context = context;
-}
-
-#ifdef E2FSCK_NOTUSED
-/*
- * Free a dynamically allocated dictionary object. Removing the nodes
- * from the tree before deleting it is required.
- */
-
-void dict_destroy(dict_t *dict)
-{
-    assert (dict_isempty(dict));
-    free(dict);
-}
-#endif
-
-/*
- * Free all the nodes in the dictionary by using the dictionary's
- * installed free routine. The dictionary is emptied.
- */
-
-void dict_free_nodes(dict_t *dict)
-{
-    dnode_t *nil = dict_nil(dict), *root = dict_root(dict);
-    free_nodes(dict, root, nil);
-    dict->nodecount = 0;
-    dict->nilnode.left = &dict->nilnode;
-    dict->nilnode.right = &dict->nilnode;
-}
-
-#ifdef E2FSCK_NOTUSED
-/*
- * Obsolescent function, equivalent to dict_free_nodes
- */
-void dict_free(dict_t *dict)
-{
-#ifdef KAZLIB_OBSOLESCENT_DEBUG
-    assert ("call to obsolescent function dict_free()" && 0);
-#endif
-    dict_free_nodes(dict);
-}
-#endif
-
-/*
- * Initialize a user-supplied dictionary object.
- */
-
-dict_t *dict_init(dict_t *dict, dictcount_t maxcount, dict_comp_t comp)
-{
-    dict->compare = comp;
-    dict->allocnode = dnode_alloc;
-    dict->freenode = dnode_free;
-    dict->context = NULL;
-    dict->nodecount = 0;
-    dict->maxcount = maxcount;
-    dict->nilnode.left = &dict->nilnode;
-    dict->nilnode.right = &dict->nilnode;
-    dict->nilnode.parent = &dict->nilnode;
-    dict->nilnode.color = dnode_black;
-    dict->dupes = 0;
-    return dict;
-}
-
-#ifdef E2FSCK_NOTUSED
-/* 
- * Initialize a dictionary in the likeness of another dictionary
- */
-
-void dict_init_like(dict_t *dict, const dict_t *template)
-{
-    dict->compare = template->compare;
-    dict->allocnode = template->allocnode;
-    dict->freenode = template->freenode;
-    dict->context = template->context;
-    dict->nodecount = 0;
-    dict->maxcount = template->maxcount;
-    dict->nilnode.left = &dict->nilnode;
-    dict->nilnode.right = &dict->nilnode;
-    dict->nilnode.parent = &dict->nilnode;
-    dict->nilnode.color = dnode_black;
-    dict->dupes = template->dupes;
-
-    assert (dict_similar(dict, template));
-}
-
-/*
- * Remove all nodes from the dictionary (without freeing them in any way).
- */
-
-static void dict_clear(dict_t *dict)
-{
-    dict->nodecount = 0;
-    dict->nilnode.left = &dict->nilnode;
-    dict->nilnode.right = &dict->nilnode;
-    dict->nilnode.parent = &dict->nilnode;
-    assert (dict->nilnode.color == dnode_black);
-}
-
-
-/*
- * Verify the integrity of the dictionary structure.  This is provided for
- * debugging purposes, and should be placed in assert statements.   Just because
- * this function succeeds doesn't mean that the tree is not corrupt. Certain
- * corruptions in the tree may simply cause undefined behavior.
- */ 
-
-int dict_verify(dict_t *dict)
-{
-#ifndef NDEBUG
-    dnode_t *nil = dict_nil(dict), *root = dict_root(dict);
-
-    /* check that the sentinel node and root node are black */
-    if (root->color != dnode_black)
-        return 0;
-    if (nil->color != dnode_black)
-        return 0;
-    if (nil->right != nil)
-        return 0;
-    /* nil->left is the root node; check that its parent pointer is nil */
-    if (nil->left->parent != nil)
-        return 0;
-    /* perform a weak test that the tree is a binary search tree */
-    if (!verify_bintree(dict))
-        return 0;
-    /* verify that the tree is a red-black tree */
-    if (!verify_redblack(nil, root))
-        return 0;
-    if (verify_node_count(nil, root) != dict_count(dict))
-        return 0;
-#endif
-    return 1;
-}
-
-/*
- * Determine whether two dictionaries are similar: have the same comparison and
- * allocator functions, and same status as to whether duplicates are allowed.
- */
-
-int dict_similar(const dict_t *left, const dict_t *right)
-{
-    if (left->compare != right->compare)
-        return 0;
-
-    if (left->allocnode != right->allocnode)
-        return 0;
-
-    if (left->freenode != right->freenode)
-        return 0;
-
-    if (left->context != right->context)
-        return 0;
-
-    if (left->dupes != right->dupes)
-        return 0;
-
-    return 1;
-}
-#endif /* E2FSCK_NOTUSED */
-
-/*
- * Locate a node in the dictionary having the given key.
- * If the node is not found, a null a pointer is returned (rather than 
- * a pointer that dictionary's nil sentinel node), otherwise a pointer to the
- * located node is returned.
- */
-
-dnode_t *dict_lookup(dict_t *dict, const void *key)
-{
-    dnode_t *root = dict_root(dict);
-    dnode_t *nil = dict_nil(dict);
-    dnode_t *saved;
-    int result;
-
-    /* simple binary search adapted for trees that contain duplicate keys */
-
-    while (root != nil) {
-        result = dict->compare(key, root->key);
-        if (result < 0)
-            root = root->left;
-        else if (result > 0)
-            root = root->right;
-        else {
-            if (!dict->dupes) { /* no duplicates, return match          */
-                return root;
-            } else {            /* could be dupes, find leftmost one    */
-                do {
-                    saved = root;
-                    root = root->left;
-                    while (root != nil && dict->compare(key, root->key))
-                        root = root->right;
-                } while (root != nil);
-                return saved;
-            }
-        }
-    }
-
-    return NULL;
-}
-
-#ifdef E2FSCK_NOTUSED
-/*
- * Look for the node corresponding to the lowest key that is equal to or
- * greater than the given key.  If there is no such node, return null.
- */
-
-dnode_t *dict_lower_bound(dict_t *dict, const void *key)
-{
-    dnode_t *root = dict_root(dict);
-    dnode_t *nil = dict_nil(dict);
-    dnode_t *tentative = 0;
-
-    while (root != nil) {
-        int result = dict->compare(key, root->key);
-
-        if (result > 0) {
-            root = root->right;
-        } else if (result < 0) {
-            tentative = root;
-            root = root->left;
-        } else {
-            if (!dict->dupes) {
-                return root;
-            } else {
-                tentative = root;
-                root = root->left;
-            }
-        } 
-    }
-    
-    return tentative;
-}
-
-/*
- * Look for the node corresponding to the greatest key that is equal to or
- * lower than the given key.  If there is no such node, return null.
- */
-
-dnode_t *dict_upper_bound(dict_t *dict, const void *key)
-{
-    dnode_t *root = dict_root(dict);
-    dnode_t *nil = dict_nil(dict);
-    dnode_t *tentative = 0;
-
-    while (root != nil) {
-        int result = dict->compare(key, root->key);
-
-        if (result < 0) {
-            root = root->left;
-        } else if (result > 0) {
-            tentative = root;
-            root = root->right;
-        } else {
-            if (!dict->dupes) {
-                return root;
-            } else {
-                tentative = root;
-                root = root->right;
-            }
-        } 
-    }
-    
-    return tentative;
-}
-#endif
-
-/*
- * Insert a node into the dictionary. The node should have been
- * initialized with a data field. All other fields are ignored.
- * The behavior is undefined if the user attempts to insert into
- * a dictionary that is already full (for which the dict_isfull()
- * function returns true).
- */
-
-void dict_insert(dict_t *dict, dnode_t *node, const void *key)
-{
-    dnode_t *where = dict_root(dict), *nil = dict_nil(dict);
-    dnode_t *parent = nil, *uncle, *grandpa;
-    int result = -1;
-
-    node->key = key;
-
-#ifndef NDEBUG
-    assert (!dict_isfull(dict));
-    assert (!dict_contains(dict, node));
-    assert (!dnode_is_in_a_dict(node));
-#endif
-
-    /* basic binary tree insert */
-
-    while (where != nil) {
-        parent = where;
-        result = dict->compare(key, where->key);
-        /* trap attempts at duplicate key insertion unless it's explicitly allowed */
-        assert (dict->dupes || result != 0);
-        if (result < 0)
-            where = where->left;
-        else
-            where = where->right;
-    }
-
-    assert (where == nil);
-
-    if (result < 0)
-        parent->left = node;
-    else
-        parent->right = node;
-
-    node->parent = parent;
-    node->left = nil;
-    node->right = nil;
-
-    dict->nodecount++;
-
-    /* red black adjustments */
-
-    node->color = dnode_red;
-
-    while (parent->color == dnode_red) {
-        grandpa = parent->parent;
-        if (parent == grandpa->left) {
-            uncle = grandpa->right;
-            if (uncle->color == dnode_red) {    /* red parent, red uncle */
-                parent->color = dnode_black;
-                uncle->color = dnode_black;
-                grandpa->color = dnode_red;
-                node = grandpa;
-                parent = grandpa->parent;
-            } else {                            /* red parent, black uncle */
-                if (node == parent->right) {
-                    rotate_left(parent);
-                    parent = node;
-                    assert (grandpa == parent->parent);
-                    /* rotation between parent and child preserves grandpa */
-                }
-                parent->color = dnode_black;
-                grandpa->color = dnode_red;
-                rotate_right(grandpa);
-                break;
-            }
-        } else {        /* symmetric cases: parent == parent->parent->right */
-            uncle = grandpa->left;
-            if (uncle->color == dnode_red) {
-                parent->color = dnode_black;
-                uncle->color = dnode_black;
-                grandpa->color = dnode_red;
-                node = grandpa;
-                parent = grandpa->parent;
-            } else {
-                if (node == parent->left) {
-                    rotate_right(parent);
-                    parent = node;
-                    assert (grandpa == parent->parent);
-                }
-                parent->color = dnode_black;
-                grandpa->color = dnode_red;
-                rotate_left(grandpa);
-                break;
-            }
-        }
-    }
-
-    dict_root(dict)->color = dnode_black;
-
-#ifdef E2FSCK_NOTUSED
-    assert (dict_verify(dict));
-#endif
-}
-
-#ifdef E2FSCK_NOTUSED
-/*
- * Delete the given node from the dictionary. If the given node does not belong
- * to the given dictionary, undefined behavior results.  A pointer to the
- * deleted node is returned.
- */
-
-dnode_t *dict_delete(dict_t *dict, dnode_t *delete)
-{
-    dnode_t *nil = dict_nil(dict), *child, *delparent = delete->parent;
-
-    /* basic deletion */
-
-    assert (!dict_isempty(dict));
-    assert (dict_contains(dict, delete));
-
-    /*
-     * If the node being deleted has two children, then we replace it with its
-     * successor (i.e. the leftmost node in the right subtree.) By doing this,
-     * we avoid the traditional algorithm under which the successor's key and
-     * value *only* move to the deleted node and the successor is spliced out
-     * from the tree. We cannot use this approach because the user may hold
-     * pointers to the successor, or nodes may be inextricably tied to some
-     * other structures by way of embedding, etc. So we must splice out the
-     * node we are given, not some other node, and must not move contents from
-     * one node to another behind the user's back.
-     */
-
-    if (delete->left != nil && delete->right != nil) {
-        dnode_t *next = dict_next(dict, delete);
-        dnode_t *nextparent = next->parent;
-        dnode_color_t nextcolor = next->color;
-
-        assert (next != nil);
-        assert (next->parent != nil);
-        assert (next->left == nil);
-
-        /*
-         * First, splice out the successor from the tree completely, by
-         * moving up its right child into its place.
-         */
-
-        child = next->right;
-        child->parent = nextparent;
-
-        if (nextparent->left == next) {
-            nextparent->left = child;
-        } else {
-            assert (nextparent->right == next);
-            nextparent->right = child;
-        }
-
-        /*
-         * Now that the successor has been extricated from the tree, install it
-         * in place of the node that we want deleted.
-         */
-
-        next->parent = delparent;
-        next->left = delete->left;
-        next->right = delete->right;
-        next->left->parent = next;
-        next->right->parent = next;
-        next->color = delete->color;
-        delete->color = nextcolor;
-
-        if (delparent->left == delete) {
-            delparent->left = next;
-        } else {
-            assert (delparent->right == delete);
-            delparent->right = next;
-        }
-
-    } else {
-        assert (delete != nil);
-        assert (delete->left == nil || delete->right == nil);
-
-        child = (delete->left != nil) ? delete->left : delete->right;
-
-        child->parent = delparent = delete->parent;         
-
-        if (delete == delparent->left) {
-            delparent->left = child;    
-        } else {
-            assert (delete == delparent->right);
-            delparent->right = child;
-        }
-    }
-
-    delete->parent = NULL;
-    delete->right = NULL;
-    delete->left = NULL;
-
-    dict->nodecount--;
-
-    assert (verify_bintree(dict));
-
-    /* red-black adjustments */
-
-    if (delete->color == dnode_black) {
-        dnode_t *parent, *sister;
-
-        dict_root(dict)->color = dnode_red;
-
-        while (child->color == dnode_black) {
-            parent = child->parent;
-            if (child == parent->left) {
-                sister = parent->right;
-                assert (sister != nil);
-                if (sister->color == dnode_red) {
-                    sister->color = dnode_black;
-                    parent->color = dnode_red;
-                    rotate_left(parent);
-                    sister = parent->right;
-                    assert (sister != nil);
-                }
-                if (sister->left->color == dnode_black
-                        && sister->right->color == dnode_black) {
-                    sister->color = dnode_red;
-                    child = parent;
-                } else {
-                    if (sister->right->color == dnode_black) {
-                        assert (sister->left->color == dnode_red);
-                        sister->left->color = dnode_black;
-                        sister->color = dnode_red;
-                        rotate_right(sister);
-                        sister = parent->right;
-                        assert (sister != nil);
-                    }
-                    sister->color = parent->color;
-                    sister->right->color = dnode_black;
-                    parent->color = dnode_black;
-                    rotate_left(parent);
-                    break;
-                }
-            } else {    /* symmetric case: child == child->parent->right */
-                assert (child == parent->right);
-                sister = parent->left;
-                assert (sister != nil);
-                if (sister->color == dnode_red) {
-                    sister->color = dnode_black;
-                    parent->color = dnode_red;
-                    rotate_right(parent);
-                    sister = parent->left;
-                    assert (sister != nil);
-                }
-                if (sister->right->color == dnode_black
-                        && sister->left->color == dnode_black) {
-                    sister->color = dnode_red;
-                    child = parent;
-                } else {
-                    if (sister->left->color == dnode_black) {
-                        assert (sister->right->color == dnode_red);
-                        sister->right->color = dnode_black;
-                        sister->color = dnode_red;
-                        rotate_left(sister);
-                        sister = parent->left;
-                        assert (sister != nil);
-                    }
-                    sister->color = parent->color;
-                    sister->left->color = dnode_black;
-                    parent->color = dnode_black;
-                    rotate_right(parent);
-                    break;
-                }
-            }
-        }
-
-        child->color = dnode_black;
-        dict_root(dict)->color = dnode_black;
-    }
-
-#ifdef E2FSCK_NOTUSED
-    assert (dict_verify(dict));
-#endif
-
-    return delete;
-}
-#endif /* E2FSCK_NOTUSED */
-
-/*
- * Allocate a node using the dictionary's allocator routine, give it
- * the data item.
- */
-
-int dict_alloc_insert(dict_t *dict, const void *key, void *data)
-{
-    dnode_t *node = dict->allocnode(dict->context);
-
-    if (node) {
-        dnode_init(node, data);
-        dict_insert(dict, node, key);
-        return 1;
-    }
-    return 0;
-}
-
-#ifdef E2FSCK_NOTUSED
-void dict_delete_free(dict_t *dict, dnode_t *node)
-{
-    dict_delete(dict, node);
-    dict->freenode(node, dict->context);
-}
-#endif
-
-/*
- * Return the node with the lowest (leftmost) key. If the dictionary is empty
- * (that is, dict_isempty(dict) returns 1) a null pointer is returned.
- */
-
-dnode_t *dict_first(dict_t *dict)
-{
-    dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *left;
-
-    if (root != nil)
-        while ((left = root->left) != nil)
-            root = left;
-
-    return (root == nil) ? NULL : root;
-}
-
-/*
- * Return the node with the highest (rightmost) key. If the dictionary is empty
- * (that is, dict_isempty(dict) returns 1) a null pointer is returned.
- */
-
-dnode_t *dict_last(dict_t *dict)
-{
-    dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *right;
-
-    if (root != nil)
-        while ((right = root->right) != nil)
-            root = right;
-
-    return (root == nil) ? NULL : root;
-}
-
-/*
- * Return the given node's successor node---the node which has the
- * next key in the the left to right ordering. If the node has
- * no successor, a null pointer is returned rather than a pointer to
- * the nil node.
- */
-
-dnode_t *dict_next(dict_t *dict, dnode_t *curr)
-{
-    dnode_t *nil = dict_nil(dict), *parent, *left;
-
-    if (curr->right != nil) {
-        curr = curr->right;
-        while ((left = curr->left) != nil)
-            curr = left;
-        return curr;
-    }
-
-    parent = curr->parent;
-
-    while (parent != nil && curr == parent->right) {
-        curr = parent;
-        parent = curr->parent;
-    }
-
-    return (parent == nil) ? NULL : parent;
-}
-
-/*
- * Return the given node's predecessor, in the key order.
- * The nil sentinel node is returned if there is no predecessor.
- */
-
-dnode_t *dict_prev(dict_t *dict, dnode_t *curr)
-{
-    dnode_t *nil = dict_nil(dict), *parent, *right;
-
-    if (curr->left != nil) {
-        curr = curr->left;
-        while ((right = curr->right) != nil)
-            curr = right;
-        return curr;
-    }
-
-    parent = curr->parent;
-
-    while (parent != nil && curr == parent->left) {
-        curr = parent;
-        parent = curr->parent;
-    }
-
-    return (parent == nil) ? NULL : parent;
-}
-
-void dict_allow_dupes(dict_t *dict)
-{
-    dict->dupes = 1;
-}
-
-#undef dict_count
-#undef dict_isempty
-#undef dict_isfull
-#undef dnode_get
-#undef dnode_put
-#undef dnode_getkey
-
-dictcount_t dict_count(dict_t *dict)
-{
-    return dict->nodecount;
-}
-
-int dict_isempty(dict_t *dict)
-{
-    return dict->nodecount == 0;
-}
-
-int dict_isfull(dict_t *dict)
-{
-    return dict->nodecount == dict->maxcount;
-}
-
-int dict_contains(dict_t *dict, dnode_t *node)
-{
-    return verify_dict_has_node(dict_nil(dict), dict_root(dict), node);
-}
-
-static dnode_t *dnode_alloc(void *context EXT2FS_ATTR((unused)))
-{
-    return malloc(sizeof *dnode_alloc(NULL));
-}
-
-static void dnode_free(dnode_t *node, void *context EXT2FS_ATTR((unused)))
-{
-    free(node);
-}
-
-dnode_t *dnode_create(void *data)
-{
-    dnode_t *new = malloc(sizeof *new);
-    if (new) {
-        new->data = data;
-        new->parent = NULL;
-        new->left = NULL;
-        new->right = NULL;
-    }
-    return new;
-}
-
-dnode_t *dnode_init(dnode_t *dnode, void *data)
-{
-    dnode->data = data;
-    dnode->parent = NULL;
-    dnode->left = NULL;
-    dnode->right = NULL;
-    return dnode;
-}
-
-void dnode_destroy(dnode_t *dnode)
-{
-#ifndef NDEBUG
-    assert (!dnode_is_in_a_dict(dnode));
-#endif
-    free(dnode);
-}
-
-void *dnode_get(dnode_t *dnode)
-{
-    return dnode->data;
-}
-
-const void *dnode_getkey(dnode_t *dnode)
-{
-    return dnode->key;
-}
-
-#ifdef E2FSCK_NOTUSED
-void dnode_put(dnode_t *dnode, void *data)
-{
-    dnode->data = data;
-}
-
-int dnode_is_in_a_dict(dnode_t *dnode)
-{
-    return (dnode->parent && dnode->left && dnode->right);
-}
-
-void dict_process(dict_t *dict, void *context, dnode_process_t function)
-{
-    dnode_t *node = dict_first(dict), *next;
-
-    while (node != NULL) {
-        /* check for callback function deleting */
-        /* the next node from under us          */
-        assert (dict_contains(dict, node));
-        next = dict_next(dict, node);
-        function(dict, node, context);
-        node = next;
-    }
-}
-
-static void load_begin_internal(dict_load_t *load, dict_t *dict)
-{
-    load->dictptr = dict;
-    load->nilnode.left = &load->nilnode;
-    load->nilnode.right = &load->nilnode;
-}
-
-void dict_load_begin(dict_load_t *load, dict_t *dict)
-{
-    assert (dict_isempty(dict));
-    load_begin_internal(load, dict);
-}
-
-void dict_load_next(dict_load_t *load, dnode_t *newnode, const void *key)
-{
-    dict_t *dict = load->dictptr;
-    dnode_t *nil = &load->nilnode;
-   
-#ifndef NDEBUG
-    assert (!dnode_is_in_a_dict(newnode));
-    assert (dict->nodecount < dict->maxcount);
-
-    if (dict->nodecount > 0) {
-        if (dict->dupes)
-            assert (dict->compare(nil->left->key, key) <= 0);
-        else
-            assert (dict->compare(nil->left->key, key) < 0);
-    }
-#endif
-
-    newnode->key = key;
-    nil->right->left = newnode;
-    nil->right = newnode;
-    newnode->left = nil;
-    dict->nodecount++;
-}
-
-void dict_load_end(dict_load_t *load)
-{
-    dict_t *dict = load->dictptr;
-    dnode_t *tree[DICT_DEPTH_MAX] = { 0 };
-    dnode_t *curr, *dictnil = dict_nil(dict), *loadnil = &load->nilnode, *next;
-    dnode_t *complete = 0;
-    dictcount_t fullcount = DICTCOUNT_T_MAX, nodecount = dict->nodecount;
-    dictcount_t botrowcount;
-    unsigned baselevel = 0, level = 0, i;
-
-    assert (dnode_red == 0 && dnode_black == 1);
-
-    while (fullcount >= nodecount && fullcount)
-        fullcount >>= 1;
-
-    botrowcount = nodecount - fullcount;
-
-    for (curr = loadnil->left; curr != loadnil; curr = next) {
-        next = curr->left;
-
-        if (complete == NULL && botrowcount-- == 0) {
-            assert (baselevel == 0);
-            assert (level == 0);
-            baselevel = level = 1;
-            complete = tree[0];
-
-            if (complete != 0) {
-                tree[0] = 0;
-                complete->right = dictnil;
-                while (tree[level] != 0) {
-                    tree[level]->right = complete;
-                    complete->parent = tree[level];
-                    complete = tree[level];
-                    tree[level++] = 0;
-                }
-            }
-        }
-
-        if (complete == NULL) {
-            curr->left = dictnil;
-            curr->right = dictnil;
-            curr->color = level % 2;
-            complete = curr;
-
-            assert (level == baselevel);
-            while (tree[level] != 0) {
-                tree[level]->right = complete;
-                complete->parent = tree[level];
-                complete = tree[level];
-                tree[level++] = 0;
-            }
-        } else {
-            curr->left = complete;
-            curr->color = (level + 1) % 2;
-            complete->parent = curr;
-            tree[level] = curr;
-            complete = 0;
-            level = baselevel;
-        }
-    }
-
-    if (complete == NULL)
-        complete = dictnil;
-
-    for (i = 0; i < DICT_DEPTH_MAX; i++) {
-        if (tree[i] != 0) {
-            tree[i]->right = complete;
-            complete->parent = tree[i];
-            complete = tree[i];
-        }
-    }
-
-    dictnil->color = dnode_black;
-    dictnil->right = dictnil;
-    complete->parent = dictnil;
-    complete->color = dnode_black;
-    dict_root(dict) = complete;
-
-#ifdef E2FSCK_NOTUSED
-    assert (dict_verify(dict));
-#endif
-}
-
-void dict_merge(dict_t *dest, dict_t *source)
-{
-    dict_load_t load;
-    dnode_t *leftnode = dict_first(dest), *rightnode = dict_first(source);
-
-    assert (dict_similar(dest, source));        
-
-    if (source == dest)
-        return;
-
-    dest->nodecount = 0;
-    load_begin_internal(&load, dest);
-
-    for (;;) {
-        if (leftnode != NULL && rightnode != NULL) {
-            if (dest->compare(leftnode->key, rightnode->key) < 0)
-                goto copyleft;
-            else
-                goto copyright;
-        } else if (leftnode != NULL) {
-            goto copyleft;
-        } else if (rightnode != NULL) {
-            goto copyright;
-        } else {
-            assert (leftnode == NULL && rightnode == NULL);
-            break;
-        }
-
-    copyleft:
-        {
-            dnode_t *next = dict_next(dest, leftnode);
-#ifndef NDEBUG
-            leftnode->left = NULL;      /* suppress assertion in dict_load_next */
-#endif
-            dict_load_next(&load, leftnode, leftnode->key);
-            leftnode = next;
-            continue;
-        }
-        
-    copyright:
-        {
-            dnode_t *next = dict_next(source, rightnode);
-#ifndef NDEBUG
-            rightnode->left = NULL;
-#endif
-            dict_load_next(&load, rightnode, rightnode->key);
-            rightnode = next;
-            continue;
-        }
-    }
-
-    dict_clear(source);
-    dict_load_end(&load);
-}
-#endif /* E2FSCK_NOTUSED */
-
-#ifdef KAZLIB_TEST_MAIN
-
-#include <stdio.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdarg.h>
-
-typedef char input_t[256];
-
-static int tokenize(char *string, ...)
-{
-    char **tokptr; 
-    va_list arglist;
-    int tokcount = 0;
-
-    va_start(arglist, string);
-    tokptr = va_arg(arglist, char **);
-    while (tokptr) {
-        while (*string && isspace((unsigned char) *string))
-            string++;
-        if (!*string)
-            break;
-        *tokptr = string;
-        while (*string && !isspace((unsigned char) *string))
-            string++;
-        tokptr = va_arg(arglist, char **);
-        tokcount++;
-        if (!*string)
-            break;
-        *string++ = 0;
-    }
-    va_end(arglist);
-
-    return tokcount;
-}
-
-static int comparef(const void *key1, const void *key2)
-{
-    return strcmp(key1, key2);
-}
-
-static char *dupstring(char *str)
-{
-    int sz = strlen(str) + 1;
-    char *new = malloc(sz);
-    if (new)
-        memcpy(new, str, sz);
-    return new;
-}
-
-static dnode_t *new_node(void *c)
-{
-    static dnode_t few[5];
-    static int count;
-
-    if (count < 5)
-        return few + count++;
-
-    return NULL;
-}
-
-static void del_node(dnode_t *n, void *c)
-{
-}
-
-static int prompt = 0;
-
-static void construct(dict_t *d)
-{
-    input_t in;
-    int done = 0;
-    dict_load_t dl;
-    dnode_t *dn;
-    char *tok1, *tok2, *val;
-    const char *key;
-    char *help = 
-        "p                      turn prompt on\n"
-        "q                      finish construction\n"
-        "a <key> <val>          add new entry\n";
-
-    if (!dict_isempty(d))
-        puts("warning: dictionary not empty!");
-
-    dict_load_begin(&dl, d);
-
-    while (!done) {
-        if (prompt)
-            putchar('>');
-        fflush(stdout);
-
-        if (!fgets(in, sizeof(input_t), stdin))
-            break;
-
-        switch (in[0]) {
-            case '?':
-                puts(help);
-                break;
-            case 'p':
-                prompt = 1;
-                break;
-            case 'q':
-                done = 1;
-                break;
-            case 'a':
-                if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
-                    puts("what?");
-                    break;
-                }
-                key = dupstring(tok1);
-                val = dupstring(tok2);
-                dn = dnode_create(val);
-
-                if (!key || !val || !dn) {
-                    puts("out of memory");
-                    free((void *) key);
-                    free(val);
-                    if (dn)
-                        dnode_destroy(dn);
-                }
-
-                dict_load_next(&dl, dn, key);
-                break;
-            default:
-                putchar('?');
-                putchar('\n');
-                break;
-        }
-    }
-
-    dict_load_end(&dl);
-}
-
-int main(void)
-{
-    input_t in;
-    dict_t darray[10];
-    dict_t *d = &darray[0];
-    dnode_t *dn;
-    int i;
-    char *tok1, *tok2, *val;
-    const char *key;
-
-    char *help =
-        "a <key> <val>          add value to dictionary\n"
-        "d <key>                delete value from dictionary\n"
-        "l <key>                lookup value in dictionary\n"
-        "( <key>                lookup lower bound\n"
-        ") <key>                lookup upper bound\n"
-        "# <num>                switch to alternate dictionary (0-9)\n"
-        "j <num> <num>          merge two dictionaries\n"
-        "f                      free the whole dictionary\n"
-        "k                      allow duplicate keys\n"
-        "c                      show number of entries\n"
-        "t                      dump whole dictionary in sort order\n"
-        "m                      make dictionary out of sorted items\n"
-        "p                      turn prompt on\n"
-        "s                      switch to non-functioning allocator\n"
-        "q                      quit";
-
-    for (i = 0; i < sizeof darray / sizeof *darray; i++)
-        dict_init(&darray[i], DICTCOUNT_T_MAX, comparef);
-
-    for (;;) {
-        if (prompt)
-            putchar('>');
-        fflush(stdout);
-
-        if (!fgets(in, sizeof(input_t), stdin))
-            break;
-
-        switch(in[0]) {
-            case '?':
-                puts(help);
-                break;
-            case 'a':
-                if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
-                    puts("what?");
-                    break;
-                }
-                key = dupstring(tok1);
-                val = dupstring(tok2);
-
-                if (!key || !val) {
-                    puts("out of memory");
-                    free((void *) key);
-                    free(val);
-                }
-
-                if (!dict_alloc_insert(d, key, val)) {
-                    puts("dict_alloc_insert failed");
-                    free((void *) key);
-                    free(val);
-                    break;
-                }
-                break;
-            case 'd':
-                if (tokenize(in+1, &tok1, (char **) 0) != 1) {
-                    puts("what?");
-                    break;
-                }
-                dn = dict_lookup(d, tok1);
-                if (!dn) {
-                    puts("dict_lookup failed");
-                    break;
-                }
-                val = dnode_get(dn);
-                key = dnode_getkey(dn);
-                dict_delete_free(d, dn);
-
-                free(val);
-                free((void *) key);
-                break;
-            case 'f':
-                dict_free(d);
-                break;
-            case 'l':
-            case '(':
-            case ')':
-                if (tokenize(in+1, &tok1, (char **) 0) != 1) {
-                    puts("what?");
-                    break;
-                }
-                dn = 0;
-                switch (in[0]) {
-                case 'l':
-                    dn = dict_lookup(d, tok1);
-                    break;
-                case '(':
-                    dn = dict_lower_bound(d, tok1);
-                    break;
-                case ')':
-                    dn = dict_upper_bound(d, tok1);
-                    break;
-                }
-                if (!dn) {
-                    puts("lookup failed");
-                    break;
-                }
-                val = dnode_get(dn);
-                puts(val);
-                break;
-            case 'm':
-                construct(d);
-                break;
-            case 'k':
-                dict_allow_dupes(d);
-                break;
-            case 'c':
-                printf("%lu\n", (unsigned long) dict_count(d));
-                break;
-            case 't':
-                for (dn = dict_first(d); dn; dn = dict_next(d, dn)) {
-                    printf("%s\t%s\n", (char *) dnode_getkey(dn),
-                            (char *) dnode_get(dn));
-                }
-                break;
-            case 'q':
-                exit(0);
-                break;
-            case '\0':
-                break;
-            case 'p':
-                prompt = 1;
-                break;
-            case 's':
-                dict_set_allocator(d, new_node, del_node, NULL);
-                break;
-            case '#':
-                if (tokenize(in+1, &tok1, (char **) 0) != 1) {
-                    puts("what?");
-                    break;
-                } else {
-                    int dictnum = atoi(tok1);
-                    if (dictnum < 0 || dictnum > 9) {
-                        puts("invalid number");
-                        break;
-                    }
-                    d = &darray[dictnum];
-                }
-                break;
-            case 'j':
-                if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
-                    puts("what?");
-                    break;
-                } else {
-                    int dict1 = atoi(tok1), dict2 = atoi(tok2);
-                    if (dict1 < 0 || dict1 > 9 || dict2 < 0 || dict2 > 9) {
-                        puts("invalid number");
-                        break;
-                    }
-                    dict_merge(&darray[dict1], &darray[dict2]);
-                }
-                break;
-            default:
-                putchar('?');
-                putchar('\n');
-                break;
-        }
-    }
-
-    return 0;
-}
-
-#endif
diff --git a/e2fsprogs/e2fsck/dict.h b/e2fsprogs/e2fsck/dict.h
deleted file mode 100644
index 838079d6c..000000000
--- a/e2fsprogs/e2fsck/dict.h
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Dictionary Abstract Data Type
- * Copyright (C) 1997 Kaz Kylheku <kaz@ashi.footprints.net>
- *
- * Free Software License:
- *
- * All rights are reserved by the author, with the following exceptions:
- * Permission is granted to freely reproduce and distribute this software,
- * possibly in exchange for a fee, provided that this copyright notice appears
- * intact. Permission is also granted to adapt this software to produce
- * derivative works, as long as the modified versions carry this copyright
- * notice and additional notices stating that the work has been modified.
- * This source code may be translated into executable form and incorporated
- * into proprietary software; there is no requirement for such software to
- * contain a copyright notice related to this source.
- *
- * $Id: dict.h,v 1.22.2.6 2000/11/13 01:36:44 kaz Exp $
- * $Name: kazlib_1_20 $
- */
-
-#ifndef DICT_H
-#define DICT_H
-
-#include <limits.h>
-#ifdef KAZLIB_SIDEEFFECT_DEBUG
-#include "sfx.h"
-#endif
-
-/*
- * Blurb for inclusion into C++ translation units
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef unsigned long dictcount_t;
-#define DICTCOUNT_T_MAX ULONG_MAX
-
-/*
- * The dictionary is implemented as a red-black tree
- */
-
-typedef enum { dnode_red, dnode_black } dnode_color_t;
-
-typedef struct dnode_t {
-#if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
-    struct dnode_t *dict_left;
-    struct dnode_t *dict_right;
-    struct dnode_t *dict_parent;
-    dnode_color_t dict_color;
-    const void *dict_key;
-    void *dict_data;
-#else
-    int dict_dummy;
-#endif
-} dnode_t;
-
-typedef int (*dict_comp_t)(const void *, const void *);
-typedef dnode_t *(*dnode_alloc_t)(void *);
-typedef void (*dnode_free_t)(dnode_t *, void *);
-
-typedef struct dict_t {
-#if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
-    dnode_t dict_nilnode;
-    dictcount_t dict_nodecount;
-    dictcount_t dict_maxcount;
-    dict_comp_t dict_compare;
-    dnode_alloc_t dict_allocnode;
-    dnode_free_t dict_freenode;
-    void *dict_context;
-    int dict_dupes;
-#else
-    int dict_dummmy;
-#endif
-} dict_t;
-
-typedef void (*dnode_process_t)(dict_t *, dnode_t *, void *);
-
-typedef struct dict_load_t {
-#if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
-    dict_t *dict_dictptr;
-    dnode_t dict_nilnode;
-#else
-    int dict_dummmy;
-#endif
-} dict_load_t;
-
-extern dict_t *dict_create(dictcount_t, dict_comp_t);
-extern void dict_set_allocator(dict_t *, dnode_alloc_t, dnode_free_t, void *);
-extern void dict_destroy(dict_t *);
-extern void dict_free_nodes(dict_t *);
-extern void dict_free(dict_t *);
-extern dict_t *dict_init(dict_t *, dictcount_t, dict_comp_t);
-extern void dict_init_like(dict_t *, const dict_t *);
-extern int dict_verify(dict_t *);
-extern int dict_similar(const dict_t *, const dict_t *);
-extern dnode_t *dict_lookup(dict_t *, const void *);
-extern dnode_t *dict_lower_bound(dict_t *, const void *);
-extern dnode_t *dict_upper_bound(dict_t *, const void *);
-extern void dict_insert(dict_t *, dnode_t *, const void *);
-extern dnode_t *dict_delete(dict_t *, dnode_t *);
-extern int dict_alloc_insert(dict_t *, const void *, void *);
-extern void dict_delete_free(dict_t *, dnode_t *);
-extern dnode_t *dict_first(dict_t *);
-extern dnode_t *dict_last(dict_t *);
-extern dnode_t *dict_next(dict_t *, dnode_t *);
-extern dnode_t *dict_prev(dict_t *, dnode_t *);
-extern dictcount_t dict_count(dict_t *);
-extern int dict_isempty(dict_t *);
-extern int dict_isfull(dict_t *);
-extern int dict_contains(dict_t *, dnode_t *);
-extern void dict_allow_dupes(dict_t *);
-extern int dnode_is_in_a_dict(dnode_t *);
-extern dnode_t *dnode_create(void *);
-extern dnode_t *dnode_init(dnode_t *, void *);
-extern void dnode_destroy(dnode_t *);
-extern void *dnode_get(dnode_t *);
-extern const void *dnode_getkey(dnode_t *);
-extern void dnode_put(dnode_t *, void *);
-extern void dict_process(dict_t *, void *, dnode_process_t);
-extern void dict_load_begin(dict_load_t *, dict_t *);
-extern void dict_load_next(dict_load_t *, dnode_t *, const void *);
-extern void dict_load_end(dict_load_t *);
-extern void dict_merge(dict_t *, dict_t *);
-
-#if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG)
-#ifdef KAZLIB_SIDEEFFECT_DEBUG
-#define dict_isfull(D) (SFX_CHECK(D)->dict_nodecount == (D)->dict_maxcount)
-#else
-#define dict_isfull(D) ((D)->dict_nodecount == (D)->dict_maxcount)
-#endif
-#define dict_count(D) ((D)->dict_nodecount)
-#define dict_isempty(D) ((D)->dict_nodecount == 0)
-#define dnode_get(N) ((N)->dict_data)
-#define dnode_getkey(N) ((N)->dict_key)
-#define dnode_put(N, X) ((N)->dict_data = (X))
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/e2fsprogs/e2fsck/dirinfo.c b/e2fsprogs/e2fsck/dirinfo.c
deleted file mode 100644
index 516c46135..000000000
--- a/e2fsprogs/e2fsck/dirinfo.c
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * dirinfo.c --- maintains the directory information table for e2fsck.
- *
- * Copyright (C) 1993 Theodore Ts'o.  This file may be redistributed
- * under the terms of the GNU Public License.
- */
-
-#include "e2fsck.h"
-
-/*
- * This subroutine is called during pass1 to create a directory info
- * entry.  During pass1, the passed-in parent is 0; it will get filled
- * in during pass2.  
- */
-void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent)
-{
-        struct dir_info *dir;
-        int             i, j;
-        ext2_ino_t      num_dirs;
-        errcode_t       retval;
-        unsigned long   old_size;
-
-#if 0
-        printf("add_dir_info for inode %lu...\n", ino);
-#endif
-        if (!ctx->dir_info) {
-                ctx->dir_info_count = 0;
-                retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs);
-                if (retval)
-                        num_dirs = 1024;        /* Guess */
-                ctx->dir_info_size = num_dirs + 10;
-                ctx->dir_info  = (struct dir_info *)
-                        e2fsck_allocate_memory(ctx, ctx->dir_info_size
-                                               * sizeof (struct dir_info),
-                                               "directory map");
-        }
-        
-        if (ctx->dir_info_count >= ctx->dir_info_size) {
-                old_size = ctx->dir_info_size * sizeof(struct dir_info);
-                ctx->dir_info_size += 10;
-                retval = ext2fs_resize_mem(old_size, ctx->dir_info_size *
-                                           sizeof(struct dir_info),
-                                           &ctx->dir_info);
-                if (retval) {
-                        ctx->dir_info_size -= 10;
-                        return;
-                }
-        }
-
-        /*
-         * Normally, add_dir_info is called with each inode in
-         * sequential order; but once in a while (like when pass 3
-         * needs to recreate the root directory or lost+found
-         * directory) it is called out of order.  In those cases, we
-         * need to move the dir_info entries down to make room, since
-         * the dir_info array needs to be sorted by inode number for
-         * get_dir_info()'s sake.
-         */
-        if (ctx->dir_info_count &&
-            ctx->dir_info[ctx->dir_info_count-1].ino >= ino) {
-                for (i = ctx->dir_info_count-1; i > 0; i--)
-                        if (ctx->dir_info[i-1].ino < ino)
-                                break;
-                dir = &ctx->dir_info[i];
-                if (dir->ino != ino) 
-                        for (j = ctx->dir_info_count++; j > i; j--)
-                                ctx->dir_info[j] = ctx->dir_info[j-1];
-        } else
-                dir = &ctx->dir_info[ctx->dir_info_count++];
-        
-        dir->ino = ino;
-        dir->dotdot = parent;
-        dir->parent = parent;
-}
-
-/*
- * get_dir_info() --- given an inode number, try to find the directory
- * information entry for it.
- */
-struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino)
-{
-        int     low, high, mid;
-
-        low = 0;
-        high = ctx->dir_info_count-1;
-        if (!ctx->dir_info)
-                return 0;
-        if (ino == ctx->dir_info[low].ino)
-                return &ctx->dir_info[low];
-        if  (ino == ctx->dir_info[high].ino)
-                return &ctx->dir_info[high];
-
-        while (low < high) {
-                mid = (low+high)/2;
-                if (mid == low || mid == high)
-                        break;
-                if (ino == ctx->dir_info[mid].ino)
-                        return &ctx->dir_info[mid];
-                if (ino < ctx->dir_info[mid].ino)
-                        high = mid;
-                else
-                        low = mid;
-        }
-        return 0;
-}
-
-/*
- * Free the dir_info structure when it isn't needed any more.
- */
-void e2fsck_free_dir_info(e2fsck_t ctx)
-{
-        if (ctx->dir_info) {
-                ext2fs_free_mem(&ctx->dir_info);
-                ctx->dir_info = 0;
-        }
-        ctx->dir_info_size = 0;
-        ctx->dir_info_count = 0;
-}
-
-/*
- * Return the count of number of directories in the dir_info structure
- */
-int e2fsck_get_num_dirinfo(e2fsck_t ctx)
-{
-        return ctx->dir_info_count;
-}
-
-/*
- * A simple interator function
- */
-struct dir_info *e2fsck_dir_info_iter(e2fsck_t ctx, int *control)
-{
-        if (*control >= ctx->dir_info_count)
-                return 0;
-
-        return(ctx->dir_info + (*control)++);
-}
diff --git a/e2fsprogs/e2fsck/dx_dirinfo.c b/e2fsprogs/e2fsck/dx_dirinfo.c
deleted file mode 100644
index 322f51679..000000000
--- a/e2fsprogs/e2fsck/dx_dirinfo.c
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * dirinfo.c --- maintains the directory information table for e2fsck.
- *
- * Copyright (C) 1993 Theodore Ts'o.  This file may be redistributed
- * under the terms of the GNU Public License.
- */
-
-#include "e2fsck.h"
-#ifdef ENABLE_HTREE
-
-/*
- * This subroutine is called during pass1 to create a directory info
- * entry.  During pass1, the passed-in parent is 0; it will get filled
- * in during pass2.  
- */
-void e2fsck_add_dx_dir(e2fsck_t ctx, ext2_ino_t ino, int num_blocks)
-{
-        struct dx_dir_info *dir;
-        int             i, j;
-        errcode_t       retval;
-        unsigned long   old_size;
-
-#if 0
-        printf("add_dx_dir_info for inode %lu...\n", ino);
-#endif
-        if (!ctx->dx_dir_info) {
-                ctx->dx_dir_info_count = 0;
-                ctx->dx_dir_info_size = 100; /* Guess */
-                ctx->dx_dir_info  = (struct dx_dir_info *)
-                        e2fsck_allocate_memory(ctx, ctx->dx_dir_info_size
-                                               * sizeof (struct dx_dir_info),
-                                               "directory map");
-        }
-        
-        if (ctx->dx_dir_info_count >= ctx->dx_dir_info_size) {
-                old_size = ctx->dx_dir_info_size * sizeof(struct dx_dir_info);
-                ctx->dx_dir_info_size += 10;
-                retval = ext2fs_resize_mem(old_size, ctx->dx_dir_info_size *
-                                           sizeof(struct dx_dir_info),
-                                           &ctx->dx_dir_info);
-                if (retval) {
-                        ctx->dx_dir_info_size -= 10;
-                        return;
-                }
-        }
-
-        /*
-         * Normally, add_dx_dir_info is called with each inode in
-         * sequential order; but once in a while (like when pass 3
-         * needs to recreate the root directory or lost+found
-         * directory) it is called out of order.  In those cases, we
-         * need to move the dx_dir_info entries down to make room, since
-         * the dx_dir_info array needs to be sorted by inode number for
-         * get_dx_dir_info()'s sake.
-         */
-        if (ctx->dx_dir_info_count &&
-            ctx->dx_dir_info[ctx->dx_dir_info_count-1].ino >= ino) {
-                for (i = ctx->dx_dir_info_count-1; i > 0; i--)
-                        if (ctx->dx_dir_info[i-1].ino < ino)
-                                break;
-                dir = &ctx->dx_dir_info[i];
-                if (dir->ino != ino) 
-                        for (j = ctx->dx_dir_info_count++; j > i; j--)
-                                ctx->dx_dir_info[j] = ctx->dx_dir_info[j-1];
-        } else
-                dir = &ctx->dx_dir_info[ctx->dx_dir_info_count++];
-        
-        dir->ino = ino;
-        dir->numblocks = num_blocks;
-        dir->hashversion = 0;
-        dir->dx_block = e2fsck_allocate_memory(ctx, num_blocks
-                                       * sizeof (struct dx_dirblock_info),
-                                       "dx_block info array");
-
-}
-
-/*
- * get_dx_dir_info() --- given an inode number, try to find the directory
- * information entry for it.
- */
-struct dx_dir_info *e2fsck_get_dx_dir_info(e2fsck_t ctx, ext2_ino_t ino)
-{
-        int     low, high, mid;
-
-        low = 0;
-        high = ctx->dx_dir_info_count-1;
-        if (!ctx->dx_dir_info)
-                return 0;
-        if (ino == ctx->dx_dir_info[low].ino)
-                return &ctx->dx_dir_info[low];
-        if  (ino == ctx->dx_dir_info[high].ino)
-                return &ctx->dx_dir_info[high];
-
-        while (low < high) {
-                mid = (low+high)/2;
-                if (mid == low || mid == high)
-                        break;
-                if (ino == ctx->dx_dir_info[mid].ino)
-                        return &ctx->dx_dir_info[mid];
-                if (ino < ctx->dx_dir_info[mid].ino)
-                        high = mid;
-                else
-                        low = mid;
-        }
-        return 0;
-}
-
-/*
- * Free the dx_dir_info structure when it isn't needed any more.
- */
-void e2fsck_free_dx_dir_info(e2fsck_t ctx)
-{
-        int     i;
-        struct dx_dir_info *dir;
-        
-        if (ctx->dx_dir_info) {
-                dir = ctx->dx_dir_info;
-                for (i=0; i < ctx->dx_dir_info_count; i++) {
-                        if (dir->dx_block) {
-                                ext2fs_free_mem(&dir->dx_block);
-                                dir->dx_block = 0;
-                        }
-                }
-                ext2fs_free_mem(&ctx->dx_dir_info);
-                ctx->dx_dir_info = 0;
-        }
-        ctx->dx_dir_info_size = 0;
-        ctx->dx_dir_info_count = 0;
-}
-
-/*
- * Return the count of number of directories in the dx_dir_info structure
- */
-int e2fsck_get_num_dx_dirinfo(e2fsck_t ctx)
-{
-        return ctx->dx_dir_info_count;
-}
-
-/*
- * A simple interator function
- */
-struct dx_dir_info *e2fsck_dx_dir_info_iter(e2fsck_t ctx, int *control)
-{
-        if (*control >= ctx->dx_dir_info_count)
-                return 0;
-
-        return(ctx->dx_dir_info + (*control)++);
-}
-
-#endif /* ENABLE_HTREE */
diff --git a/e2fsprogs/e2fsck/e2fsck.c b/e2fsprogs/e2fsck/e2fsck.c
deleted file mode 100644
index 2a84c5171..000000000
--- a/e2fsprogs/e2fsck/e2fsck.c
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
- * e2fsck.c - a consistency checker for the new extended file system.
- * 
- * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- */
-
-#include <errno.h>
-
-#include "e2fsck.h"
-#include "problem.h"
-
-/*
- * This function allocates an e2fsck context 
- */
-errcode_t e2fsck_allocate_context(e2fsck_t *ret)
-{
-        e2fsck_t        context;
-        errcode_t       retval;
-
-        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;
-
-        *ret = context;
-        return 0;
-}
-
-/*
- * This function resets an e2fsck context; it is called when e2fsck
- * needs to be restarted.
- */
-errcode_t e2fsck_reset_context(e2fsck_t ctx)
-{
-        ctx->flags = 0;
-        ctx->lost_and_found = 0;
-        ctx->bad_lost_and_found = 0;
-        if (ctx->inode_used_map) {
-                ext2fs_free_inode_bitmap(ctx->inode_used_map);
-                ctx->inode_used_map = 0;
-        }
-        if (ctx->inode_dir_map) {
-                ext2fs_free_inode_bitmap(ctx->inode_dir_map);
-                ctx->inode_dir_map = 0;
-        }
-        if (ctx->inode_reg_map) {
-                ext2fs_free_inode_bitmap(ctx->inode_reg_map);
-                ctx->inode_reg_map = 0;
-        }
-        if (ctx->block_found_map) {
-                ext2fs_free_block_bitmap(ctx->block_found_map);
-                ctx->block_found_map = 0;
-        }
-        if (ctx->inode_link_info) {
-                ext2fs_free_icount(ctx->inode_link_info);
-                ctx->inode_link_info = 0;
-        }
-        if (ctx->journal_io) {
-                if (ctx->fs && ctx->fs->io != ctx->journal_io)
-                        io_channel_close(ctx->journal_io);
-                ctx->journal_io = 0;
-        }
-        if (ctx->fs && ctx->fs->dblist) {
-                ext2fs_free_dblist(ctx->fs->dblist);
-                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;
-        }
-        if (ctx->refcount_extra) {
-                ea_refcount_free(ctx->refcount_extra);
-                ctx->refcount_extra = 0;
-        }
-        if (ctx->block_dup_map) {
-                ext2fs_free_block_bitmap(ctx->block_dup_map);
-                ctx->block_dup_map = 0;
-        }
-        if (ctx->block_ea_map) {
-                ext2fs_free_block_bitmap(ctx->block_ea_map);
-                ctx->block_ea_map = 0;
-        }
-        if (ctx->inode_bb_map) {
-                ext2fs_free_inode_bitmap(ctx->inode_bb_map);
-                ctx->inode_bb_map = 0;
-        }
-        if (ctx->inode_bad_map) {
-                ext2fs_free_inode_bitmap(ctx->inode_bad_map);
-                ctx->inode_bad_map = 0;
-        }
-        if (ctx->inode_imagic_map) {
-                ext2fs_free_inode_bitmap(ctx->inode_imagic_map);
-                ctx->inode_imagic_map = 0;
-        }
-        if (ctx->dirs_to_hash) {
-                ext2fs_u32_list_free(ctx->dirs_to_hash);
-                ctx->dirs_to_hash = 0;
-        }
-
-        /*
-         * Clear the array of invalid meta-data flags
-         */
-        if (ctx->invalid_inode_bitmap_flag) {
-                ext2fs_free_mem(&ctx->invalid_inode_bitmap_flag);
-                ctx->invalid_inode_bitmap_flag = 0;
-        }
-        if (ctx->invalid_block_bitmap_flag) {
-                ext2fs_free_mem(&ctx->invalid_block_bitmap_flag);
-                ctx->invalid_block_bitmap_flag = 0;
-        }
-        if (ctx->invalid_inode_table_flag) {
-                ext2fs_free_mem(&ctx->invalid_inode_table_flag);
-                ctx->invalid_inode_table_flag = 0;
-        }
-
-        /* Clear statistic counters */
-        ctx->fs_directory_count = 0;
-        ctx->fs_regular_count = 0;
-        ctx->fs_blockdev_count = 0;
-        ctx->fs_chardev_count = 0;
-        ctx->fs_links_count = 0;
-        ctx->fs_symlinks_count = 0;
-        ctx->fs_fast_symlinks_count = 0;
-        ctx->fs_fifo_count = 0;
-        ctx->fs_total_count = 0;
-        ctx->fs_badblocks_count = 0;
-        ctx->fs_sockets_count = 0;
-        ctx->fs_ind_count = 0;
-        ctx->fs_dind_count = 0;
-        ctx->fs_tind_count = 0;
-        ctx->fs_fragmented = 0;
-        ctx->large_files = 0;
-
-        /* Reset the superblock to the user's requested value */
-        ctx->superblock = ctx->use_superblock;
-        
-        return 0;
-}
-
-void e2fsck_free_context(e2fsck_t ctx)
-{
-        if (!ctx)
-                return;
-        
-        e2fsck_reset_context(ctx);
-        if (ctx->blkid)
-                blkid_put_cache(ctx->blkid);
-                        
-        ext2fs_free_mem(&ctx);
-}
-
-/*
- * This function runs through the e2fsck passes and calls them all,
- * returning restart, abort, or cancel as necessary...
- */
-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)
-
-int e2fsck_run(e2fsck_t ctx)
-{
-        int     i;
-        pass_t  e2fsck_pass;
-
-#ifdef HAVE_SETJMP_H
-        if (setjmp(ctx->abort_loc)) {
-                ctx->flags &= ~E2F_FLAG_SETJMP_OK;
-                return (ctx->flags & E2F_FLAG_RUN_RETURN);
-        }
-        ctx->flags |= E2F_FLAG_SETJMP_OK;
-#endif
-                
-        for (i=0; (e2fsck_pass = e2fsck_passes[i]); i++) {
-                if (ctx->flags & E2F_FLAG_RUN_RETURN)
-                        break;
-                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;
-}
diff --git a/e2fsprogs/e2fsck/e2fsck.h b/e2fsprogs/e2fsck/e2fsck.h
deleted file mode 100644
index 489903d7c..000000000
--- a/e2fsprogs/e2fsck/e2fsck.h
+++ /dev/null
@@ -1,446 +0,0 @@
-/*
- * e2fsck.h
- * 
- * Copyright (C) 1993, 1994 Theodore Ts'o.  This file may be
- * redistributed under the terms of the GNU Public License.
- * 
- */
-
-#include <stdio.h>
-#include <string.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <stdlib.h>
-#include <time.h>
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-#ifdef HAVE_SETJMP_H
-#include <setjmp.h>
-#endif
-
-#if EXT2_FLAT_INCLUDES
-#include "ext2_fs.h"
-#include "ext2fs.h"
-#include "blkid.h"
-#else
-#include "ext2fs/ext2_fs.h"
-#include "ext2fs/ext2fs.h"
-#include "blkid/blkid.h"
-#endif
-
-/*
- * Exit codes used by fsck-type programs
- */
-#define FSCK_OK          0      /* No errors */
-#define FSCK_NONDESTRUCT 1      /* File system errors corrected */
-#define FSCK_REBOOT      2      /* System should be rebooted */
-#define FSCK_UNCORRECTED 4      /* File system errors left uncorrected */
-#define FSCK_ERROR       8      /* Operational error */
-#define FSCK_USAGE       16     /* Usage or syntax error */
-#define FSCK_CANCELED    32     /* Aborted with a signal or ^C */
-#define FSCK_LIBRARY     128    /* Shared library error */
-
-/*
- * The last ext2fs revision level that this version of e2fsck is able to
- * support
- */
-#define E2FSCK_CURRENT_REV      1
-
-/*
- * The directory information structure; stores directory information
- * collected in earlier passes, to avoid disk i/o in fetching the
- * directory information.
- */
-struct dir_info {
-        ext2_ino_t              ino;    /* Inode number */
-        ext2_ino_t              dotdot; /* Parent according to '..' */
-        ext2_ino_t              parent; /* Parent according to treewalk */
-};
-
-
-/*
- * The indexed directory information structure; stores information for
- * directories which contain a hash tree index.
- */
-struct dx_dir_info {
-        ext2_ino_t              ino;            /* Inode number */
-        int                     numblocks;      /* number of blocks */
-        int                     hashversion;
-        short                   depth;          /* depth of tree */
-        struct dx_dirblock_info *dx_block;      /* Array of size numblocks */
-};
-
-#define DX_DIRBLOCK_ROOT        1
-#define DX_DIRBLOCK_LEAF        2
-#define DX_DIRBLOCK_NODE        3
-#define DX_DIRBLOCK_CORRUPT     4
-#define DX_DIRBLOCK_CLEARED     8
-
-struct dx_dirblock_info {
-        int             type;
-        blk_t           phys;
-        int             flags;
-        blk_t           parent;
-        ext2_dirhash_t  min_hash; 
-        ext2_dirhash_t  max_hash;
-        ext2_dirhash_t  node_min_hash; 
-        ext2_dirhash_t  node_max_hash;
-};
-
-#define DX_FLAG_REFERENCED      1
-#define DX_FLAG_DUP_REF         2
-#define DX_FLAG_FIRST           4
-#define DX_FLAG_LAST            8
-
-#ifdef RESOURCE_TRACK
-/*
- * This structure is used for keeping track of how much resources have
- * been used for a particular pass of e2fsck.
- */
-struct resource_track {
-        struct timeval time_start;
-        struct timeval user_start;
-        struct timeval system_start;
-        void    *brk_start;
-};
-#endif
-
-/*
- * E2fsck options
- */
-#define E2F_OPT_READONLY        0x0001
-#define E2F_OPT_PREEN           0x0002
-#define E2F_OPT_YES             0x0004
-#define E2F_OPT_NO              0x0008
-#define E2F_OPT_TIME            0x0010
-#define E2F_OPT_TIME2           0x0020
-#define E2F_OPT_CHECKBLOCKS     0x0040
-#define E2F_OPT_DEBUG           0x0080
-#define E2F_OPT_FORCE           0x0100
-#define E2F_OPT_WRITECHECK      0x0200
-#define E2F_OPT_COMPRESS_DIRS   0x0400
-
-/*
- * E2fsck flags
- */
-#define E2F_FLAG_ABORT          0x0001 /* Abort signaled */
-#define E2F_FLAG_CANCEL         0x0002 /* Cancel signaled */
-#define E2F_FLAG_SIGNAL_MASK    0x0003
-#define E2F_FLAG_RESTART        0x0004 /* Restart signaled */
-
-#define E2F_FLAG_SETJMP_OK      0x0010 /* Setjmp valid for abort */
-
-#define E2F_FLAG_PROG_BAR       0x0020 /* Progress bar on screen */
-#define E2F_FLAG_PROG_SUPPRESS  0x0040 /* Progress suspended */
-#define E2F_FLAG_JOURNAL_INODE  0x0080 /* Create a new ext3 journal inode */
-#define E2F_FLAG_SB_SPECIFIED   0x0100 /* The superblock was explicitly 
-                                        * specified by the user */
-#define E2F_FLAG_RESTARTED      0x0200 /* E2fsck has been restarted */
-#define E2F_FLAG_RESIZE_INODE   0x0400 /* Request to recreate resize inode */
-
-/*
- * Defines for indicating the e2fsck pass number
- */
-#define E2F_PASS_1      1
-#define E2F_PASS_2      2
-#define E2F_PASS_3      3
-#define E2F_PASS_4      4
-#define E2F_PASS_5      5
-#define E2F_PASS_1B     6
-
-/*
- * Define the extended attribute refcount structure
- */
-typedef struct ea_refcount *ext2_refcount_t;
-
-/*
- * This is the global e2fsck structure.
- */
-typedef struct e2fsck_struct *e2fsck_t;
-
-struct e2fsck_struct {
-        ext2_filsys fs;
-        const char *program_name;
-        char *filesystem_name;
-        char *device_name;
-        char *io_options;
-        int     flags;          /* E2fsck internal flags */
-        int     options;
-        blk_t   use_superblock; /* sb requested by user */
-        blk_t   superblock;     /* sb used to open fs */
-        int     blocksize;      /* blocksize */
-        blk_t   num_blocks;     /* Total number of blocks */
-        int     mount_flags;
-        blkid_cache blkid;      /* blkid cache */
-
-#ifdef HAVE_SETJMP_H
-        jmp_buf abort_loc;
-#endif
-        unsigned long abort_code;
-
-        int (*progress)(e2fsck_t ctx, int pass, unsigned long cur,
-                        unsigned long max);
-
-        ext2fs_inode_bitmap inode_used_map; /* Inodes which are in use */
-        ext2fs_inode_bitmap inode_bad_map; /* Inodes which are bad somehow */
-        ext2fs_inode_bitmap inode_dir_map; /* Inodes which are directories */
-        ext2fs_inode_bitmap inode_bb_map; /* Inodes which are in bad blocks */
-        ext2fs_inode_bitmap inode_imagic_map; /* AFS inodes */
-        ext2fs_inode_bitmap inode_reg_map; /* Inodes which are regular files*/
-
-        ext2fs_block_bitmap block_found_map; /* Blocks which are in use */
-        ext2fs_block_bitmap block_dup_map; /* Blks referenced more than once */
-        ext2fs_block_bitmap block_ea_map; /* Blocks which are used by EA's */
-
-        /*
-         * Inode count arrays
-         */
-        ext2_icount_t   inode_count;
-        ext2_icount_t inode_link_info;
-
-        ext2_refcount_t refcount;
-        ext2_refcount_t refcount_extra;
-
-        /*
-         * Array of flags indicating whether an inode bitmap, block
-         * bitmap, or inode table is invalid
-         */
-        int *invalid_inode_bitmap_flag;
-        int *invalid_block_bitmap_flag;
-        int *invalid_inode_table_flag;
-        int invalid_bitmaps;    /* There are invalid bitmaps/itable */
-
-        /*
-         * Block buffer
-         */
-        char *block_buf;
-
-        /*
-         * For pass1_check_directory and pass1_get_blocks
-         */
-        ext2_ino_t stashed_ino;
-        struct ext2_inode *stashed_inode;
-
-        /*
-         * Location of the lost and found directory
-         */
-        ext2_ino_t lost_and_found;
-        int bad_lost_and_found;
-        
-        /*
-         * Directory information
-         */
-        int             dir_info_count;
-        int             dir_info_size;
-        struct dir_info *dir_info;
-
-        /*
-         * Indexed directory information
-         */
-        int             dx_dir_info_count;
-        int             dx_dir_info_size;
-        struct dx_dir_info *dx_dir_info;
-
-        /*
-         * Directories to hash
-         */
-        ext2_u32_list   dirs_to_hash;
-
-        /*
-         * Tuning parameters
-         */
-        int process_inode_size;
-        int inode_buffer_blocks;
-
-        /*
-         * ext3 journal support
-         */
-        io_channel      journal_io;
-        char    *journal_name;
-
-#ifdef RESOURCE_TRACK
-        /*
-         * For timing purposes
-         */
-        struct resource_track   global_rtrack;
-#endif
-
-        /*
-         * How we display the progress update (for unix)
-         */
-        int progress_fd;
-        int progress_pos;
-        int progress_last_percent;
-        unsigned int progress_last_time;
-        int interactive;        /* Are we connected directly to a tty? */
-        char start_meta[2], stop_meta[2];
-        
-        /* File counts */
-        int fs_directory_count;
-        int fs_regular_count;
-        int fs_blockdev_count;
-        int fs_chardev_count;
-        int fs_links_count;
-        int fs_symlinks_count;
-        int fs_fast_symlinks_count;
-        int fs_fifo_count;
-        int fs_total_count;
-        int fs_badblocks_count;
-        int fs_sockets_count;
-        int fs_ind_count;
-        int fs_dind_count;
-        int fs_tind_count;
-        int fs_fragmented;
-        int large_files;
-        int fs_ext_attr_inodes;
-        int fs_ext_attr_blocks;
-
-        int ext_attr_ver;
-
-        /*
-         * For the use of callers of the e2fsck functions; not used by
-         * e2fsck functions themselves.
-         */
-        void *priv_data;
-};
-
-/* Used by the region allocation code */
-typedef __u32 region_addr_t;
-typedef struct region_struct *region_t;
-
-#ifndef HAVE_STRNLEN
-#define strnlen(str, x) e2fsck_strnlen((str),(x))
-extern int e2fsck_strnlen(const char * s, int count);
-#endif
-
-/*
- * Procedure declarations
- */
-
-extern void e2fsck_pass1(e2fsck_t ctx);
-extern void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf);
-extern void e2fsck_pass2(e2fsck_t ctx);
-extern void e2fsck_pass3(e2fsck_t ctx);
-extern void e2fsck_pass4(e2fsck_t ctx);
-extern void e2fsck_pass5(e2fsck_t ctx);
-
-/* e2fsck.c */
-extern errcode_t e2fsck_allocate_context(e2fsck_t *ret);
-extern errcode_t e2fsck_reset_context(e2fsck_t ctx);
-extern void e2fsck_free_context(e2fsck_t ctx);
-extern int e2fsck_run(e2fsck_t ctx);
-
-
-/* badblock.c */
-extern void read_bad_blocks_file(e2fsck_t ctx, const char *bad_blocks_file,
-                                 int replace_bad_blocks);
-
-/* dirinfo.c */
-extern void e2fsck_add_dir_info(e2fsck_t ctx, ext2_ino_t ino, ext2_ino_t parent);
-extern struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino);
-extern void e2fsck_free_dir_info(e2fsck_t ctx);
-extern int e2fsck_get_num_dirinfo(e2fsck_t ctx);
-extern struct dir_info *e2fsck_dir_info_iter(e2fsck_t ctx, int *control);
-
-/* dx_dirinfo.c */
-extern void e2fsck_add_dx_dir(e2fsck_t ctx, ext2_ino_t ino, int num_blocks);
-extern struct dx_dir_info *e2fsck_get_dx_dir_info(e2fsck_t ctx, ext2_ino_t ino);
-extern void e2fsck_free_dx_dir_info(e2fsck_t ctx);
-extern int e2fsck_get_num_dx_dirinfo(e2fsck_t ctx);
-extern struct dx_dir_info *e2fsck_dx_dir_info_iter(e2fsck_t ctx, int *control);
-
-/* ea_refcount.c */
-extern errcode_t ea_refcount_create(int size, ext2_refcount_t *ret);
-extern void ea_refcount_free(ext2_refcount_t refcount);
-extern errcode_t ea_refcount_fetch(ext2_refcount_t refcount, blk_t blk,
-                                   int *ret);
-extern errcode_t ea_refcount_increment(ext2_refcount_t refcount,
-                                       blk_t blk, int *ret);
-extern errcode_t ea_refcount_decrement(ext2_refcount_t refcount,
-                                       blk_t blk, int *ret);
-extern errcode_t ea_refcount_store(ext2_refcount_t refcount,
-                                   blk_t blk, int count);
-extern blk_t ext2fs_get_refcount_size(ext2_refcount_t refcount);
-extern void ea_refcount_intr_begin(ext2_refcount_t refcount);
-extern blk_t ea_refcount_intr_next(ext2_refcount_t refcount, int *ret);
-
-/* ehandler.c */
-extern const char *ehandler_operation(const char *op);
-extern void ehandler_init(io_channel channel);
-
-/* journal.c */
-extern int e2fsck_check_ext3_journal(e2fsck_t ctx);
-extern int e2fsck_run_ext3_journal(e2fsck_t ctx);
-extern void e2fsck_move_ext3_journal(e2fsck_t ctx);
-
-/* pass1.c */
-extern void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool);
-extern int e2fsck_pass1_check_device_inode(ext2_filsys fs,
-                                           struct ext2_inode *inode);
-extern int e2fsck_pass1_check_symlink(ext2_filsys fs,
-                                      struct ext2_inode *inode, char *buf);
-
-/* pass2.c */
-extern int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir,
-                                    ext2_ino_t ino, char *buf);
-
-/* pass3.c */
-extern int e2fsck_reconnect_file(e2fsck_t ctx, ext2_ino_t inode);
-extern errcode_t e2fsck_expand_directory(e2fsck_t ctx, ext2_ino_t dir,
-                                         int num, int gauranteed_size);
-extern ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix);
-extern errcode_t e2fsck_adjust_inode_count(e2fsck_t ctx, ext2_ino_t ino, 
-                                           int adj);
-
-
-/* region.c */
-extern region_t region_create(region_addr_t min, region_addr_t max);
-extern void region_free(region_t region);
-extern int region_allocate(region_t region, region_addr_t start, int n);
-
-/* rehash.c */
-errcode_t e2fsck_rehash_dir(e2fsck_t ctx, ext2_ino_t ino);
-void e2fsck_rehash_directories(e2fsck_t ctx);
-
-/* super.c */
-void check_super_block(e2fsck_t ctx);
-errcode_t e2fsck_get_device_size(e2fsck_t ctx);
-
-/* swapfs.c */
-void swap_filesys(e2fsck_t ctx);
-
-/* util.c */
-extern void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size,
-                                    const char *description);
-extern int ask(e2fsck_t ctx, const char * string, int def);
-extern int ask_yn(const char * string, int def);
-extern void e2fsck_read_bitmaps(e2fsck_t ctx);
-extern void e2fsck_write_bitmaps(e2fsck_t ctx);
-extern void preenhalt(e2fsck_t ctx);
-extern char *string_copy(e2fsck_t ctx, const char *str, int len);
-#ifdef RESOURCE_TRACK
-extern void print_resource_track(const char *desc,
-                                 struct resource_track *track);
-extern void init_resource_track(struct resource_track *track);
-#endif
-extern int inode_has_valid_blocks(struct ext2_inode *inode);
-extern void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino,
-                              struct ext2_inode * inode, const char * proc);
-extern void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino,
-                               struct ext2_inode * inode, const char * proc);
-#ifdef MTRACE
-extern void mtrace_print(char *mesg);
-#endif
-extern blk_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs,
-                           const char *name, io_manager manager);
-extern int ext2_file_type(unsigned int mode);
-
-/* unix.c */
-extern void e2fsck_clear_progbar(e2fsck_t ctx);
-extern int e2fsck_simple_progress(e2fsck_t ctx, const char *label,
-                                  float percent, unsigned int dpynum);
diff --git a/e2fsprogs/e2fsck/ea_refcount.c b/e2fsprogs/e2fsck/ea_refcount.c
deleted file mode 100644
index 6420c7280..000000000
--- a/e2fsprogs/e2fsck/ea_refcount.c
+++ /dev/null
@@ -1,479 +0,0 @@
-/*
- * ea_refcount.c
- * 
- * Copyright (C) 2001 Theodore Ts'o.  This file may be
- * redistributed under the terms of the GNU Public License.
- */
-
-#if HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <string.h>
-#include <stdio.h>
-
-#include "e2fsck.h"
-
-/*
- * The strategy we use for keeping track of EA refcounts is as
- * follows.  We keep a sorted array of first EA blocks and its
- * reference counts.  Once the refcount has dropped to zero, it is
- * removed from the array to save memory space.  Once the EA block is
- * checked, its bit is set in the block_ea_map bitmap.  
- */
-struct ea_refcount_el {
-        blk_t   ea_blk;
-        int     ea_count;
-};
-
-struct ea_refcount {
-        blk_t           count;
-        blk_t           size;
-        blk_t           cursor;
-        struct ea_refcount_el   *list;
-};
-
-void ea_refcount_free(ext2_refcount_t refcount)
-{
-        if (!refcount)
-                return;
-
-        if (refcount->list)
-                ext2fs_free_mem(&refcount->list);
-        ext2fs_free_mem(&refcount);
-}
-
-errcode_t ea_refcount_create(int size, ext2_refcount_t *ret)
-{
-        ext2_refcount_t refcount;
-        errcode_t       retval;
-        size_t          bytes;
-
-        retval = ext2fs_get_mem(sizeof(struct ea_refcount), &refcount);
-        if (retval)
-                return retval;
-        memset(refcount, 0, sizeof(struct ea_refcount));
-
-        if (!size)
-                size = 500;
-        refcount->size = size;
-        bytes = (size_t) (size * sizeof(struct ea_refcount_el));
-#ifdef DEBUG
-        printf("Refcount allocated %d entries, %d bytes.\n",
-               refcount->size, bytes);
-#endif
-        retval = ext2fs_get_mem(bytes, &refcount->list);
-        if (retval)
-                goto errout;
-        memset(refcount->list, 0, bytes);
-
-        refcount->count = 0;
-        refcount->cursor = 0;
-
-        *ret = refcount;
-        return 0;
-
-errout:
-        ea_refcount_free(refcount);
-        return(retval);
-}
-
-/*
- * collapse_refcount() --- go through the refcount array, and get rid
- * of any count == zero entries
- */
-static void refcount_collapse(ext2_refcount_t refcount)
-{
-        unsigned int    i, j;
-        struct ea_refcount_el   *list;
-
-        list = refcount->list;
-        for (i = 0, j = 0; i < refcount->count; i++) {
-                if (list[i].ea_count) {
-                        if (i != j)
-                                list[j] = list[i];
-                        j++;
-                }
-        }
-#if defined(DEBUG) || defined(TEST_PROGRAM)
-        printf("Refcount_collapse: size was %d, now %d\n",
-               refcount->count, j);
-#endif
-        refcount->count = j;
-}
-
-
-/*
- * insert_refcount_el() --- Insert a new entry into the sorted list at a
- *      specified position.
- */
-static struct ea_refcount_el *insert_refcount_el(ext2_refcount_t refcount,
-                                                 blk_t blk, int pos)
-{
-        struct ea_refcount_el   *el;
-        errcode_t               retval;
-        blk_t                   new_size = 0;
-        int                     num;
-
-        if (refcount->count >= refcount->size) {
-                new_size = refcount->size + 100;
-#ifdef DEBUG
-                printf("Reallocating refcount %d entries...\n", new_size);
-#endif  
-                retval = ext2fs_resize_mem((size_t) refcount->size *
-                                           sizeof(struct ea_refcount_el),
-                                           (size_t) new_size *
-                                           sizeof(struct ea_refcount_el),
-                                           &refcount->list);
-                if (retval)
-                        return 0;
-                refcount->size = new_size;
-        }
-        num = (int) refcount->count - pos;
-        if (num < 0)
-                return 0;       /* should never happen */
-        if (num) {
-                memmove(&refcount->list[pos+1], &refcount->list[pos],
-                        sizeof(struct ea_refcount_el) * num);
-        }
-        refcount->count++;
-        el = &refcount->list[pos];
-        el->ea_count = 0;
-        el->ea_blk = blk;
-        return el;
-}
-
-
-/*
- * get_refcount_el() --- given an block number, try to find refcount
- *      information in the sorted list.  If the create flag is set,
- *      and we can't find an entry, create one in the sorted list.
- */
-static struct ea_refcount_el *get_refcount_el(ext2_refcount_t refcount,
-                                              blk_t blk, int create)
-{
-        float   range;
-        int     low, high, mid;
-        blk_t   lowval, highval;
-
-        if (!refcount || !refcount->list)
-                return 0;
-retry:
-        low = 0;
-        high = (int) refcount->count-1;
-        if (create && ((refcount->count == 0) ||
-                       (blk > refcount->list[high].ea_blk))) {
-                if (refcount->count >= refcount->size)
-                        refcount_collapse(refcount);
-
-                return insert_refcount_el(refcount, blk,
-                                          (unsigned) refcount->count);
-        }
-        if (refcount->count == 0)
-                return 0;
-        
-        if (refcount->cursor >= refcount->count)
-                refcount->cursor = 0;
-        if (blk == refcount->list[refcount->cursor].ea_blk)
-                return &refcount->list[refcount->cursor++];
-#ifdef DEBUG
-        printf("Non-cursor get_refcount_el: %u\n", blk);
-#endif
-        while (low <= high) {
-#if 0
-                mid = (low+high)/2;
-#else
-                if (low == high)
-                        mid = low;
-                else {
-                        /* Interpolate for efficiency */
-                        lowval = refcount->list[low].ea_blk;
-                        highval = refcount->list[high].ea_blk;
-
-                        if (blk < lowval)
-                                range = 0;
-                        else if (blk > highval)
-                                range = 1;
-                        else 
-                                range = ((float) (blk - lowval)) /
-                                        (highval - lowval);
-                        mid = low + ((int) (range * (high-low)));
-                }
-#endif
-                if (blk == refcount->list[mid].ea_blk) {
-                        refcount->cursor = mid+1;
-                        return &refcount->list[mid];
-                }
-                if (blk < refcount->list[mid].ea_blk)
-                        high = mid-1;
-                else
-                        low = mid+1;
-        }
-        /*
-         * If we need to create a new entry, it should be right at
-         * low (where high will be left at low-1).
-         */
-        if (create) {
-                if (refcount->count >= refcount->size) {
-                        refcount_collapse(refcount);
-                        if (refcount->count < refcount->size)
-                                goto retry;
-                }
-                return insert_refcount_el(refcount, blk, low);
-        }
-        return 0;
-}
-
-errcode_t ea_refcount_fetch(ext2_refcount_t refcount, blk_t blk,
-                                int *ret)
-{
-        struct ea_refcount_el   *el;
-        
-        el = get_refcount_el(refcount, blk, 0);
-        if (!el) {
-                *ret = 0;
-                return 0;
-        }
-        *ret = el->ea_count;
-        return 0;
-}
-
-errcode_t ea_refcount_increment(ext2_refcount_t refcount, blk_t blk, int *ret)
-{
-        struct ea_refcount_el   *el;
-
-        el = get_refcount_el(refcount, blk, 1);
-        if (!el)
-                return EXT2_ET_NO_MEMORY;
-        el->ea_count++;
-
-        if (ret)
-                *ret = el->ea_count;
-        return 0;
-}
-
-errcode_t ea_refcount_decrement(ext2_refcount_t refcount, blk_t blk, int *ret)
-{
-        struct ea_refcount_el   *el;
-
-        el = get_refcount_el(refcount, blk, 0);
-        if (!el || el->ea_count == 0)
-                return EXT2_ET_INVALID_ARGUMENT;
-
-        el->ea_count--;
-
-        if (ret)
-                *ret = el->ea_count;
-        return 0;
-}
-
-errcode_t ea_refcount_store(ext2_refcount_t refcount, blk_t blk, int count)
-{
-        struct ea_refcount_el   *el;
-
-        /*
-         * Get the refcount element
-         */
-        el = get_refcount_el(refcount, blk, count ? 1 : 0);
-        if (!el)
-                return count ? EXT2_ET_NO_MEMORY : 0;
-        el->ea_count = count;
-        return 0;
-}
-
-blk_t ext2fs_get_refcount_size(ext2_refcount_t refcount)
-{
-        if (!refcount)
-                return 0;
-
-        return refcount->size;
-}
-
-void ea_refcount_intr_begin(ext2_refcount_t refcount)
-{
-        refcount->cursor = 0;
-}
-
-
-blk_t ea_refcount_intr_next(ext2_refcount_t refcount,
-                                int *ret)
-{
-        struct ea_refcount_el   *list;
-        
-        while (1) {
-                if (refcount->cursor >= refcount->count)
-                        return 0;
-                list = refcount->list;
-                if (list[refcount->cursor].ea_count) {
-                        if (ret)
-                                *ret = list[refcount->cursor].ea_count;
-                        return list[refcount->cursor++].ea_blk;
-                }
-                refcount->cursor++;
-        }
-}
-
-
-#ifdef TEST_PROGRAM
-
-errcode_t ea_refcount_validate(ext2_refcount_t refcount, FILE *out)
-{
-        errcode_t       ret = 0;
-        int             i;
-        const char *bad = "bad refcount";
-        
-        if (refcount->count > refcount->size) {
-                fprintf(out, "%s: count > size\n", bad);
-                return EXT2_ET_INVALID_ARGUMENT;
-        }
-        for (i=1; i < refcount->count; i++) {
-                if (refcount->list[i-1].ea_blk >= refcount->list[i].ea_blk) {
-                        fprintf(out, "%s: list[%d].blk=%u, list[%d].blk=%u\n",
-                                bad, i-1, refcount->list[i-1].ea_blk,
-                                i, refcount->list[i].ea_blk);
-                        ret = EXT2_ET_INVALID_ARGUMENT;
-                }
-        }
-        return ret;
-}
-
-#define BCODE_END       0
-#define BCODE_CREATE    1
-#define BCODE_FREE      2
-#define BCODE_STORE     3
-#define BCODE_INCR      4
-#define BCODE_DECR      5
-#define BCODE_FETCH     6
-#define BCODE_VALIDATE  7
-#define BCODE_LIST      8
-#define BCODE_COLLAPSE 9
-
-int bcode_program[] = {
-        BCODE_CREATE, 5,
-        BCODE_STORE, 3, 3,
-        BCODE_STORE, 4, 4,
-        BCODE_STORE, 1, 1,
-        BCODE_STORE, 8, 8,
-        BCODE_STORE, 2, 2,
-        BCODE_STORE, 4, 0,
-        BCODE_STORE, 2, 0,
-        BCODE_STORE, 6, 6,
-        BCODE_VALIDATE,
-        BCODE_STORE, 4, 4,
-        BCODE_STORE, 2, 2,
-        BCODE_FETCH, 1,
-        BCODE_FETCH, 2,
-        BCODE_INCR, 3,
-        BCODE_INCR, 3,
-        BCODE_DECR, 4,
-        BCODE_STORE, 4, 4,
-        BCODE_VALIDATE,
-        BCODE_STORE, 20, 20,
-        BCODE_STORE, 40, 40,
-        BCODE_STORE, 30, 30,
-        BCODE_STORE, 10, 10,
-        BCODE_DECR, 30,
-        BCODE_FETCH, 30,
-        BCODE_DECR, 2,
-        BCODE_DECR, 2,
-        BCODE_COLLAPSE,
-        BCODE_LIST,
-        BCODE_VALIDATE,
-        BCODE_FREE,
-        BCODE_END
-};
-
-int main(int argc, char **argv)
-{
-        int     i = 0;
-        ext2_refcount_t refcount;
-        int             size, arg;
-        blk_t           blk;
-        errcode_t       retval;
-
-        while (1) {
-                switch (bcode_program[i++]) {
-                case BCODE_END:
-                        exit(0);
-                case BCODE_CREATE:
-                        size = bcode_program[i++];
-                        retval = ea_refcount_create(size, &refcount);
-                        if (retval) {
-                                com_err("ea_refcount_create",
-                                        retval, "");
-                                exit(1);
-                        } else
-                                printf("Creating refcount with size %d\n",
-                                       size);
-                        break;
-                case BCODE_FREE:
-                        ea_refcount_free(refcount);
-                        refcount = 0;
-                        printf("Freeing refcount\n");
-                        break;
-                case BCODE_STORE:
-                        blk = (blk_t) bcode_program[i++];
-                        arg = bcode_program[i++];
-                        retval = ea_refcount_store(refcount, blk, arg);
-                        printf("Storing blk %u with value %d\n", blk, arg);
-                        if (retval)
-                                com_err("ea_refcount_store", retval, "");
-                        break;
-                case BCODE_FETCH:
-                        blk = (blk_t) bcode_program[i++];
-                        retval = ea_refcount_fetch(refcount, blk, &arg);
-                        if (retval)
-                                com_err("ea_refcount_fetch", retval, "");
-                        else
-                                printf("bcode_fetch(%u) returns %d\n",
-                                       blk, arg);
-                        break;
-                case BCODE_INCR:
-                        blk = (blk_t) bcode_program[i++];
-                        retval = ea_refcount_increment(refcount, blk,
-                                                           &arg);
-                        if (retval)
-                                com_err("ea_refcount_increment", retval,
-                                        "");
-                        else
-                                printf("bcode_increment(%u) returns %d\n",
-                                       blk, arg);
-                        break;
-                case BCODE_DECR:
-                        blk = (blk_t) bcode_program[i++];
-                        retval = ea_refcount_decrement(refcount, blk,
-                                                           &arg);
-                        if (retval)
-                                com_err("ea_refcount_decrement", retval,
-                                        "while decrementing blk %u", blk);
-                        else
-                                printf("bcode_decrement(%u) returns %d\n",
-                                       blk, arg);
-                        break;
-                case BCODE_VALIDATE:
-                        retval = ea_refcount_validate(refcount, stderr);
-                        if (retval)
-                                com_err("ea_refcount_validate",
-                                        retval, "");
-                        else
-                                printf("Refcount validation OK.\n");
-                        break;
-                case BCODE_LIST:
-                        ea_refcount_intr_begin(refcount);
-                        while (1) {
-                                blk = ea_refcount_intr_next(refcount, 
-                                                                &arg);
-                                if (!blk)
-                                        break;
-                                printf("\tblk=%u, count=%d\n", blk,
-                                       arg);
-                        }
-                        break;
-                case BCODE_COLLAPSE:
-                        refcount_collapse(refcount);
-                        break;
-                }
-                
-        }
-}
-
-#endif
diff --git a/e2fsprogs/e2fsck/ehandler.c b/e2fsprogs/e2fsck/ehandler.c
deleted file mode 100644
index 16d6d4fa0..000000000
--- a/e2fsprogs/e2fsck/ehandler.c
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * ehandler.c --- handle bad block errors which come up during the
- *      course of an e2fsck session.
- * 
- * Copyright (C) 1994 Theodore Ts'o.  This file may be redistributed
- * under the terms of the GNU Public License.
- */
-
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <ctype.h>
-#include <termios.h>
-
-#include "e2fsck.h"
-
-#include <sys/time.h>
-#include <sys/resource.h>
-
-static const char *operation;
-
-static errcode_t e2fsck_handle_read_error(io_channel channel,
-                                          unsigned long block,
-                                          int count,
-                                          void *data,
-                                          size_t size EXT2FS_ATTR((unused)),
-                                          int actual EXT2FS_ATTR((unused)),
-                                          errcode_t error)
-{
-        int     i;
-        char    *p;
-        ext2_filsys fs = (ext2_filsys) channel->app_data;
-        e2fsck_t ctx;
-
-        ctx = (e2fsck_t) fs->priv_data;
-
-        /*
-         * If more than one block was read, try reading each block
-         * separately.  We could use the actual bytes read to figure
-         * out where to start, but we don't bother.
-         */
-        if (count > 1) {
-                p = (char *) data;
-                for (i=0; i < count; i++, p += channel->block_size, block++) {
-                        error = io_channel_read_blk(channel, block,
-                                                    1, p);
-                        if (error)
-                                return error;
-                }
-                return 0;
-        }
-        if (operation)
-                printf(_("Error reading block %lu (%s) while %s.  "), block,
-                       error_message(error), operation);
-        else
-                printf(_("Error reading block %lu (%s).  "), block,
-                       error_message(error));
-        preenhalt(ctx);
-        if (ask(ctx, _("Ignore error"), 1)) {
-                if (ask(ctx, _("Force rewrite"), 1))
-                        io_channel_write_blk(channel, block, 1, data);
-                return 0;
-        }
-
-        return error;
-}
-
-static errcode_t e2fsck_handle_write_error(io_channel channel,
-                                            unsigned long block,
-                                            int count,
-                                            const void *data,
-                                            size_t size EXT2FS_ATTR((unused)),
-                                            int actual EXT2FS_ATTR((unused)),
-                                            errcode_t error)
-{
-        int             i;
-        const char      *p;
-        ext2_filsys fs = (ext2_filsys) channel->app_data;
-        e2fsck_t ctx;
-        
-        ctx = (e2fsck_t) fs->priv_data;
-
-        /*
-         * If more than one block was written, try writing each block
-         * separately.  We could use the actual bytes read to figure
-         * out where to start, but we don't bother.
-         */
-        if (count > 1) {
-                p = (const char *) data;
-                for (i=0; i < count; i++, p += channel->block_size, block++) {
-                        error = io_channel_write_blk(channel, block,
-                                                     1, p);
-                        if (error)
-                                return error;
-                }
-                return 0;
-        }
-        
-        if (operation)
-                printf(_("Error writing block %lu (%s) while %s.  "), block,
-                       error_message(error), operation);
-        else
-                printf(_("Error writing block %lu (%s).  "), block,
-                       error_message(error));
-        preenhalt(ctx);
-        if (ask(ctx, _("Ignore error"), 1))
-                return 0;
-
-        return error;
-}
-
-const char *ehandler_operation(const char *op)
-{
-        const char *ret = operation;
-
-        operation = op;
-        return ret;
-}
-
-void ehandler_init(io_channel channel)
-{
-        channel->read_error = e2fsck_handle_read_error;
-        channel->write_error = e2fsck_handle_write_error;
-}
diff --git a/e2fsprogs/e2fsck/jfs_user.h b/e2fsprogs/e2fsck/jfs_user.h
deleted file mode 100644
index c38def3e5..000000000
--- a/e2fsprogs/e2fsck/jfs_user.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * Compatibility header file for e2fsck which should be included
- * instead of linux/jfs.h
- *
- * Copyright (C) 2000 Stephen C. Tweedie
- *
- * This file may be redistributed under the terms of the
- * GNU General Public License version 2 or at your discretion
- * any later version.
- */
-
-/*
- * Pull in the definition of the e2fsck context structure
- */
-#include "e2fsck.h"
-
-struct buffer_head {
-        char            b_data[8192];
-        e2fsck_t        b_ctx;
-        io_channel      b_io;
-        int             b_size;
-        blk_t           b_blocknr;
-        int             b_dirty;
-        int             b_uptodate;
-        int             b_err;
-};
-
-struct inode {
-        e2fsck_t        i_ctx;
-        ext2_ino_t      i_ino;
-        struct ext2_inode i_ext2;
-};
-
-struct kdev_s {
-        e2fsck_t        k_ctx;
-        int             k_dev;
-};
-
-#define K_DEV_FS        1
-#define K_DEV_JOURNAL   2
-
-typedef struct kdev_s *kdev_t;
-
-#define lock_buffer(bh) do {} while(0)
-#define unlock_buffer(bh) do {} while(0)
-#define buffer_req(bh) 1
-#define do_readahead(journal, start) do {} while(0)
-        
-extern e2fsck_t e2fsck_global_ctx;  /* Try your very best not to use this! */
-
-typedef struct {
-        int     object_length;
-} kmem_cache_t;
-
-#define kmem_cache_alloc(cache,flags) malloc((cache)->object_length)
-#define kmem_cache_free(cache,obj) free(obj)
-#define kmem_cache_create(name,len,a,b,c,d) do_cache_create(len)
-#define kmem_cache_destroy(cache) do_cache_destroy(cache)
-#define kmalloc(len,flags) malloc(len)
-#define kfree(p) free(p)
-
-/*
- * We use the standard libext2fs portability tricks for inline
- * functions.  
- */
-extern kmem_cache_t * do_cache_create(int len);
-extern void do_cache_destroy(kmem_cache_t *cache);
-        
-#if (defined(E2FSCK_INCLUDE_INLINE_FUNCS) || !defined(NO_INLINE_FUNCS))
-#ifdef E2FSCK_INCLUDE_INLINE_FUNCS
-#define _INLINE_ extern
-#else
-#ifdef __GNUC__
-#define _INLINE_ extern __inline__
-#else                           /* For Watcom C */
-#define _INLINE_ extern inline
-#endif
-#endif
-
-_INLINE_ kmem_cache_t * do_cache_create(int len)
-{
-        kmem_cache_t *new_cache;
-        new_cache = malloc(sizeof(*new_cache));
-        if (new_cache)
-                new_cache->object_length = len;
-        return new_cache;
-}
-
-_INLINE_ void do_cache_destroy(kmem_cache_t *cache)
-{
-        free(cache);
-}
-#undef _INLINE_
-#endif
-
-#define __init
-
-/*
- * Now pull in the real linux/jfs.h definitions.
- */
-#include <ext2fs/kernel-jbd.h>
-
-/*
- * Kernel compatibility functions are defined in journal.c
- */
-int journal_bmap(journal_t *journal, blk_t block, unsigned long *phys);
-struct buffer_head *getblk(kdev_t ctx, blk_t blocknr, int blocksize);
-void sync_blockdev(kdev_t kdev);
-void ll_rw_block(int rw, int dummy, struct buffer_head *bh[]);
-void mark_buffer_dirty(struct buffer_head *bh);
-void mark_buffer_uptodate(struct buffer_head *bh, int val);
-void brelse(struct buffer_head *bh);
-int buffer_uptodate(struct buffer_head *bh);
-void wait_on_buffer(struct buffer_head *bh);
-
-/*
- * Define newer 2.5 interfaces
- */
-#define __getblk(dev, blocknr, blocksize) getblk(dev, blocknr, blocksize)
-#define set_buffer_uptodate(bh) mark_buffer_uptodate(bh, 1)
diff --git a/e2fsprogs/e2fsck/journal.c b/e2fsprogs/e2fsck/journal.c
deleted file mode 100644
index 14e774d50..000000000
--- a/e2fsprogs/e2fsck/journal.c
+++ /dev/null
@@ -1,960 +0,0 @@
-/*
- * journal.c --- code for handling the "ext3" journal
- *
- * Copyright (C) 2000 Andreas Dilger
- * Copyright (C) 2000 Theodore Ts'o
- *
- * Parts of the code are based on fs/jfs/journal.c by Stephen C. Tweedie
- * Copyright (C) 1999 Red Hat Software
- *
- * This file may be redistributed under the terms of the
- * GNU General Public License version 2 or at your discretion
- * any later version.
- */
-
-#ifdef HAVE_SYS_MOUNT_H
-#include <sys/param.h>
-#include <sys/mount.h>
-#define MNT_FL (MS_MGC_VAL | MS_RDONLY)
-#endif
-#ifdef HAVE_SYS_STAT_H
-#include <sys/stat.h>
-#endif
-
-#define E2FSCK_INCLUDE_INLINE_FUNCS
-#include "jfs_user.h"
-#include "problem.h"
-#include "uuid/uuid.h"
-
-#ifdef __CONFIG_JBD_DEBUG__E2FS         /* Enabled by configure --enable-jfs-debug */
-static int bh_count = 0;
-#endif
-
-/*
- * Define USE_INODE_IO to use the inode_io.c / fileio.c codepaths.
- * This creates a larger static binary, and a smaller binary using
- * shared libraries.  It's also probably slightly less CPU-efficient,
- * which is why it's not on by default.  But, it's a good way of
- * testing the functions in inode_io.c and fileio.c.
- */
-#undef USE_INODE_IO
-
-/* Kernel compatibility functions for handling the journal.  These allow us
- * to use the recovery.c file virtually unchanged from the kernel, so we
- * don't have to do much to keep kernel and user recovery in sync.
- */
-int journal_bmap(journal_t *journal, blk_t block, unsigned long *phys)
-{
-#ifdef USE_INODE_IO
-        *phys = block;
-        return 0;
-#else
-        struct inode    *inode = journal->j_inode;
-        errcode_t       retval;
-        blk_t           pblk;
-
-        if (!inode) {
-                *phys = block;
-                return 0;
-        }
-
-        retval= ext2fs_bmap(inode->i_ctx->fs, inode->i_ino, 
-                            &inode->i_ext2, NULL, 0, block, &pblk);
-        *phys = pblk;
-        return (retval);
-#endif
-}
-
-struct buffer_head *getblk(kdev_t kdev, blk_t blocknr, int blocksize)
-{
-        struct buffer_head *bh;
-
-        bh = e2fsck_allocate_memory(kdev->k_ctx, sizeof(*bh), "block buffer");
-        if (!bh)
-                return NULL;
-
-        jfs_debug(4, "getblk for block %lu (%d bytes)(total %d)\n",
-                  (unsigned long) blocknr, blocksize, ++bh_count);
-
-        bh->b_ctx = kdev->k_ctx;
-        if (kdev->k_dev == K_DEV_FS)
-                bh->b_io = kdev->k_ctx->fs->io;
-        else 
-                bh->b_io = kdev->k_ctx->journal_io;
-        bh->b_size = blocksize;
-        bh->b_blocknr = blocknr;
-
-        return bh;
-}
-
-void sync_blockdev(kdev_t kdev)
-{
-        io_channel      io;
-
-        if (kdev->k_dev == K_DEV_FS)
-                io = kdev->k_ctx->fs->io;
-        else 
-                io = kdev->k_ctx->journal_io;
-
-        io_channel_flush(io);
-}
-
-void ll_rw_block(int rw, int nr, struct buffer_head *bhp[])
-{
-        int retval;
-        struct buffer_head *bh;
-
-        for (; nr > 0; --nr) {
-                bh = *bhp++;
-                if (rw == READ && !bh->b_uptodate) {
-                        jfs_debug(3, "reading block %lu/%p\n", 
-                                  (unsigned long) bh->b_blocknr, (void *) bh);
-                        retval = io_channel_read_blk(bh->b_io, 
-                                                     bh->b_blocknr,
-                                                     1, bh->b_data);
-                        if (retval) {
-                                com_err(bh->b_ctx->device_name, retval,
-                                        "while reading block %lu\n", 
-                                        (unsigned long) bh->b_blocknr);
-                                bh->b_err = retval;
-                                continue;
-                        }
-                        bh->b_uptodate = 1;
-                } else if (rw == WRITE && bh->b_dirty) {
-                        jfs_debug(3, "writing block %lu/%p\n", 
-                                  (unsigned long) bh->b_blocknr, (void *) bh);
-                        retval = io_channel_write_blk(bh->b_io, 
-                                                      bh->b_blocknr,
-                                                      1, bh->b_data);
-                        if (retval) {
-                                com_err(bh->b_ctx->device_name, retval,
-                                        "while writing block %lu\n", 
-                                        (unsigned long) bh->b_blocknr);
-                                bh->b_err = retval;
-                                continue;
-                        }
-                        bh->b_dirty = 0;
-                        bh->b_uptodate = 1;
-                } else {
-                        jfs_debug(3, "no-op %s for block %lu\n",
-                                  rw == READ ? "read" : "write", 
-                                  (unsigned long) bh->b_blocknr);
-                }
-        }
-}
-
-void mark_buffer_dirty(struct buffer_head *bh)
-{
-        bh->b_dirty = 1;
-}
-
-static void mark_buffer_clean(struct buffer_head * bh)
-{
-        bh->b_dirty = 0;
-}
-
-void brelse(struct buffer_head *bh)
-{
-        if (bh->b_dirty)
-                ll_rw_block(WRITE, 1, &bh);
-        jfs_debug(3, "freeing block %lu/%p (total %d)\n",
-                  (unsigned long) bh->b_blocknr, (void *) bh, --bh_count);
-        ext2fs_free_mem(&bh);
-}
-
-int buffer_uptodate(struct buffer_head *bh)
-{
-        return bh->b_uptodate;
-}
-
-void mark_buffer_uptodate(struct buffer_head *bh, int val)
-{
-        bh->b_uptodate = val;
-}
-
-void wait_on_buffer(struct buffer_head *bh)
-{
-        if (!bh->b_uptodate)
-                ll_rw_block(READ, 1, &bh);
-}
-
-
-static void e2fsck_clear_recover(e2fsck_t ctx, int error)
-{
-        ctx->fs->super->s_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
-
-        /* if we had an error doing journal recovery, we need a full fsck */
-        if (error)
-                ctx->fs->super->s_state &= ~EXT2_VALID_FS;
-        ext2fs_mark_super_dirty(ctx->fs);
-}
-
-static errcode_t e2fsck_get_journal(e2fsck_t ctx, journal_t **ret_journal)
-{
-        struct ext2_super_block *sb = ctx->fs->super;
-        struct ext2_super_block jsuper;
-        struct problem_context  pctx;
-        struct buffer_head      *bh;
-        struct inode            *j_inode = NULL;
-        struct kdev_s           *dev_fs = NULL, *dev_journal;
-        const char              *journal_name = 0;
-        journal_t               *journal = NULL;
-        errcode_t               retval = 0;
-        io_manager              io_ptr = 0;
-        unsigned long           start = 0;
-        blk_t                   blk;
-        int                     ext_journal = 0;
-        int                     tried_backup_jnl = 0;
-        int                     i;
-                
-        clear_problem_context(&pctx);
-        
-        journal = e2fsck_allocate_memory(ctx, sizeof(journal_t), "journal");
-        if (!journal) {
-                return EXT2_ET_NO_MEMORY;
-        }
-
-        dev_fs = e2fsck_allocate_memory(ctx, 2*sizeof(struct kdev_s), "kdev");
-        if (!dev_fs) {
-                retval = EXT2_ET_NO_MEMORY;
-                goto errout;
-        }
-        dev_journal = dev_fs+1;
-        
-        dev_fs->k_ctx = dev_journal->k_ctx = ctx;
-        dev_fs->k_dev = K_DEV_FS;
-        dev_journal->k_dev = K_DEV_JOURNAL;
-        
-        journal->j_dev = dev_journal;
-        journal->j_fs_dev = dev_fs;
-        journal->j_inode = NULL;
-        journal->j_blocksize = ctx->fs->blocksize;
-
-        if (uuid_is_null(sb->s_journal_uuid)) {
-                if (!sb->s_journal_inum)
-                        return EXT2_ET_BAD_INODE_NUM;
-                j_inode = e2fsck_allocate_memory(ctx, sizeof(*j_inode),
-                                                 "journal inode");
-                if (!j_inode) {
-                        retval = EXT2_ET_NO_MEMORY;
-                        goto errout;
-                }
-
-                j_inode->i_ctx = ctx;
-                j_inode->i_ino = sb->s_journal_inum;
-                
-                if ((retval = ext2fs_read_inode(ctx->fs,
-                                                sb->s_journal_inum,
-                                                &j_inode->i_ext2))) {
-                try_backup_journal:
-                        if (sb->s_jnl_backup_type != EXT3_JNL_BACKUP_BLOCKS ||
-                            tried_backup_jnl)
-                                goto errout;
-                        memset(&j_inode->i_ext2, 0, sizeof(struct ext2_inode));
-                        memcpy(&j_inode->i_ext2.i_block[0], sb->s_jnl_blocks, 
-                               EXT2_N_BLOCKS*4);
-                        j_inode->i_ext2.i_size = sb->s_jnl_blocks[16];
-                        j_inode->i_ext2.i_links_count = 1;
-                        j_inode->i_ext2.i_mode = LINUX_S_IFREG | 0600;
-                        tried_backup_jnl++;
-                }
-                if (!j_inode->i_ext2.i_links_count ||
-                    !LINUX_S_ISREG(j_inode->i_ext2.i_mode)) {
-                        retval = EXT2_ET_NO_JOURNAL;
-                        goto try_backup_journal;
-                }
-                if (j_inode->i_ext2.i_size / journal->j_blocksize <
-                    JFS_MIN_JOURNAL_BLOCKS) {
-                        retval = EXT2_ET_JOURNAL_TOO_SMALL;
-                        goto try_backup_journal;
-                }
-                for (i=0; i < EXT2_N_BLOCKS; i++) {
-                        blk = j_inode->i_ext2.i_block[i];
-                        if (!blk) {
-                                if (i < EXT2_NDIR_BLOCKS) {
-                                        retval = EXT2_ET_JOURNAL_TOO_SMALL;
-                                        goto try_backup_journal;
-                                }
-                                continue;
-                        }
-                        if (blk < sb->s_first_data_block ||
-                            blk >= sb->s_blocks_count) {
-                                retval = EXT2_ET_BAD_BLOCK_NUM;
-                                goto try_backup_journal;
-                        }
-                }
-                journal->j_maxlen = j_inode->i_ext2.i_size / journal->j_blocksize;
-
-#ifdef USE_INODE_IO
-                retval = ext2fs_inode_io_intern2(ctx->fs, sb->s_journal_inum,
-                                                 &j_inode->i_ext2,
-                                                 &journal_name);
-                if (retval)
-                        goto errout;
-
-                io_ptr = inode_io_manager;
-#else
-                journal->j_inode = j_inode;
-                ctx->journal_io = ctx->fs->io;
-                if ((retval = journal_bmap(journal, 0, &start)) != 0)
-                        goto errout;
-#endif
-        } else {
-                ext_journal = 1;
-                if (!ctx->journal_name) {
-                        char uuid[37];
-
-                        uuid_unparse(sb->s_journal_uuid, uuid);
-                        ctx->journal_name = blkid_get_devname(ctx->blkid,
-                                                              "UUID", uuid);
-                        if (!ctx->journal_name)
-                                ctx->journal_name = blkid_devno_to_devname(sb->s_journal_dev);
-                }
-                journal_name = ctx->journal_name;
-                        
-                if (!journal_name) {
-                        fix_problem(ctx, PR_0_CANT_FIND_JOURNAL, &pctx);
-                        return EXT2_ET_LOAD_EXT_JOURNAL;
-                }
-                
-                jfs_debug(1, "Using journal file %s\n", journal_name);
-                io_ptr = unix_io_manager;
-        }
-
-#if 0
-        test_io_backing_manager = io_ptr;
-        io_ptr = test_io_manager;
-#endif
-#ifndef USE_INODE_IO
-        if (ext_journal)
-#endif
-                retval = io_ptr->open(journal_name, IO_FLAG_RW,
-                                      &ctx->journal_io);
-        if (retval)
-                goto errout;
-
-        io_channel_set_blksize(ctx->journal_io, ctx->fs->blocksize);
-
-        if (ext_journal) {
-                if (ctx->fs->blocksize == 1024)
-                        start = 1;
-                bh = getblk(dev_journal, start, ctx->fs->blocksize);
-                if (!bh) {
-                        retval = EXT2_ET_NO_MEMORY;
-                        goto errout;
-                }
-                ll_rw_block(READ, 1, &bh);
-                if ((retval = bh->b_err) != 0)
-                        goto errout;
-                memcpy(&jsuper, start ? bh->b_data :  bh->b_data + 1024,
-                       sizeof(jsuper));
-                brelse(bh);
-#ifdef EXT2FS_ENABLE_SWAPFS
-                if (jsuper.s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC)) 
-                        ext2fs_swap_super(&jsuper);
-#endif
-                if (jsuper.s_magic != EXT2_SUPER_MAGIC ||
-                    !(jsuper.s_feature_incompat & EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
-                        fix_problem(ctx, PR_0_EXT_JOURNAL_BAD_SUPER, &pctx);
-                        retval = EXT2_ET_LOAD_EXT_JOURNAL;
-                        goto errout;
-                }
-                /* Make sure the journal UUID is correct */
-                if (memcmp(jsuper.s_uuid, ctx->fs->super->s_journal_uuid,
-                           sizeof(jsuper.s_uuid))) {
-                        fix_problem(ctx, PR_0_JOURNAL_BAD_UUID, &pctx);
-                        retval = EXT2_ET_LOAD_EXT_JOURNAL;
-                        goto errout;
-                }
-                
-                journal->j_maxlen = jsuper.s_blocks_count;
-                start++;
-        }
-
-        if (!(bh = getblk(dev_journal, start, journal->j_blocksize))) {
-                retval = EXT2_ET_NO_MEMORY;
-                goto errout;
-        }
-        
-        journal->j_sb_buffer = bh;
-        journal->j_superblock = (journal_superblock_t *)bh->b_data;
-        
-#ifdef USE_INODE_IO
-        if (j_inode)
-                ext2fs_free_mem(&j_inode);
-#endif
-
-        *ret_journal = journal;
-        return 0;
-
-errout:
-        if (dev_fs)
-                ext2fs_free_mem(&dev_fs);
-        if (j_inode)
-                ext2fs_free_mem(&j_inode);
-        if (journal)
-                ext2fs_free_mem(&journal);
-        return retval;
-        
-}
-
-static errcode_t e2fsck_journal_fix_bad_inode(e2fsck_t ctx,
-                                              struct problem_context *pctx)
-{
-        struct ext2_super_block *sb = ctx->fs->super;
-        int recover = ctx->fs->super->s_feature_incompat &
-                EXT3_FEATURE_INCOMPAT_RECOVER;
-        int has_journal = ctx->fs->super->s_feature_compat &
-                EXT3_FEATURE_COMPAT_HAS_JOURNAL;
-
-        if (has_journal || sb->s_journal_inum) {
-                /* The journal inode is bogus, remove and force full fsck */
-                pctx->ino = sb->s_journal_inum;
-                if (fix_problem(ctx, PR_0_JOURNAL_BAD_INODE, pctx)) {
-                        if (has_journal && sb->s_journal_inum)
-                                printf("*** ext3 journal has been deleted - "
-                                       "filesystem is now ext2 only ***\n\n");
-                        sb->s_feature_compat &= ~EXT3_FEATURE_COMPAT_HAS_JOURNAL;
-                        sb->s_journal_inum = 0;
-                        ctx->flags |= E2F_FLAG_JOURNAL_INODE; /* FIXME: todo */
-                        e2fsck_clear_recover(ctx, 1);
-                        return 0;
-                }
-                return EXT2_ET_BAD_INODE_NUM;
-        } else if (recover) {
-                if (fix_problem(ctx, PR_0_JOURNAL_RECOVER_SET, pctx)) {
-                        e2fsck_clear_recover(ctx, 1);
-                        return 0;
-                }
-                return EXT2_ET_UNSUPP_FEATURE;
-        }
-        return 0;
-}
-
-#define V1_SB_SIZE      0x0024
-static void clear_v2_journal_fields(journal_t *journal)
-{
-        e2fsck_t ctx = journal->j_dev->k_ctx;
-        struct problem_context pctx;
-
-        clear_problem_context(&pctx);
-
-        if (!fix_problem(ctx, PR_0_CLEAR_V2_JOURNAL, &pctx))
-                return;
-
-        memset(((char *) journal->j_superblock) + V1_SB_SIZE, 0,
-               ctx->fs->blocksize-V1_SB_SIZE);
-        mark_buffer_dirty(journal->j_sb_buffer);
-}
-
-
-static errcode_t e2fsck_journal_load(journal_t *journal)
-{
-        e2fsck_t ctx = journal->j_dev->k_ctx;
-        journal_superblock_t *jsb;
-        struct buffer_head *jbh = journal->j_sb_buffer;
-        struct problem_context pctx;
-
-        clear_problem_context(&pctx);
-
-        ll_rw_block(READ, 1, &jbh);
-        if (jbh->b_err) {
-                com_err(ctx->device_name, jbh->b_err,
-                        _("reading journal superblock\n"));
-                return jbh->b_err;
-        }
-
-        jsb = journal->j_superblock;
-        /* If we don't even have JFS_MAGIC, we probably have a wrong inode */
-        if (jsb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER))
-                return e2fsck_journal_fix_bad_inode(ctx, &pctx);
-
-        switch (ntohl(jsb->s_header.h_blocktype)) {
-        case JFS_SUPERBLOCK_V1:
-                journal->j_format_version = 1;
-                if (jsb->s_feature_compat ||
-                    jsb->s_feature_incompat ||
-                    jsb->s_feature_ro_compat ||
-                    jsb->s_nr_users)
-                        clear_v2_journal_fields(journal);
-                break;
-                
-        case JFS_SUPERBLOCK_V2:
-                journal->j_format_version = 2;
-                if (ntohl(jsb->s_nr_users) > 1 &&
-                    uuid_is_null(ctx->fs->super->s_journal_uuid))
-                        clear_v2_journal_fields(journal);
-                if (ntohl(jsb->s_nr_users) > 1) {
-                        fix_problem(ctx, PR_0_JOURNAL_UNSUPP_MULTIFS, &pctx);
-                        return EXT2_ET_JOURNAL_UNSUPP_VERSION;
-                }
-                break;
-
-        /*
-         * These should never appear in a journal super block, so if
-         * they do, the journal is badly corrupted.
-         */
-        case JFS_DESCRIPTOR_BLOCK:
-        case JFS_COMMIT_BLOCK:
-        case JFS_REVOKE_BLOCK:
-                return EXT2_ET_CORRUPT_SUPERBLOCK;
-                
-        /* If we don't understand the superblock major type, but there
-         * is a magic number, then it is likely to be a new format we
-         * just don't understand, so leave it alone. */
-        default:
-                return EXT2_ET_JOURNAL_UNSUPP_VERSION;
-        }
-
-        if (JFS_HAS_INCOMPAT_FEATURE(journal, ~JFS_KNOWN_INCOMPAT_FEATURES))
-                return EXT2_ET_UNSUPP_FEATURE;
-        
-        if (JFS_HAS_RO_COMPAT_FEATURE(journal, ~JFS_KNOWN_ROCOMPAT_FEATURES))
-                return EXT2_ET_RO_UNSUPP_FEATURE;
-
-        /* We have now checked whether we know enough about the journal
-         * format to be able to proceed safely, so any other checks that
-         * fail we should attempt to recover from. */
-        if (jsb->s_blocksize != htonl(journal->j_blocksize)) {
-                com_err(ctx->program_name, EXT2_ET_CORRUPT_SUPERBLOCK,
-                        _("%s: no valid journal superblock found\n"),
-                        ctx->device_name);
-                return EXT2_ET_CORRUPT_SUPERBLOCK;
-        }
-
-        if (ntohl(jsb->s_maxlen) < journal->j_maxlen)
-                journal->j_maxlen = ntohl(jsb->s_maxlen);
-        else if (ntohl(jsb->s_maxlen) > journal->j_maxlen) {
-                com_err(ctx->program_name, EXT2_ET_CORRUPT_SUPERBLOCK,
-                        _("%s: journal too short\n"),
-                        ctx->device_name);
-                return EXT2_ET_CORRUPT_SUPERBLOCK;
-        }
-
-        journal->j_tail_sequence = ntohl(jsb->s_sequence);
-        journal->j_transaction_sequence = journal->j_tail_sequence;
-        journal->j_tail = ntohl(jsb->s_start);
-        journal->j_first = ntohl(jsb->s_first);
-        journal->j_last = ntohl(jsb->s_maxlen);
-
-        return 0;
-}
-
-static void e2fsck_journal_reset_super(e2fsck_t ctx, journal_superblock_t *jsb,
-                                       journal_t *journal)
-{
-        char *p;
-        union {
-                uuid_t uuid;
-                __u32 val[4];
-        } u;
-        __u32 new_seq = 0;
-        int i;
-
-        /* Leave a valid existing V1 superblock signature alone.
-         * Anything unrecognisable we overwrite with a new V2
-         * signature. */
-        
-        if (jsb->s_header.h_magic != htonl(JFS_MAGIC_NUMBER) ||
-            jsb->s_header.h_blocktype != htonl(JFS_SUPERBLOCK_V1)) {
-                jsb->s_header.h_magic = htonl(JFS_MAGIC_NUMBER);
-                jsb->s_header.h_blocktype = htonl(JFS_SUPERBLOCK_V2);
-        }
-
-        /* Zero out everything else beyond the superblock header */
-        
-        p = ((char *) jsb) + sizeof(journal_header_t);
-        memset (p, 0, ctx->fs->blocksize-sizeof(journal_header_t));
-
-        jsb->s_blocksize = htonl(ctx->fs->blocksize);
-        jsb->s_maxlen = htonl(journal->j_maxlen);
-        jsb->s_first = htonl(1);
-
-        /* Initialize the journal sequence number so that there is "no"
-         * chance we will find old "valid" transactions in the journal.
-         * This avoids the need to zero the whole journal (slow to do,
-         * and risky when we are just recovering the filesystem).
-         */
-        uuid_generate(u.uuid);
-        for (i = 0; i < 4; i ++)
-                new_seq ^= u.val[i];
-        jsb->s_sequence = htonl(new_seq);
-
-        mark_buffer_dirty(journal->j_sb_buffer);
-        ll_rw_block(WRITE, 1, &journal->j_sb_buffer);
-}
-
-static errcode_t e2fsck_journal_fix_corrupt_super(e2fsck_t ctx,
-                                                  journal_t *journal,
-                                                  struct problem_context *pctx)
-{
-        struct ext2_super_block *sb = ctx->fs->super;
-        int recover = ctx->fs->super->s_feature_incompat &
-                EXT3_FEATURE_INCOMPAT_RECOVER;
-
-        if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) {
-                if (fix_problem(ctx, PR_0_JOURNAL_BAD_SUPER, pctx)) {
-                        e2fsck_journal_reset_super(ctx, journal->j_superblock,
-                                                   journal);
-                        journal->j_transaction_sequence = 1;
-                        e2fsck_clear_recover(ctx, recover);
-                        return 0;
-                }
-                return EXT2_ET_CORRUPT_SUPERBLOCK;
-        } else if (e2fsck_journal_fix_bad_inode(ctx, pctx))
-                return EXT2_ET_CORRUPT_SUPERBLOCK;
-
-        return 0;
-}
-
-static void e2fsck_journal_release(e2fsck_t ctx, journal_t *journal,
-                                   int reset, int drop)
-{
-        journal_superblock_t *jsb;
-
-        if (drop)
-                mark_buffer_clean(journal->j_sb_buffer);
-        else if (!(ctx->options & E2F_OPT_READONLY)) {
-                jsb = journal->j_superblock;
-                jsb->s_sequence = htonl(journal->j_transaction_sequence);
-                if (reset)
-                        jsb->s_start = 0; /* this marks the journal as empty */
-                mark_buffer_dirty(journal->j_sb_buffer);
-        }
-        brelse(journal->j_sb_buffer);
-
-        if (ctx->journal_io) {
-                if (ctx->fs && ctx->fs->io != ctx->journal_io)
-                        io_channel_close(ctx->journal_io);
-                ctx->journal_io = 0;
-        }
-        
-#ifndef USE_INODE_IO
-        if (journal->j_inode)
-                ext2fs_free_mem(&journal->j_inode);
-#endif
-        if (journal->j_fs_dev)
-                ext2fs_free_mem(&journal->j_fs_dev);
-        ext2fs_free_mem(&journal);
-}
-
-/*
- * This function makes sure that the superblock fields regarding the
- * journal are consistent.
- */
-int e2fsck_check_ext3_journal(e2fsck_t ctx)
-{
-        struct ext2_super_block *sb = ctx->fs->super;
-        journal_t *journal;
-        int recover = ctx->fs->super->s_feature_incompat &
-                EXT3_FEATURE_INCOMPAT_RECOVER;
-        struct problem_context pctx;
-        problem_t problem;
-        int reset = 0, force_fsck = 0;
-        int retval;
-
-        /* If we don't have any journal features, don't do anything more */
-        if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
-            !recover && sb->s_journal_inum == 0 && sb->s_journal_dev == 0 &&
-            uuid_is_null(sb->s_journal_uuid))
-                return 0;
-
-        clear_problem_context(&pctx);
-        pctx.num = sb->s_journal_inum;
-
-        retval = e2fsck_get_journal(ctx, &journal);
-        if (retval) {
-                if ((retval == EXT2_ET_BAD_INODE_NUM) ||
-                    (retval == EXT2_ET_BAD_BLOCK_NUM) ||
-                    (retval == EXT2_ET_JOURNAL_TOO_SMALL) ||
-                    (retval == EXT2_ET_NO_JOURNAL))
-                        return e2fsck_journal_fix_bad_inode(ctx, &pctx);
-                return retval;
-        }
-
-        retval = e2fsck_journal_load(journal);
-        if (retval) {
-                if ((retval == EXT2_ET_CORRUPT_SUPERBLOCK) ||
-                    ((retval == EXT2_ET_UNSUPP_FEATURE) &&
-                    (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_INCOMPAT,
-                                  &pctx))) ||
-                    ((retval == EXT2_ET_RO_UNSUPP_FEATURE) &&
-                    (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_ROCOMPAT,
-                                  &pctx))) ||
-                    ((retval == EXT2_ET_JOURNAL_UNSUPP_VERSION) &&
-                    (!fix_problem(ctx, PR_0_JOURNAL_UNSUPP_VERSION, &pctx))))
-                        retval = e2fsck_journal_fix_corrupt_super(ctx, journal,
-                                                                  &pctx);
-                e2fsck_journal_release(ctx, journal, 0, 1);
-                return retval;
-        }
-
-        /*
-         * We want to make the flags consistent here.  We will not leave with
-         * needs_recovery set but has_journal clear.  We can't get in a loop
-         * with -y, -n, or -p, only if a user isn't making up their mind.
-         */
-no_has_journal:
-        if (!(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
-                recover = sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER;
-                pctx.str = "inode";
-                if (fix_problem(ctx, PR_0_JOURNAL_HAS_JOURNAL, &pctx)) {
-                        if (recover &&
-                            !fix_problem(ctx, PR_0_JOURNAL_RECOVER_SET, &pctx))
-                                goto no_has_journal;
-                        /*
-                         * Need a full fsck if we are releasing a
-                         * journal stored on a reserved inode.
-                         */
-                        force_fsck = recover ||
-                                (sb->s_journal_inum < EXT2_FIRST_INODE(sb));
-                        /* Clear all of the journal fields */
-                        sb->s_journal_inum = 0;
-                        sb->s_journal_dev = 0;
-                        memset(sb->s_journal_uuid, 0,
-                               sizeof(sb->s_journal_uuid));
-                        e2fsck_clear_recover(ctx, force_fsck);
-                } else if (!(ctx->options & E2F_OPT_READONLY)) {
-                        sb->s_feature_compat |= EXT3_FEATURE_COMPAT_HAS_JOURNAL;
-                        ext2fs_mark_super_dirty(ctx->fs);
-                }
-        }
-
-        if (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL &&
-            !(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) &&
-            journal->j_superblock->s_start != 0) {
-                /* Print status information */
-                fix_problem(ctx, PR_0_JOURNAL_RECOVERY_CLEAR, &pctx);
-                if (ctx->superblock)
-                        problem = PR_0_JOURNAL_RUN_DEFAULT;
-                else
-                        problem = PR_0_JOURNAL_RUN;
-                if (fix_problem(ctx, problem, &pctx)) {
-                        ctx->options |= E2F_OPT_FORCE;
-                        sb->s_feature_incompat |=
-                                EXT3_FEATURE_INCOMPAT_RECOVER;
-                        ext2fs_mark_super_dirty(ctx->fs);
-                } else if (fix_problem(ctx,
-                                       PR_0_JOURNAL_RESET_JOURNAL, &pctx)) {
-                        reset = 1;
-                        sb->s_state &= ~EXT2_VALID_FS;
-                        ext2fs_mark_super_dirty(ctx->fs);
-                }
-                /*
-                 * If the user answers no to the above question, we
-                 * ignore the fact that journal apparently has data;
-                 * accidentally replaying over valid data would be far
-                 * worse than skipping a questionable recovery.
-                 * 
-                 * XXX should we abort with a fatal error here?  What
-                 * will the ext3 kernel code do if a filesystem with
-                 * !NEEDS_RECOVERY but with a non-zero
-                 * journal->j_superblock->s_start is mounted?
-                 */
-        }
-
-        e2fsck_journal_release(ctx, journal, reset, 0);
-        return retval;
-}
-
-static errcode_t recover_ext3_journal(e2fsck_t ctx)
-{
-        journal_t *journal;
-        int retval;
-
-        journal_init_revoke_caches();
-        retval = e2fsck_get_journal(ctx, &journal);
-        if (retval)
-                return retval;
-
-        retval = e2fsck_journal_load(journal);
-        if (retval)
-                goto errout;
-
-        retval = journal_init_revoke(journal, 1024);
-        if (retval)
-                goto errout;
-        
-        retval = -journal_recover(journal);
-        if (retval)
-                goto errout;
-        
-        if (journal->j_superblock->s_errno) {
-                ctx->fs->super->s_state |= EXT2_ERROR_FS;
-                ext2fs_mark_super_dirty(ctx->fs);
-                journal->j_superblock->s_errno = 0;
-                mark_buffer_dirty(journal->j_sb_buffer);
-        }
-                
-errout:
-        journal_destroy_revoke(journal);
-        journal_destroy_revoke_caches();
-        e2fsck_journal_release(ctx, journal, 1, 0);
-        return retval;
-}
-
-int e2fsck_run_ext3_journal(e2fsck_t ctx)
-{
-        io_manager io_ptr = ctx->fs->io->manager;
-        int blocksize = ctx->fs->blocksize;
-        errcode_t       retval, recover_retval;
-
-        printf(_("%s: recovering journal\n"), ctx->device_name);
-        if (ctx->options & E2F_OPT_READONLY) {
-                printf(_("%s: won't do journal recovery while read-only\n"),
-                       ctx->device_name);
-                return EXT2_ET_FILE_RO;
-        }
-
-        if (ctx->fs->flags & EXT2_FLAG_DIRTY)
-                ext2fs_flush(ctx->fs);  /* Force out any modifications */
-
-        recover_retval = recover_ext3_journal(ctx);
-        
-        /*
-         * Reload the filesystem context to get up-to-date data from disk
-         * because journal recovery will change the filesystem under us.
-         */
-        ext2fs_close(ctx->fs);
-        retval = ext2fs_open(ctx->filesystem_name, EXT2_FLAG_RW,
-                             ctx->superblock, blocksize, io_ptr,
-                             &ctx->fs);
-
-        if (retval) {
-                com_err(ctx->program_name, retval,
-                        _("while trying to re-open %s"),
-                        ctx->device_name);
-                fatal_error(ctx, 0);
-        }
-        ctx->fs->priv_data = ctx;
-
-        /* Set the superblock flags */
-        e2fsck_clear_recover(ctx, recover_retval);
-        return recover_retval;
-}
-
-/*
- * This function will move the journal inode from a visible file in
- * the filesystem directory hierarchy to the reserved inode if necessary.
- */
-static const char * const journal_names[] = {
-        ".journal", "journal", ".journal.dat", "journal.dat", 0 };
-
-void e2fsck_move_ext3_journal(e2fsck_t ctx)
-{
-        struct ext2_super_block *sb = ctx->fs->super;
-        struct problem_context  pctx;
-        struct ext2_inode       inode;
-        ext2_filsys             fs = ctx->fs;
-        ext2_ino_t              ino;
-        errcode_t               retval;
-        const char * const *    cpp;
-        int                     group, mount_flags;
-        
-        clear_problem_context(&pctx);
-
-        /*
-         * If the filesystem is opened read-only, or there is no
-         * journal, then do nothing.
-         */
-        if ((ctx->options & E2F_OPT_READONLY) ||
-            (sb->s_journal_inum == 0) ||
-            !(sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL))
-                return;
-
-        /*
-         * Read in the journal inode
-         */
-        if (ext2fs_read_inode(fs, sb->s_journal_inum, &inode) != 0)
-                return;
-
-        /*
-         * If it's necessary to backup the journal inode, do so.
-         */
-        if ((sb->s_jnl_backup_type == 0) ||
-            ((sb->s_jnl_backup_type == EXT3_JNL_BACKUP_BLOCKS) &&
-             memcmp(inode.i_block, sb->s_jnl_blocks, EXT2_N_BLOCKS*4))) {
-                if (fix_problem(ctx, PR_0_BACKUP_JNL, &pctx)) {
-                        memcpy(sb->s_jnl_blocks, inode.i_block,
-                               EXT2_N_BLOCKS*4);
-                        sb->s_jnl_blocks[16] = inode.i_size;
-                        sb->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS;
-                        ext2fs_mark_super_dirty(fs);
-                        fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
-                }
-        }
-
-        /*
-         * If the journal is already the hidden inode, then do nothing
-         */
-        if (sb->s_journal_inum == EXT2_JOURNAL_INO)
-                return;
-        
-        /*
-         * The journal inode had better have only one link and not be readable.
-         */
-        if (inode.i_links_count != 1)
-                return;
-
-        /*
-         * If the filesystem is mounted, or we can't tell whether
-         * or not it's mounted, do nothing.
-         */
-        retval = ext2fs_check_if_mounted(ctx->filesystem_name, &mount_flags);
-        if (retval || (mount_flags & EXT2_MF_MOUNTED))
-                return;
-
-        /*
-         * If we can't find the name of the journal inode, then do
-         * nothing.
-         */
-        for (cpp = journal_names; *cpp; cpp++) {
-                retval = ext2fs_lookup(fs, EXT2_ROOT_INO, *cpp,
-                                       strlen(*cpp), 0, &ino);
-                if ((retval == 0) && (ino == sb->s_journal_inum))
-                        break;
-        }
-        if (*cpp == 0)
-                return;
-
-        /* We need the inode bitmap to be loaded */
-        retval = ext2fs_read_bitmaps(fs);
-        if (retval)
-                return;
-
-        pctx.str = *cpp;
-        if (!fix_problem(ctx, PR_0_MOVE_JOURNAL, &pctx))
-                return;
-                
-        /*
-         * OK, we've done all the checks, let's actually move the
-         * journal inode.  Errors at this point mean we need to force
-         * an ext2 filesystem check.
-         */
-        if ((retval = ext2fs_unlink(fs, EXT2_ROOT_INO, *cpp, ino, 0)) != 0)
-                goto err_out;
-        if ((retval = ext2fs_write_inode(fs, EXT2_JOURNAL_INO, &inode)) != 0)
-                goto err_out;
-        sb->s_journal_inum = EXT2_JOURNAL_INO;
-        ext2fs_mark_super_dirty(fs);
-        fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
-        inode.i_links_count = 0;
-        inode.i_dtime = time(0);
-        if ((retval = ext2fs_write_inode(fs, ino, &inode)) != 0)
-                goto err_out;
-
-        group = ext2fs_group_of_ino(fs, ino);
-        ext2fs_unmark_inode_bitmap(fs->inode_map, ino);
-        ext2fs_mark_ib_dirty(fs);
-        fs->group_desc[group].bg_free_inodes_count++;
-        fs->super->s_free_inodes_count++;
-        return;
-
-err_out:
-        pctx.errcode = retval;
-        fix_problem(ctx, PR_0_ERR_MOVE_JOURNAL, &pctx);
-        fs->super->s_state &= ~EXT2_VALID_FS;
-        ext2fs_mark_super_dirty(fs);
-        return;
-}
-
diff --git a/e2fsprogs/e2fsck/message.c b/e2fsprogs/e2fsck/message.c
deleted file mode 100644
index b09ae8976..000000000
--- a/e2fsprogs/e2fsck/message.c
+++ /dev/null
@@ -1,466 +0,0 @@
-/*
- * message.c --- print e2fsck messages (with compression)
- *
- * Copyright 1996, 1997 by Theodore Ts'o
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- *
- * print_e2fsck_message() prints a message to the user, using
- * compression techniques and expansions of abbreviations.
- *
- * The following % expansions are supported:
- *
- *      %b      <blk>                   block number
- *      %B      <blkcount>              integer
- *      %c      <blk2>                  block number
- *      %Di     <dirent>->ino           inode number
- *      %Dn     <dirent>->name          string
- *      %Dr     <dirent>->rec_len
- *      %Dl     <dirent>->name_len
- *      %Dt     <dirent>->filetype
- *      %d      <dir>                   inode number
- *      %g      <group>                 integer
- *      %i      <ino>                   inode number
- *      %Is     <inode> -> i_size
- *      %IS     <inode> -> i_extra_isize
- *      %Ib     <inode> -> i_blocks
- *      %Il     <inode> -> i_links_count
- *      %Im     <inode> -> i_mode
- *      %IM     <inode> -> i_mtime
- *      %IF     <inode> -> i_faddr
- *      %If     <inode> -> i_file_acl
- *      %Id     <inode> -> i_dir_acl
- *      %Iu     <inode> -> i_uid
- *      %Ig     <inode> -> i_gid
- *      %j      <ino2>                  inode number
- *      %m      <com_err error message>
- *      %N      <num>
- *      %p      ext2fs_get_pathname of directory <ino>
- *      %P      ext2fs_get_pathname of <dirent>->ino with <ino2> as
- *                      the containing directory.  (If dirent is NULL
- *                      then return the pathname of directory <ino2>)
- *      %q      ext2fs_get_pathname of directory <dir>
- *      %Q      ext2fs_get_pathname of directory <ino> with <dir> as
- *                      the containing directory.
- *      %s      <str>                   miscellaneous string
- *      %S      backup superblock
- *      %X      <num> hexadecimal format
- *
- * The following '@' expansions are supported:
- *
- *      @a      extended attribute
- *      @A      error allocating
- *      @b      block
- *      @B      bitmap
- *      @c      compress
- *      @C      conflicts with some other fs block
- *      @D      deleted
- *      @d      directory
- *      @e      entry
- *      @E      Entry '%Dn' in %p (%i)
- *      @f      filesystem
- *      @F      for @i %i (%Q) is
- *      @g      group
- *      @h      HTREE directory inode
- *      @i      inode
- *      @I      illegal
- *      @j      journal
- *      @l      lost+found
- *      @L      is a link
- *      @o      orphaned
- *      @p      problem in
- *      @r      root inode
- *      @s      should be 
- *      @S      superblock
- *      @u      unattached
- *      @v      device
- *      @z      zero-length
- */
-
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <ctype.h>
-#include <termios.h>
-
-#include "e2fsck.h"
-
-#include "problem.h"
-
-#ifdef __GNUC__
-#define _INLINE_ __inline__
-#else
-#define _INLINE_
-#endif
-
-/*
- * This structure defines the abbreviations used by the text strings
- * below.  The first character in the string is the index letter.  An
- * abbreviation of the form '@<i>' is expanded by looking up the index
- * letter <i> in the table below.
- */
-static const char *abbrevs[] = {
-        N_("aextended attribute"),
-        N_("Aerror allocating"),
-        N_("bblock"),
-        N_("Bbitmap"),
-        N_("ccompress"),
-        N_("Cconflicts with some other fs @b"),
-        N_("iinode"),
-        N_("Iillegal"),
-        N_("jjournal"),
-        N_("Ddeleted"),
-        N_("ddirectory"),
-        N_("eentry"),
-        N_("E@e '%Dn' in %p (%i)"),
-        N_("ffilesystem"),
-        N_("Ffor @i %i (%Q) is"),
-        N_("ggroup"),
-        N_("hHTREE @d @i"),
-        N_("llost+found"),
-        N_("Lis a link"),
-        N_("oorphaned"),
-        N_("pproblem in"),
-        N_("rroot @i"),
-        N_("sshould be"),
-        N_("Ssuper@b"),
-        N_("uunattached"),
-        N_("vdevice"),
-        N_("zzero-length"),
-        "@@",
-        0
-        };
-
-/*
- * Give more user friendly names to the "special" inodes.
- */
-#define num_special_inodes      11
-static const char *special_inode_name[] =
-{
-        N_("<The NULL inode>"),                 /* 0 */
-        N_("<The bad blocks inode>"),           /* 1 */
-        "/",                                    /* 2 */
-        N_("<The ACL index inode>"),            /* 3 */
-        N_("<The ACL data inode>"),             /* 4 */
-        N_("<The boot loader inode>"),          /* 5 */
-        N_("<The undelete directory inode>"),   /* 6 */
-        N_("<The group descriptor inode>"),     /* 7 */
-        N_("<The journal inode>"),              /* 8 */
-        N_("<Reserved inode 9>"),               /* 9 */
-        N_("<Reserved inode 10>"),              /* 10 */
-};
-
-/*
- * This function does "safe" printing.  It will convert non-printable
- * ASCII characters using '^' and M- notation.
- */
-static void safe_print(const char *cp, int len)
-{
-        unsigned char   ch;
-
-        if (len < 0)
-                len = strlen(cp);
-
-        while (len--) {
-                ch = *cp++;
-                if (ch > 128) {
-                        fputs("M-", stdout);
-                        ch -= 128;
-                }
-                if ((ch < 32) || (ch == 0x7f)) {
-                        fputc('^', stdout);
-                        ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */
-                }
-                fputc(ch, stdout);
-        }
-}
-
-
-/*
- * This function prints a pathname, using the ext2fs_get_pathname
- * function
- */
-static void print_pathname(ext2_filsys fs, ext2_ino_t dir, ext2_ino_t ino)
-{
-        errcode_t       retval;
-        char            *path;
-
-        if (!dir && (ino < num_special_inodes)) {
-                fputs(_(special_inode_name[ino]), stdout);
-                return;
-        }
-        
-        retval = ext2fs_get_pathname(fs, dir, ino, &path);
-        if (retval)
-                fputs("???", stdout);
-        else {
-                safe_print(path, -1);
-                ext2fs_free_mem(&path);
-        }
-}
-
-/*
- * This function handles the '@' expansion.  We allow recursive
- * expansion; an @ expression can contain further '@' and '%'
- * expressions. 
- */
-static _INLINE_ void expand_at_expression(e2fsck_t ctx, char ch,
-                                          struct problem_context *pctx,
-                                          int *first)
-{
-        const char **cpp, *str;
-        
-        /* Search for the abbreviation */
-        for (cpp = abbrevs; *cpp; cpp++) {
-                if (ch == *cpp[0])
-                        break;
-        }
-        if (*cpp) {
-                str = _(*cpp) + 1;
-                if (*first && islower(*str)) {
-                        *first = 0;
-                        fputc(toupper(*str++), stdout);
-                }
-                print_e2fsck_message(ctx, str, pctx, *first);
-        } else
-                printf("@%c", ch);
-}
-
-/*
- * This function expands '%IX' expressions
- */
-static _INLINE_ void expand_inode_expression(char ch, 
-                                             struct problem_context *ctx)
-{
-        struct ext2_inode       *inode;
-        struct ext2_inode_large *large_inode;
-        char *                  time_str;
-        time_t                  t;
-        int                     do_gmt = -1;
-
-        if (!ctx || !ctx->inode)
-                goto no_inode;
-        
-        inode = ctx->inode;
-        large_inode = (struct ext2_inode_large *) inode;
-
-        switch (ch) {
-        case 's':
-                if (LINUX_S_ISDIR(inode->i_mode))
-                        printf("%u", inode->i_size);
-                else {
-#ifdef EXT2_NO_64_TYPE
-                        if (inode->i_size_high)
-                                printf("0x%x%08x", inode->i_size_high,
-                                       inode->i_size);
-                        else
-                                printf("%u", inode->i_size);
-#else
-                        printf("%llu", (inode->i_size | 
-                                        ((__u64) inode->i_size_high << 32)));
-#endif
-                }
-                break;
-        case 'S':
-                printf("%u", large_inode->i_extra_isize);
-                break;
-        case 'b':
-                printf("%u", inode->i_blocks);
-                break;
-        case 'l':
-                printf("%d", inode->i_links_count);
-                break;
-        case 'm':
-                printf("0%o", inode->i_mode);
-                break;
-        case 'M':
-                /* The diet libc doesn't respect the TZ environemnt variable */
-                if (do_gmt == -1) {
-                        time_str = getenv("TZ");
-                        if (!time_str)
-                                time_str = "";
-                        do_gmt = !strcmp(time_str, "GMT");
-                }
-                t = inode->i_mtime;
-                time_str = asctime(do_gmt ? gmtime(&t) : localtime(&t));
-                printf("%.24s", time_str);
-                break;
-        case 'F':
-                printf("%u", inode->i_faddr);
-                break;
-        case 'f':
-                printf("%u", inode->i_file_acl);
-                break;
-        case 'd':
-                printf("%u", (LINUX_S_ISDIR(inode->i_mode) ?
-                              inode->i_dir_acl : 0));
-                break;
-        case 'u':
-                printf("%d", (inode->i_uid |
-                              (inode->osd2.linux2.l_i_uid_high << 16)));
-                break;
-        case 'g':
-                printf("%d", (inode->i_gid |
-                              (inode->osd2.linux2.l_i_gid_high << 16)));
-                break;
-        default:
-        no_inode:
-                printf("%%I%c", ch);
-                break;
-        }
-}
-
-/*
- * This function expands '%dX' expressions
- */
-static _INLINE_ void expand_dirent_expression(char ch,
-                                              struct problem_context *ctx)
-{
-        struct ext2_dir_entry   *dirent;
-        int     len;
-        
-        if (!ctx || !ctx->dirent)
-                goto no_dirent;
-        
-        dirent = ctx->dirent;
-        
-        switch (ch) {
-        case 'i':
-                printf("%u", dirent->inode);
-                break;
-        case 'n':
-                len = dirent->name_len & 0xFF;
-                if (len > EXT2_NAME_LEN)
-                        len = EXT2_NAME_LEN;
-                if (len > dirent->rec_len)
-                        len = dirent->rec_len;
-                safe_print(dirent->name, len);
-                break;
-        case 'r':
-                printf("%u", dirent->rec_len);
-                break;
-        case 'l':
-                printf("%u", dirent->name_len & 0xFF);
-                break;
-        case 't':
-                printf("%u", dirent->name_len >> 8);
-                break;
-        default:
-        no_dirent:
-                printf("%%D%c", ch);
-                break;
-        }
-}
-
-static _INLINE_ void expand_percent_expression(ext2_filsys fs, char ch,
-                                               struct problem_context *ctx)
-{
-        if (!ctx)
-                goto no_context;
-        
-        switch (ch) {
-        case '%':
-                fputc('%', stdout);
-                break;
-        case 'b':
-                printf("%u", ctx->blk);
-                break;
-        case 'B':
-#ifdef EXT2_NO_64_TYPE
-                printf("%d", ctx->blkcount);
-#else
-                printf("%lld", ctx->blkcount);
-#endif
-                break;
-        case 'c':
-                printf("%u", ctx->blk2);
-                break;
-        case 'd':
-                printf("%u", ctx->dir);
-                break;
-        case 'g':
-                printf("%d", ctx->group);
-                break;
-        case 'i':
-                printf("%u", ctx->ino);
-                break;
-        case 'j':
-                printf("%u", ctx->ino2);
-                break;
-        case 'm':
-                printf("%s", error_message(ctx->errcode));
-                break;
-        case 'N':
-#ifdef EXT2_NO_64_TYPE
-                printf("%u", ctx->num);
-#else
-                printf("%llu", ctx->num);
-#endif
-                break;
-        case 'p':
-                print_pathname(fs, ctx->ino, 0);
-                break;
-        case 'P':
-                print_pathname(fs, ctx->ino2,
-                               ctx->dirent ? ctx->dirent->inode : 0);
-                break;
-        case 'q':
-                print_pathname(fs, ctx->dir, 0);
-                break;
-        case 'Q':
-                print_pathname(fs, ctx->dir, ctx->ino);
-                break;
-        case 'S':
-                printf("%d", get_backup_sb(NULL, fs, NULL, NULL));
-                break;
-        case 's':
-                printf("%s", ctx->str ? ctx->str : "NULL");
-                break;
-        case 'X':
-#ifdef EXT2_NO_64_TYPE
-                printf("0x%x", ctx->num);
-#else
-                printf("0x%llx", ctx->num);
-#endif
-                break;
-        default:
-        no_context:
-                printf("%%%c", ch);
-                break;
-        }
-}       
-
-void print_e2fsck_message(e2fsck_t ctx, const char *msg,
-                          struct problem_context *pctx, int first)
-{
-        ext2_filsys fs = ctx->fs;
-        const char *    cp;
-        int             i;
-
-        e2fsck_clear_progbar(ctx);
-        for (cp = msg; *cp; cp++) {
-                if (cp[0] == '@') {
-                        cp++;
-                        expand_at_expression(ctx, *cp, pctx, &first);
-                } else if (cp[0] == '%' && cp[1] == 'I') {
-                        cp += 2;
-                        expand_inode_expression(*cp, pctx);
-                } else if (cp[0] == '%' && cp[1] == 'D') {
-                        cp += 2;
-                        expand_dirent_expression(*cp, pctx);
-                } else if ((cp[0] == '%')) {
-                        cp++;
-                        expand_percent_expression(fs, *cp, pctx);
-                } else {
-                        for (i=0; cp[i]; i++)
-                                if ((cp[i] == '@') || cp[i] == '%')
-                                        break;
-                        printf("%.*s", i, cp);
-                        cp += i-1;
-                }
-                first = 0;
-        }
-}
diff --git a/e2fsprogs/e2fsck/pass1.c b/e2fsprogs/e2fsck/pass1.c
deleted file mode 100644
index 8d01cae2b..000000000
--- a/e2fsprogs/e2fsck/pass1.c
+++ /dev/null
@@ -1,2122 +0,0 @@
-/*
- * pass1.c -- pass #1 of e2fsck: sequential scan of the inode table
- * 
- * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- * 
- * Pass 1 of e2fsck iterates over all the inodes in the filesystems,
- * and applies the following tests to each inode:
- *
- *      - The mode field of the inode must be legal.
- *      - The size and block count fields of the inode are correct.
- *      - A data block must not be used by another inode
- *
- * Pass 1 also gathers the collects the following information:
- *
- *      - A bitmap of which inodes are in use.          (inode_used_map)
- *      - A bitmap of which inodes are directories.     (inode_dir_map)
- *      - A bitmap of which inodes are regular files.   (inode_reg_map)
- *      - A bitmap of which inodes have bad fields.     (inode_bad_map)
- *      - A bitmap of which inodes are in bad blocks.   (inode_bb_map)
- *      - A bitmap of which inodes are imagic inodes.   (inode_imagic_map)
- *      - A bitmap of which blocks are in use.          (block_found_map)
- *      - A bitmap of which blocks are in use by two inodes     (block_dup_map)
- *      - The data blocks of the directory inodes.      (dir_map)
- *
- * Pass 1 is designed to stash away enough information so that the
- * other passes should not need to read in the inode information
- * during the normal course of a filesystem check.  (Althogh if an
- * inconsistency is detected, other passes may need to read in an
- * inode to fix it.)
- *
- * Note that pass 1B will be invoked if there are any duplicate blocks
- * found.
- */
-
-#define _GNU_SOURCE 1 /* get strnlen() */
-#include <string.h>
-#include <time.h>
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#endif
-
-#include "e2fsck.h"
-#include <ext2fs/ext2_ext_attr.h>
-
-#include "problem.h"
-
-#ifdef NO_INLINE_FUNCS
-#define _INLINE_
-#else
-#define _INLINE_ inline
-#endif
-
-static int process_block(ext2_filsys fs, blk_t  *blocknr,
-                         e2_blkcnt_t blockcnt, blk_t ref_blk, 
-                         int ref_offset, void *priv_data);
-static int process_bad_block(ext2_filsys fs, blk_t *block_nr,
-                             e2_blkcnt_t blockcnt, blk_t ref_blk,
-                             int ref_offset, void *priv_data);
-static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
-                         char *block_buf);
-static void mark_table_blocks(e2fsck_t ctx);
-static void alloc_bb_map(e2fsck_t ctx);
-static void alloc_imagic_map(e2fsck_t ctx);
-static void mark_inode_bad(e2fsck_t ctx, ino_t ino);
-static void handle_fs_bad_blocks(e2fsck_t ctx);
-static void process_inodes(e2fsck_t ctx, char *block_buf);
-static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b);
-static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan,
-                                  dgrp_t group, void * priv_data);
-static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, 
-                                    char *block_buf, int adjust_sign);
-/* static char *describe_illegal_block(ext2_filsys fs, blk_t block); */
-
-extern void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino,
-                               struct ext2_inode * inode, int bufsize,
-                               const char *proc);
-
-struct process_block_struct {
-        ext2_ino_t      ino;
-        unsigned        is_dir:1, is_reg:1, clear:1, suppress:1,
-                                fragmented:1, compressed:1, bbcheck:1;
-        blk_t           num_blocks;
-        blk_t           max_blocks;
-        e2_blkcnt_t     last_block;
-        int             num_illegal_blocks;
-        blk_t           previous_block;
-        struct ext2_inode *inode;
-        struct problem_context *pctx;
-        ext2fs_block_bitmap fs_meta_blocks;
-        e2fsck_t        ctx;
-};
-
-struct process_inode_block {
-        ext2_ino_t ino;
-        struct ext2_inode inode;
-};
-
-struct scan_callback_struct {
-        e2fsck_t        ctx;
-        char            *block_buf;
-};
-
-/*
- * For the inodes to process list.
- */
-static struct process_inode_block *inodes_to_process;
-static int process_inode_count;
-
-static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE -
-                            EXT2_MIN_BLOCK_LOG_SIZE + 1];
-
-/*
- * Free all memory allocated by pass1 in preparation for restarting
- * things.
- */
-static void unwind_pass1(ext2_filsys fs EXT2FS_ATTR((unused)))
-{
-        ext2fs_free_mem(&inodes_to_process);
-        inodes_to_process = 0;
-}
-
-/*
- * Check to make sure a device inode is real.  Returns 1 if the device
- * checks out, 0 if not.
- *
- * Note: this routine is now also used to check FIFO's and Sockets,
- * since they have the same requirement; the i_block fields should be
- * zero. 
- */
-int e2fsck_pass1_check_device_inode(ext2_filsys fs, struct ext2_inode *inode)
-{
-        int     i;
-
-        /*
-         * If i_blocks is non-zero, or the index flag is set, then
-         * this is a bogus device/fifo/socket
-         */
-        if ((ext2fs_inode_data_blocks(fs, inode) != 0) ||
-            (inode->i_flags & EXT2_INDEX_FL))
-                return 0;
-
-        /*
-         * We should be able to do the test below all the time, but
-         * because the kernel doesn't forcibly clear the device
-         * inode's additional i_block fields, there are some rare
-         * occasions when a legitimate device inode will have non-zero
-         * additional i_block fields.  So for now, we only complain
-         * when the immutable flag is set, which should never happen
-         * for devices.  (And that's when the problem is caused, since
-         * you can't set or clear immutable flags for devices.)  Once
-         * the kernel has been fixed we can change this...
-         */
-        if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) {
-                for (i=4; i < EXT2_N_BLOCKS; i++) 
-                        if (inode->i_block[i])
-                                return 0;
-        }
-        return 1;
-}
-
-/*
- * Check to make sure a symlink inode is real.  Returns 1 if the symlink
- * checks out, 0 if not.
- */
-int e2fsck_pass1_check_symlink(ext2_filsys fs, struct ext2_inode *inode,
-                               char *buf)
-{
-        unsigned int len;
-        int i;
-        blk_t   blocks;
-
-        if ((inode->i_size_high || inode->i_size == 0) ||
-            (inode->i_flags & EXT2_INDEX_FL))
-                return 0;
-
-        blocks = ext2fs_inode_data_blocks(fs, inode);
-        if (blocks) {
-                if ((inode->i_size >= fs->blocksize) ||
-                    (blocks != fs->blocksize >> 9) ||
-                    (inode->i_block[0] < fs->super->s_first_data_block) ||
-                    (inode->i_block[0] >= fs->super->s_blocks_count))
-                        return 0;
-
-                for (i = 1; i < EXT2_N_BLOCKS; i++)
-                        if (inode->i_block[i])
-                                return 0;
-
-                if (io_channel_read_blk(fs->io, inode->i_block[0], 1, buf))
-                        return 0;
-
-                len = strnlen(buf, fs->blocksize);
-                if (len == fs->blocksize)
-                        return 0;
-        } else {
-                if (inode->i_size >= sizeof(inode->i_block))
-                        return 0;
-
-                len = strnlen((char *)inode->i_block, sizeof(inode->i_block));
-                if (len == sizeof(inode->i_block))
-                        return 0;
-        }
-        if (len != inode->i_size)
-                return 0;
-        return 1;
-}
-
-/*
- * If the immutable (or append-only) flag is set on the inode, offer
- * to clear it.
- */
-#define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)
-static void check_immutable(e2fsck_t ctx, struct problem_context *pctx)
-{
-        if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS))
-                return;
-
-        if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx))
-                return;
-
-        pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS;
-        e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
-}
-
-/*
- * If device, fifo or socket, check size is zero -- if not offer to
- * clear it
- */
-static void check_size(e2fsck_t ctx, struct problem_context *pctx)
-{
-        struct ext2_inode *inode = pctx->inode;
-        
-        if ((inode->i_size == 0) && (inode->i_size_high == 0))
-                return;
-        
-        if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx))
-                return;
-        
-        inode->i_size = 0;
-        inode->i_size_high = 0;
-        e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1");
-}
-        
-static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx)
-{
-        struct ext2_super_block *sb = ctx->fs->super;
-        struct ext2_inode_large *inode;
-        struct ext2_ext_attr_entry *entry;
-        char *start, *end;
-        int storage_size, remain, offs;
-        int problem = 0;
-
-        inode = (struct ext2_inode_large *) pctx->inode;
-        storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE -
-                inode->i_extra_isize;
-        start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
-                inode->i_extra_isize + sizeof(__u32);
-        end = (char *) inode + EXT2_INODE_SIZE(ctx->fs->super);
-        entry = (struct ext2_ext_attr_entry *) start;
-
-        /* scan all entry's headers first */
-
-        /* take finish entry 0UL into account */
-        remain = storage_size - sizeof(__u32); 
-        offs = end - start;
-
-        while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
-
-                /* header eats this space */
-                remain -= sizeof(struct ext2_ext_attr_entry);
-                
-                /* is attribute name valid? */
-                if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) {
-                        pctx->num = entry->e_name_len;
-                        problem = PR_1_ATTR_NAME_LEN;
-                        goto fix;
-                }
-
-                /* attribute len eats this space */
-                remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len);
-
-                /* check value size */
-                if (entry->e_value_size == 0 || entry->e_value_size > remain) {
-                        pctx->num = entry->e_value_size;
-                        problem = PR_1_ATTR_VALUE_SIZE;
-                        goto fix;
-                }
-
-                /* check value placement */
-                if (entry->e_value_offs + 
-                    EXT2_XATTR_SIZE(entry->e_value_size) != offs) {
-                        printf("(entry->e_value_offs + entry->e_value_size: %d, offs: %d)\n", entry->e_value_offs + entry->e_value_size, offs);
-                        pctx->num = entry->e_value_offs;
-                        problem = PR_1_ATTR_VALUE_OFFSET;
-                        goto fix;
-                }
-        
-                /* e_value_block must be 0 in inode's ea */
-                if (entry->e_value_block != 0) {
-                        pctx->num = entry->e_value_block;
-                        problem = PR_1_ATTR_VALUE_BLOCK;
-                        goto fix;
-                }
-                
-                /* e_hash must be 0 in inode's ea */
-                if (entry->e_hash != 0) {
-                        pctx->num = entry->e_hash;
-                        problem = PR_1_ATTR_HASH;
-                        goto fix;
-                }
-
-                remain -= entry->e_value_size;
-                offs -= EXT2_XATTR_SIZE(entry->e_value_size);
-
-                entry = EXT2_EXT_ATTR_NEXT(entry);
-        }
-fix:
-        /*
-         * it seems like a corruption. it's very unlikely we could repair
-         * EA(s) in automatic fashion -bzzz
-         */
-#if 0
-        problem = PR_1_ATTR_HASH;
-#endif
-        if (problem == 0 || !fix_problem(ctx, problem, pctx))
-                return;
-
-        /* simple remove all possible EA(s) */
-        *((__u32 *)start) = 0UL;
-        e2fsck_write_inode_full(ctx, pctx->ino, (struct ext2_inode *)inode,
-                                EXT2_INODE_SIZE(sb), "pass1");
-}
-
-static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx)
-{
-        struct ext2_super_block *sb = ctx->fs->super;
-        struct ext2_inode_large *inode;
-        __u32 *eamagic;
-        int min, max;
-
-        inode = (struct ext2_inode_large *) pctx->inode;
-        if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) {
-                /* this isn't large inode. so, nothing to check */
-                return;
-        }
-
-#if 0
-        printf("inode #%u, i_extra_size %d\n", pctx->ino,
-                        inode->i_extra_isize);
-#endif  
-        /* i_extra_isize must cover i_extra_isize + i_pad1 at least */
-        min = sizeof(inode->i_extra_isize) + sizeof(inode->i_pad1);
-        max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE;
-        /* 
-         * For now we will allow i_extra_isize to be 0, but really
-         * implementations should never allow i_extra_isize to be 0
-         */
-        if (inode->i_extra_isize &&
-            (inode->i_extra_isize < min || inode->i_extra_isize > max)) {
-                if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx))
-                        return;
-                inode->i_extra_isize = min;
-                e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode,
-                                        EXT2_INODE_SIZE(sb), "pass1");
-                return;
-        }
-
-        eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
-                        inode->i_extra_isize);
-        if (*eamagic == EXT2_EXT_ATTR_MAGIC) {
-                /* it seems inode has an extended attribute(s) in body */
-                check_ea_in_inode(ctx, pctx);
-        }
-}
-
-void e2fsck_pass1(e2fsck_t ctx)
-{
-        int     i;
-        __u64   max_sizes;
-        ext2_filsys fs = ctx->fs;
-        ext2_ino_t      ino;
-        struct ext2_inode *inode;
-        ext2_inode_scan scan;
-        char            *block_buf;
-#ifdef RESOURCE_TRACK
-        struct resource_track   rtrack;
-#endif
-        unsigned char   frag, fsize;
-        struct          problem_context pctx;
-        struct          scan_callback_struct scan_struct;
-        struct ext2_super_block *sb = ctx->fs->super;
-        int             imagic_fs;
-        int             busted_fs_time = 0;
-        int             inode_size;
-        
-#ifdef RESOURCE_TRACK
-        init_resource_track(&rtrack);
-#endif
-        clear_problem_context(&pctx);
-
-        if (!(ctx->options & E2F_OPT_PREEN))
-                fix_problem(ctx, PR_1_PASS_HEADER, &pctx);
-
-        if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
-            !(ctx->options & E2F_OPT_NO)) {
-                if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50))
-                        ctx->dirs_to_hash = 0;
-        }
-
-#ifdef MTRACE
-        mtrace_print("Pass 1");
-#endif
-
-#define EXT2_BPP(bits) (1ULL << ((bits) - 2))
-
-        for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) {
-                max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i);
-                max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i);
-                max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i);
-                max_sizes = (max_sizes * (1UL << i)) - 1;
-                ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes;
-        }
-#undef EXT2_BPP
-
-        imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES);
-
-        /*
-         * Allocate bitmaps structures
-         */
-        pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("in-use inode map"),
-                                              &ctx->inode_used_map);
-        if (pctx.errcode) {
-                pctx.num = 1;
-                fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
-                                _("directory inode map"), &ctx->inode_dir_map);
-        if (pctx.errcode) {
-                pctx.num = 2;
-                fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
-                        _("regular file inode map"), &ctx->inode_reg_map);
-        if (pctx.errcode) {
-                pctx.num = 6;
-                fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        pctx.errcode = ext2fs_allocate_block_bitmap(fs, _("in-use block map"),
-                                              &ctx->block_found_map);
-        if (pctx.errcode) {
-                pctx.num = 1;
-                fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0,
-                                             &ctx->inode_link_info);
-        if (pctx.errcode) {
-                fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        inode_size = EXT2_INODE_SIZE(fs->super);
-        inode = (struct ext2_inode *)
-                e2fsck_allocate_memory(ctx, inode_size, "scratch inode");
-
-        inodes_to_process = (struct process_inode_block *)
-                e2fsck_allocate_memory(ctx,
-                                       (ctx->process_inode_size *
-                                        sizeof(struct process_inode_block)),
-                                       "array of inodes to process");
-        process_inode_count = 0;
-
-        pctx.errcode = ext2fs_init_dblist(fs, 0);
-        if (pctx.errcode) {
-                fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-
-        /*
-         * If the last orphan field is set, clear it, since the pass1
-         * processing will automatically find and clear the orphans.
-         * In the future, we may want to try using the last_orphan
-         * linked list ourselves, but for now, we clear it so that the
-         * ext3 mount code won't get confused.
-         */
-        if (!(ctx->options & E2F_OPT_READONLY)) {
-                if (fs->super->s_last_orphan) {
-                        fs->super->s_last_orphan = 0;
-                        ext2fs_mark_super_dirty(fs);
-                }
-        }
-
-        mark_table_blocks(ctx);
-        block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3,
-                                                    "block interate buffer");
-        e2fsck_use_inode_shortcuts(ctx, 1);
-        ehandler_operation(_("doing inode scan"));
-        pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks, 
-                                              &scan);
-        if (pctx.errcode) {
-                fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0);
-        ctx->stashed_inode = inode;
-        scan_struct.ctx = ctx;
-        scan_struct.block_buf = block_buf;
-        ext2fs_set_inode_callback(scan, scan_callback, &scan_struct);
-        if (ctx->progress)
-                if ((ctx->progress)(ctx, 1, 0, ctx->fs->group_desc_count))
-                        return;
-        if (fs->super->s_wtime < fs->super->s_inodes_count)
-                busted_fs_time = 1;
-
-        while (1) {
-                pctx.errcode = ext2fs_get_next_inode_full(scan, &ino, 
-                                                          inode, inode_size);
-                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                        return;
-                if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) {
-                        if (!ctx->inode_bb_map)
-                                alloc_bb_map(ctx);
-                        ext2fs_mark_inode_bitmap(ctx->inode_bb_map, ino);
-                        ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
-                        continue;
-                }
-                if (pctx.errcode) {
-                        fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return;
-                }
-                if (!ino)
-                        break;
-                pctx.ino = ino;
-                pctx.inode = inode;
-                ctx->stashed_ino = ino;
-                if (inode->i_links_count) {
-                        pctx.errcode = ext2fs_icount_store(ctx->inode_link_info, 
-                                           ino, inode->i_links_count);
-                        if (pctx.errcode) {
-                                pctx.num = inode->i_links_count;
-                                fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx);
-                                ctx->flags |= E2F_FLAG_ABORT;
-                                return;
-                        }
-                }
-                if (ino == EXT2_BAD_INO) {
-                        struct process_block_struct pb;
-                        
-                        pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map,
-                                                          &pb.fs_meta_blocks);
-                        if (pctx.errcode) {
-                                pctx.num = 4;
-                                fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx);
-                                ctx->flags |= E2F_FLAG_ABORT;
-                                return;
-                        }
-                        pb.ino = EXT2_BAD_INO;
-                        pb.num_blocks = pb.last_block = 0;
-                        pb.num_illegal_blocks = 0;
-                        pb.suppress = 0; pb.clear = 0; pb.is_dir = 0;
-                        pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0;
-                        pb.inode = inode;
-                        pb.pctx = &pctx;
-                        pb.ctx = ctx;
-                        pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, 
-                                     block_buf, process_bad_block, &pb);
-                        ext2fs_free_block_bitmap(pb.fs_meta_blocks);
-                        if (pctx.errcode) {
-                                fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx);
-                                ctx->flags |= E2F_FLAG_ABORT;
-                                return;
-                        }
-                        if (pb.bbcheck)
-                                if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) {
-                                ctx->flags |= E2F_FLAG_ABORT;
-                                return;
-                        }
-                        ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
-                        clear_problem_context(&pctx);
-                        continue;
-                } else if (ino == EXT2_ROOT_INO) {
-                        /*
-                         * Make sure the root inode is a directory; if
-                         * not, offer to clear it.  It will be
-                         * regnerated in pass #3.
-                         */
-                        if (!LINUX_S_ISDIR(inode->i_mode)) {
-                                if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx)) {
-                                        inode->i_dtime = time(0);
-                                        inode->i_links_count = 0;
-                                        ext2fs_icount_store(ctx->inode_link_info,
-                                                            ino, 0);
-                                        e2fsck_write_inode(ctx, ino, inode,
-                                                           "pass1");
-                                }
-
-                        }
-                        /*
-                         * If dtime is set, offer to clear it.  mke2fs
-                         * version 0.2b created filesystems with the
-                         * dtime field set for the root and lost+found
-                         * directories.  We won't worry about
-                         * /lost+found, since that can be regenerated
-                         * easily.  But we will fix the root directory
-                         * as a special case.
-                         */
-                        if (inode->i_dtime && inode->i_links_count) {
-                                if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) {
-                                        inode->i_dtime = 0;
-                                        e2fsck_write_inode(ctx, ino, inode,
-                                                           "pass1");
-                                }
-                        }
-                } else if (ino == EXT2_JOURNAL_INO) {
-                        ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
-                        if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) {
-                                if (!LINUX_S_ISREG(inode->i_mode) &&
-                                    fix_problem(ctx, PR_1_JOURNAL_BAD_MODE,
-                                                &pctx)) {
-                                        inode->i_mode = LINUX_S_IFREG;
-                                        e2fsck_write_inode(ctx, ino, inode,
-                                                           "pass1");
-                                }
-                                check_blocks(ctx, &pctx, block_buf);
-                                continue;
-                        }
-                        if ((inode->i_links_count || inode->i_blocks ||
-                             inode->i_blocks || inode->i_block[0]) &&
-                            fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR, 
-                                        &pctx)) {
-                                memset(inode, 0, inode_size);
-                                ext2fs_icount_store(ctx->inode_link_info,
-                                                    ino, 0);
-                                e2fsck_write_inode_full(ctx, ino, inode, 
-                                                        inode_size, "pass1");
-                        }
-                } else if (ino < EXT2_FIRST_INODE(fs->super)) {
-                        int     problem = 0;
-                        
-                        ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
-                        if (ino == EXT2_BOOT_LOADER_INO) {
-                                if (LINUX_S_ISDIR(inode->i_mode))
-                                        problem = PR_1_RESERVED_BAD_MODE;
-                        } else if (ino == EXT2_RESIZE_INO) {
-                                if (inode->i_mode &&
-                                    !LINUX_S_ISREG(inode->i_mode))
-                                        problem = PR_1_RESERVED_BAD_MODE;
-                        } else {
-                                if (inode->i_mode != 0)
-                                        problem = PR_1_RESERVED_BAD_MODE;
-                        }
-                        if (problem) {
-                                if (fix_problem(ctx, problem, &pctx)) {
-                                        inode->i_mode = 0;
-                                        e2fsck_write_inode(ctx, ino, inode,
-                                                           "pass1");
-                                }
-                        }
-                        check_blocks(ctx, &pctx, block_buf);
-                        continue;
-                }
-                /*
-                 * Check for inodes who might have been part of the
-                 * orphaned list linked list.  They should have gotten
-                 * dealt with by now, unless the list had somehow been
-                 * corrupted.
-                 * 
-                 * FIXME: In the future, inodes which are still in use
-                 * (and which are therefore) pending truncation should
-                 * be handled specially.  Right now we just clear the
-                 * dtime field, and the normal e2fsck handling of
-                 * inodes where i_size and the inode blocks are
-                 * inconsistent is to fix i_size, instead of releasing
-                 * the extra blocks.  This won't catch the inodes that
-                 * was at the end of the orphan list, but it's better
-                 * than nothing.  The right answer is that there
-                 * shouldn't be any bugs in the orphan list handling.  :-)
-                 */
-                if (inode->i_dtime && !busted_fs_time &&
-                    inode->i_dtime < ctx->fs->super->s_inodes_count) {
-                        if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) {
-                                inode->i_dtime = inode->i_links_count ?
-                                        0 : time(0);
-                                e2fsck_write_inode(ctx, ino, inode,
-                                                   "pass1");
-                        }
-                }
-                
-                /*
-                 * This code assumes that deleted inodes have
-                 * i_links_count set to 0.  
-                 */
-                if (!inode->i_links_count) {
-                        if (!inode->i_dtime && inode->i_mode) {
-                                if (fix_problem(ctx,
-                                            PR_1_ZERO_DTIME, &pctx)) {
-                                        inode->i_dtime = time(0);
-                                        e2fsck_write_inode(ctx, ino, inode,
-                                                           "pass1");
-                                }
-                        }
-                        continue;
-                }
-                /*
-                 * n.b.  0.3c ext2fs code didn't clear i_links_count for
-                 * deleted files.  Oops.
-                 *
-                 * Since all new ext2 implementations get this right,
-                 * we now assume that the case of non-zero
-                 * i_links_count and non-zero dtime means that we
-                 * should keep the file, not delete it.
-                 * 
-                 */
-                if (inode->i_dtime) {
-                        if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) {
-                                inode->i_dtime = 0;
-                                e2fsck_write_inode(ctx, ino, inode, "pass1");
-                        }
-                }
-                
-                ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
-                switch (fs->super->s_creator_os) {
-                    case EXT2_OS_LINUX:
-                        frag = inode->osd2.linux2.l_i_frag;
-                        fsize = inode->osd2.linux2.l_i_fsize;
-                        break;
-                    case EXT2_OS_HURD:
-                        frag = inode->osd2.hurd2.h_i_frag;
-                        fsize = inode->osd2.hurd2.h_i_fsize;
-                        break;
-                    case EXT2_OS_MASIX:
-                        frag = inode->osd2.masix2.m_i_frag;
-                        fsize = inode->osd2.masix2.m_i_fsize;
-                        break;
-                    default:
-                        frag = fsize = 0;
-                }
-                
-                if (inode->i_faddr || frag || fsize ||
-                    (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl))
-                        mark_inode_bad(ctx, ino);
-                if (inode->i_flags & EXT2_IMAGIC_FL) {
-                        if (imagic_fs) {
-                                if (!ctx->inode_imagic_map)
-                                        alloc_imagic_map(ctx);
-                                ext2fs_mark_inode_bitmap(ctx->inode_imagic_map,
-                                                         ino);
-                        } else {
-                                if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) {
-                                        inode->i_flags &= ~EXT2_IMAGIC_FL;
-                                        e2fsck_write_inode(ctx, ino,
-                                                           inode, "pass1");
-                                }
-                        }
-                }
-
-                check_inode_extra_space(ctx, &pctx);
-
-                if (LINUX_S_ISDIR(inode->i_mode)) {
-                        ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino);
-                        e2fsck_add_dir_info(ctx, ino, 0);
-                        ctx->fs_directory_count++;
-                } else if (LINUX_S_ISREG (inode->i_mode)) {
-                        ext2fs_mark_inode_bitmap(ctx->inode_reg_map, ino);
-                        ctx->fs_regular_count++;
-                } else if (LINUX_S_ISCHR (inode->i_mode) &&
-                           e2fsck_pass1_check_device_inode(fs, inode)) {
-                        check_immutable(ctx, &pctx);
-                        check_size(ctx, &pctx);
-                        ctx->fs_chardev_count++;
-                } else if (LINUX_S_ISBLK (inode->i_mode) &&
-                           e2fsck_pass1_check_device_inode(fs, inode)) {
-                        check_immutable(ctx, &pctx);
-                        check_size(ctx, &pctx);
-                        ctx->fs_blockdev_count++;
-                } else if (LINUX_S_ISLNK (inode->i_mode) &&
-                           e2fsck_pass1_check_symlink(fs, inode, block_buf)) {
-                        check_immutable(ctx, &pctx);
-                        ctx->fs_symlinks_count++;
-                        if (ext2fs_inode_data_blocks(fs, inode) == 0) {
-                                ctx->fs_fast_symlinks_count++;
-                                check_blocks(ctx, &pctx, block_buf);
-                                continue;
-                        }
-                }
-                else if (LINUX_S_ISFIFO (inode->i_mode) &&
-                         e2fsck_pass1_check_device_inode(fs, inode)) {
-                        check_immutable(ctx, &pctx);
-                        check_size(ctx, &pctx);
-                        ctx->fs_fifo_count++;
-                } else if ((LINUX_S_ISSOCK (inode->i_mode)) &&
-                           e2fsck_pass1_check_device_inode(fs, inode)) {
-                        check_immutable(ctx, &pctx);
-                        check_size(ctx, &pctx);
-                        ctx->fs_sockets_count++;
-                } else
-                        mark_inode_bad(ctx, ino);
-                if (inode->i_block[EXT2_IND_BLOCK])
-                        ctx->fs_ind_count++;
-                if (inode->i_block[EXT2_DIND_BLOCK])
-                        ctx->fs_dind_count++;
-                if (inode->i_block[EXT2_TIND_BLOCK])
-                        ctx->fs_tind_count++;
-                if (inode->i_block[EXT2_IND_BLOCK] ||
-                    inode->i_block[EXT2_DIND_BLOCK] ||
-                    inode->i_block[EXT2_TIND_BLOCK] ||
-                    inode->i_file_acl) {
-                        inodes_to_process[process_inode_count].ino = ino;
-                        inodes_to_process[process_inode_count].inode = *inode;
-                        process_inode_count++;
-                } else
-                        check_blocks(ctx, &pctx, block_buf);
-
-                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                        return;
-
-                if (process_inode_count >= ctx->process_inode_size) {
-                        process_inodes(ctx, block_buf);
-
-                        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                                return;
-                }
-        }
-        process_inodes(ctx, block_buf);
-        ext2fs_close_inode_scan(scan);
-        ehandler_operation(0);
-
-        /*
-         * 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) {
-                ext2fs_block_bitmap save_bmap;
-
-                save_bmap = fs->block_map;
-                fs->block_map = ctx->block_found_map;
-                clear_problem_context(&pctx);
-                pctx.errcode = ext2fs_create_resize_inode(fs);
-                if (pctx.errcode) {
-                        fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, &pctx);
-                        /* Should never get here */
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return;
-                }
-                fs->block_map = save_bmap;
-                ctx->flags &= ~E2F_FLAG_RESIZE_INODE;
-        }
-                       
-        if (ctx->flags & E2F_FLAG_RESTART) {
-                /*
-                 * Only the master copy of the superblock and block
-                 * group descriptors are going to be written during a
-                 * restart, so set the superblock to be used to be the
-                 * master superblock.
-                 */
-                ctx->use_superblock = 0;
-                unwind_pass1(fs);
-                goto endit;
-        }
-
-        if (ctx->block_dup_map) {
-                if (ctx->options & E2F_OPT_PREEN) {
-                        clear_problem_context(&pctx);
-                        fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx);
-                }
-                e2fsck_pass1_dupblocks(ctx, block_buf);
-        }
-        ext2fs_free_mem(&inodes_to_process);
-endit:
-        e2fsck_use_inode_shortcuts(ctx, 0);
-        
-        ext2fs_free_mem(&block_buf);
-        ext2fs_free_mem(&inode);
-
-#ifdef RESOURCE_TRACK
-        if (ctx->options & E2F_OPT_TIME2) {
-                e2fsck_clear_progbar(ctx);
-                print_resource_track(_("Pass 1"), &rtrack);
-        }
-#endif
-}
-
-/*
- * When the inode_scan routines call this callback at the end of the
- * glock group, call process_inodes.
- */
-static errcode_t scan_callback(ext2_filsys fs, 
-                               ext2_inode_scan scan EXT2FS_ATTR((unused)),
-                               dgrp_t group, void * priv_data)
-{
-        struct scan_callback_struct *scan_struct;
-        e2fsck_t ctx;
-
-        scan_struct = (struct scan_callback_struct *) priv_data;
-        ctx = scan_struct->ctx;
-        
-        process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf);
-
-        if (ctx->progress)
-                if ((ctx->progress)(ctx, 1, group+1,
-                                    ctx->fs->group_desc_count))
-                        return EXT2_ET_CANCEL_REQUESTED;
-
-        return 0;
-}
-
-/*
- * Process the inodes in the "inodes to process" list.
- */
-static void process_inodes(e2fsck_t ctx, char *block_buf)
-{
-        int                     i;
-        struct ext2_inode       *old_stashed_inode;
-        ext2_ino_t              old_stashed_ino;
-        const char              *old_operation;
-        char                    buf[80];
-        struct problem_context  pctx;
-        
-#if 0
-        printf("begin process_inodes: ");
-#endif
-        if (process_inode_count == 0)
-                return;
-        old_operation = ehandler_operation(0);
-        old_stashed_inode = ctx->stashed_inode;
-        old_stashed_ino = ctx->stashed_ino;
-        qsort(inodes_to_process, process_inode_count,
-                      sizeof(struct process_inode_block), process_inode_cmp);
-        clear_problem_context(&pctx);
-        for (i=0; i < process_inode_count; i++) {
-                pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode;
-                pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino;
-                
-#if 0
-                printf("%u ", pctx.ino);
-#endif
-                sprintf(buf, _("reading indirect blocks of inode %u"),
-                        pctx.ino);
-                ehandler_operation(buf);
-                check_blocks(ctx, &pctx, block_buf);
-                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                        break;
-        }
-        ctx->stashed_inode = old_stashed_inode;
-        ctx->stashed_ino = old_stashed_ino;
-        process_inode_count = 0;
-#if 0
-        printf("end process inodes\n");
-#endif
-        ehandler_operation(old_operation);
-}
-
-static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b)
-{
-        const struct process_inode_block *ib_a =
-                (const struct process_inode_block *) a;
-        const struct process_inode_block *ib_b =
-                (const struct process_inode_block *) b;
-        int     ret;
-        
-        ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] -
-               ib_b->inode.i_block[EXT2_IND_BLOCK]);
-        if (ret == 0)
-                ret = ib_a->inode.i_file_acl - ib_b->inode.i_file_acl;
-        return ret;
-}
-
-/*
- * Mark an inode as being bad in some what
- */
-static void mark_inode_bad(e2fsck_t ctx, ino_t ino)
-{
-        struct          problem_context pctx;
-
-        if (!ctx->inode_bad_map) {
-                clear_problem_context(&pctx);
-        
-                pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
-                            _("bad inode map"), &ctx->inode_bad_map);
-                if (pctx.errcode) {
-                        pctx.num = 3;
-                        fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
-                        /* Should never get here */
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return;
-                }
-        }
-        ext2fs_mark_inode_bitmap(ctx->inode_bad_map, ino);
-}
-
-
-/*
- * This procedure will allocate the inode "bb" (badblock) map table
- */
-static void alloc_bb_map(e2fsck_t ctx)
-{
-        struct          problem_context pctx;
-        
-        clear_problem_context(&pctx);
-        pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
-                                              _("inode in bad block map"),
-                                              &ctx->inode_bb_map);
-        if (pctx.errcode) {
-                pctx.num = 4;
-                fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
-                /* Should never get here */
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-}
-
-/*
- * This procedure will allocate the inode imagic table
- */
-static void alloc_imagic_map(e2fsck_t ctx)
-{
-        struct          problem_context pctx;
-        
-        clear_problem_context(&pctx);
-        pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
-                                              _("imagic inode map"),
-                                              &ctx->inode_imagic_map);
-        if (pctx.errcode) {
-                pctx.num = 5;
-                fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
-                /* Should never get here */
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-}
-
-/*
- * Marks a block as in use, setting the dup_map if it's been set
- * already.  Called by process_block and process_bad_block.
- *
- * WARNING: Assumes checks have already been done to make sure block
- * is valid.  This is true in both process_block and process_bad_block.
- */
-static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block)
-{
-        struct          problem_context pctx;
-        
-        clear_problem_context(&pctx);
-        
-        if (ext2fs_fast_test_block_bitmap(ctx->block_found_map, block)) {
-                if (!ctx->block_dup_map) {
-                        pctx.errcode = ext2fs_allocate_block_bitmap(ctx->fs,
-                              _("multiply claimed block map"),
-                              &ctx->block_dup_map);
-                        if (pctx.errcode) {
-                                pctx.num = 3;
-                                fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, 
-                                            &pctx);
-                                /* Should never get here */
-                                ctx->flags |= E2F_FLAG_ABORT;
-                                return;
-                        }
-                }
-                ext2fs_fast_mark_block_bitmap(ctx->block_dup_map, block);
-        } else {
-                ext2fs_fast_mark_block_bitmap(ctx->block_found_map, block);
-        }
-}
-
-/*
- * Adjust the extended attribute block's reference counts at the end
- * of pass 1, either by subtracting out references for EA blocks that
- * are still referenced in ctx->refcount, or by adding references for
- * EA blocks that had extra references as accounted for in
- * ctx->refcount_extra.
- */
-static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, 
-                                    char *block_buf, int adjust_sign)
-{
-        struct ext2_ext_attr_header     *header;
-        struct problem_context          pctx;
-        ext2_filsys                     fs = ctx->fs;
-        blk_t                           blk;
-        __u32                           should_be;
-        int                             count;
-
-        clear_problem_context(&pctx);
-        
-        ea_refcount_intr_begin(refcount);
-        while (1) {
-                if ((blk = ea_refcount_intr_next(refcount, &count)) == 0)
-                        break;
-                pctx.blk = blk;
-                pctx.errcode = ext2fs_read_ext_attr(fs, blk, block_buf);
-                if (pctx.errcode) {
-                        fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx);
-                        return;
-                }
-                header = (struct ext2_ext_attr_header *) block_buf;
-                pctx.blkcount = header->h_refcount;
-                should_be = header->h_refcount + adjust_sign * count;
-                pctx.num = should_be;
-                if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) {
-                        header->h_refcount = should_be;
-                        pctx.errcode = ext2fs_write_ext_attr(fs, blk,
-                                                             block_buf);
-                        if (pctx.errcode) {
-                                fix_problem(ctx, PR_1_EXTATTR_WRITE, &pctx);
-                                continue;
-                        }
-                }
-        }
-}
-
-/*
- * Handle processing the extended attribute blocks
- */
-static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx,
-                           char *block_buf)
-{
-        ext2_filsys fs = ctx->fs;
-        ext2_ino_t      ino = pctx->ino;
-        struct ext2_inode *inode = pctx->inode;
-        blk_t           blk;
-        char *          end;
-        struct ext2_ext_attr_header *header;
-        struct ext2_ext_attr_entry *entry;
-        int             count;
-        region_t        region;
-        
-        blk = inode->i_file_acl;
-        if (blk == 0)
-                return 0;
-
-        /*
-         * If the Extended attribute flag isn't set, then a non-zero
-         * file acl means that the inode is corrupted.
-         *
-         * Or if the extended attribute block is an invalid block,
-         * then the inode is also corrupted.
-         */
-        if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) ||
-            (blk < fs->super->s_first_data_block) ||
-            (blk >= fs->super->s_blocks_count)) {
-                mark_inode_bad(ctx, ino);
-                return 0;
-        }
-
-        /* If ea bitmap hasn't been allocated, create it */
-        if (!ctx->block_ea_map) {
-                pctx->errcode = ext2fs_allocate_block_bitmap(fs,
-                                                      _("ext attr block map"),
-                                                      &ctx->block_ea_map);
-                if (pctx->errcode) {
-                        pctx->num = 2;
-                        fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx);
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return 0;
-                }
-        }
-
-        /* Create the EA refcount structure if necessary */
-        if (!ctx->refcount) {
-                pctx->errcode = ea_refcount_create(0, &ctx->refcount);
-                if (pctx->errcode) {
-                        pctx->num = 1;
-                        fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return 0;
-                }
-        }
-
-#if 0
-        /* Debugging text */
-        printf("Inode %u has EA block %u\n", ino, blk);
-#endif
-
-        /* Have we seen this EA block before? */
-        if (ext2fs_fast_test_block_bitmap(ctx->block_ea_map, blk)) {
-                if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0)
-                        return 1;
-                /* Ooops, this EA was referenced more than it stated */
-                if (!ctx->refcount_extra) {
-                        pctx->errcode = ea_refcount_create(0,
-                                           &ctx->refcount_extra);
-                        if (pctx->errcode) {
-                                pctx->num = 2;
-                                fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx);
-                                ctx->flags |= E2F_FLAG_ABORT;
-                                return 0;
-                        }
-                }
-                ea_refcount_increment(ctx->refcount_extra, blk, 0);
-                return 1;
-        }
-        
-        /*
-         * OK, we haven't seen this EA block yet.  So we need to
-         * validate it
-         */
-        pctx->blk = blk;
-        pctx->errcode = ext2fs_read_ext_attr(fs, blk, block_buf);
-        if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx))
-                goto clear_extattr;
-        header = (struct ext2_ext_attr_header *) block_buf;
-        pctx->blk = inode->i_file_acl;
-        if (((ctx->ext_attr_ver == 1) &&
-             (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) ||
-            ((ctx->ext_attr_ver == 2) &&
-             (header->h_magic != EXT2_EXT_ATTR_MAGIC))) {
-                if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx))
-                        goto clear_extattr;
-        }
-
-        if (header->h_blocks != 1) {
-                if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx))
-                        goto clear_extattr;
-        }
-
-        region = region_create(0, fs->blocksize);
-        if (!region) {
-                fix_problem(ctx, PR_1_EA_ALLOC_REGION, pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return 0;
-        }
-        if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) {
-                if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
-                        goto clear_extattr;
-        }
-        
-        entry = (struct ext2_ext_attr_entry *)(header+1);
-        end = block_buf + fs->blocksize;
-        while ((char *)entry < end && *(__u32 *)entry) {
-                if (region_allocate(region, (char *)entry - (char *)header,
-                                   EXT2_EXT_ATTR_LEN(entry->e_name_len))) {
-                        if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
-                                goto clear_extattr;
-                }
-                if ((ctx->ext_attr_ver == 1 &&
-                     (entry->e_name_len == 0 || entry->e_name_index != 0)) ||
-                    (ctx->ext_attr_ver == 2 &&
-                     entry->e_name_index == 0)) {
-                        if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx))
-                                goto clear_extattr;
-                }
-                if (entry->e_value_block != 0) {
-                        if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx))
-                                goto clear_extattr;
-                }
-                if (entry->e_value_size &&
-                    region_allocate(region, entry->e_value_offs,
-                                    EXT2_EXT_ATTR_SIZE(entry->e_value_size))) {
-                        if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
-                                goto clear_extattr;
-                }
-                entry = EXT2_EXT_ATTR_NEXT(entry);
-        }
-        if (region_allocate(region, (char *)entry - (char *)header, 4)) {
-                if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx))
-                        goto clear_extattr;
-        }
-        region_free(region);
-
-        count = header->h_refcount - 1;
-        if (count)
-                ea_refcount_store(ctx->refcount, blk, count);
-        mark_block_used(ctx, blk);
-        ext2fs_fast_mark_block_bitmap(ctx->block_ea_map, blk);
-        
-        return 1;
-
-clear_extattr:
-        inode->i_file_acl = 0;
-        e2fsck_write_inode(ctx, ino, inode, "check_ext_attr");
-        return 0;
-}
-
-/* Returns 1 if bad htree, 0 if OK */
-static int handle_htree(e2fsck_t ctx, struct problem_context *pctx,
-                        ext2_ino_t ino EXT2FS_ATTR((unused)),
-                        struct ext2_inode *inode,
-                        char *block_buf)
-{
-        struct ext2_dx_root_info        *root;
-        ext2_filsys                     fs = ctx->fs;
-        errcode_t                       retval;
-        blk_t                           blk;
-
-        if ((!LINUX_S_ISDIR(inode->i_mode) &&
-             fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) ||
-            (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) &&
-             fix_problem(ctx, PR_1_HTREE_SET, pctx)))
-                return 1;
-
-        blk = inode->i_block[0];
-        if (((blk == 0) ||
-             (blk < fs->super->s_first_data_block) ||
-             (blk >= fs->super->s_blocks_count)) &&
-            fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
-                return 1;
-
-        retval = io_channel_read_blk(fs->io, blk, 1, block_buf);
-        if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
-                return 1;
-        
-        /* XXX should check that beginning matches a directory */
-        root = (struct ext2_dx_root_info *) (block_buf + 24);
-
-        if ((root->reserved_zero || root->info_length < 8) &&
-            fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
-                return 1;
-
-        pctx->num = root->hash_version;
-        if ((root->hash_version != EXT2_HASH_LEGACY) &&
-            (root->hash_version != EXT2_HASH_HALF_MD4) &&
-            (root->hash_version != EXT2_HASH_TEA) &&
-            fix_problem(ctx, PR_1_HTREE_HASHV, pctx))
-                return 1;
-                
-        if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) &&
-            fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx))
-                return 1;
-
-        pctx->num = root->indirect_levels;
-        if ((root->indirect_levels > 1) &&
-            fix_problem(ctx, PR_1_HTREE_DEPTH, pctx))
-                return 1;
-        
-        return 0;
-}
-
-/*
- * This subroutine is called on each inode to account for all of the
- * blocks used by that inode.
- */
-static void check_blocks(e2fsck_t ctx, struct problem_context *pctx,
-                         char *block_buf)
-{
-        ext2_filsys fs = ctx->fs;
-        struct process_block_struct pb;
-        ext2_ino_t      ino = pctx->ino;
-        struct ext2_inode *inode = pctx->inode;
-        int             bad_size = 0;
-        int             dirty_inode = 0;
-        __u64           size;
-        
-        pb.ino = ino;
-        pb.num_blocks = 0;
-        pb.last_block = -1;
-        pb.num_illegal_blocks = 0;
-        pb.suppress = 0; pb.clear = 0;
-        pb.fragmented = 0;
-        pb.compressed = 0;
-        pb.previous_block = 0;
-        pb.is_dir = LINUX_S_ISDIR(inode->i_mode);
-        pb.is_reg = LINUX_S_ISREG(inode->i_mode);
-        pb.max_blocks = 1 << (31 - fs->super->s_log_block_size);
-        pb.inode = inode;
-        pb.pctx = pctx;
-        pb.ctx = ctx;
-        pctx->ino = ino;
-        pctx->errcode = 0;
-
-        if (inode->i_flags & EXT2_COMPRBLK_FL) {
-                if (fs->super->s_feature_incompat &
-                    EXT2_FEATURE_INCOMPAT_COMPRESSION)
-                        pb.compressed = 1;
-                else {
-                        if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) {
-                                inode->i_flags &= ~EXT2_COMPRBLK_FL;
-                                dirty_inode++;
-                        }
-                }
-        }
-
-        if (inode->i_file_acl && check_ext_attr(ctx, pctx, block_buf))
-                pb.num_blocks++;
-
-        if (ext2fs_inode_has_valid_blocks(inode))
-                pctx->errcode = ext2fs_block_iterate2(fs, ino,
-                                       pb.is_dir ? BLOCK_FLAG_HOLE : 0,
-                                       block_buf, process_block, &pb);
-        end_problem_latch(ctx, PR_LATCH_BLOCK);
-        end_problem_latch(ctx, PR_LATCH_TOOBIG);
-        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                goto out;
-        if (pctx->errcode)
-                fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx);
-
-        if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group)
-                ctx->fs_fragmented++;
-
-        if (pb.clear) {
-                inode->i_links_count = 0;
-                ext2fs_icount_store(ctx->inode_link_info, ino, 0);
-                inode->i_dtime = time(0);
-                dirty_inode++;
-                ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
-                ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino);
-                ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
-                /*
-                 * The inode was probably partially accounted for
-                 * before processing was aborted, so we need to
-                 * restart the pass 1 scan.
-                 */
-                ctx->flags |= E2F_FLAG_RESTART;
-                goto out;
-        }
-        
-        if (inode->i_flags & EXT2_INDEX_FL) {
-                if (handle_htree(ctx, pctx, ino, inode, block_buf)) {
-                        inode->i_flags &= ~EXT2_INDEX_FL;
-                        dirty_inode++;
-                } else {
-#ifdef ENABLE_HTREE
-                        e2fsck_add_dx_dir(ctx, ino, pb.last_block+1);
-#endif
-                }
-        }
-        if (ctx->dirs_to_hash && pb.is_dir &&
-            !(inode->i_flags & EXT2_INDEX_FL) &&
-            ((inode->i_size / fs->blocksize) >= 3))
-                ext2fs_u32_list_add(ctx->dirs_to_hash, ino);
-                
-        if (!pb.num_blocks && pb.is_dir) {
-                if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) {
-                        inode->i_links_count = 0;
-                        ext2fs_icount_store(ctx->inode_link_info, ino, 0);
-                        inode->i_dtime = time(0);
-                        dirty_inode++;
-                        ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
-                        ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino);
-                        ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
-                        ctx->fs_directory_count--;
-                        goto out;
-                }
-        }
-
-        pb.num_blocks *= (fs->blocksize / 512);
-#if 0
-        printf("inode %u, i_size = %lu, last_block = %lld, i_blocks=%lu, num_blocks = %lu\n",
-               ino, inode->i_size, pb.last_block, inode->i_blocks,
-               pb.num_blocks);
-#endif
-        if (pb.is_dir) {
-                int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super);
-                if (nblock > (pb.last_block + 1))
-                        bad_size = 1;
-                else if (nblock < (pb.last_block + 1)) {
-                        if (((pb.last_block + 1) - nblock) >
-                            fs->super->s_prealloc_dir_blocks)
-                                bad_size = 2;
-                }
-        } else {
-                size = EXT2_I_SIZE(inode);
-                if ((pb.last_block >= 0) &&
-                    (size < (__u64) pb.last_block * fs->blocksize))
-                        bad_size = 3;
-                else if (size > ext2_max_sizes[fs->super->s_log_block_size])
-                        bad_size = 4;
-        }
-        /* i_size for symlinks is checked elsewhere */
-        if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) {
-                pctx->num = (pb.last_block+1) * fs->blocksize;
-                if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) {
-                        inode->i_size = pctx->num;
-                        if (!LINUX_S_ISDIR(inode->i_mode))
-                                inode->i_size_high = pctx->num >> 32;
-                        dirty_inode++;
-                }
-                pctx->num = 0;
-        }
-        if (LINUX_S_ISREG(inode->i_mode) &&
-            (inode->i_size_high || inode->i_size & 0x80000000UL))
-                ctx->large_files++;
-        if (pb.num_blocks != inode->i_blocks) {
-                pctx->num = pb.num_blocks;
-                if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) {
-                        inode->i_blocks = pb.num_blocks;
-                        dirty_inode++;
-                }
-                pctx->num = 0;
-        }
-out:
-        if (dirty_inode)
-                e2fsck_write_inode(ctx, ino, inode, "check_blocks");
-}
-
-#if 0
-/*
- * Helper function called by process block when an illegal block is
- * found.  It returns a description about why the block is illegal
- */
-static char *describe_illegal_block(ext2_filsys fs, blk_t block)
-{
-        blk_t   super;
-        int     i;
-        static char     problem[80];
-
-        super = fs->super->s_first_data_block;
-        strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block");
-        if (block < super) {
-                sprintf(problem, "< FIRSTBLOCK (%u)", super);
-                return(problem);
-        } else if (block >= fs->super->s_blocks_count) {
-                sprintf(problem, "> BLOCKS (%u)", fs->super->s_blocks_count);
-                return(problem);
-        }
-        for (i = 0; i < fs->group_desc_count; i++) {
-                if (block == super) {
-                        sprintf(problem, "is the superblock in group %d", i);
-                        break;
-                }
-                if (block > super &&
-                    block <= (super + fs->desc_blocks)) {
-                        sprintf(problem, "is in the group descriptors "
-                                "of group %d", i);
-                        break;
-                }
-                if (block == fs->group_desc[i].bg_block_bitmap) {
-                        sprintf(problem, "is the block bitmap of group %d", i);
-                        break;
-                }
-                if (block == fs->group_desc[i].bg_inode_bitmap) {
-                        sprintf(problem, "is the inode bitmap of group %d", i);
-                        break;
-                }
-                if (block >= fs->group_desc[i].bg_inode_table &&
-                    (block < fs->group_desc[i].bg_inode_table
-                     + fs->inode_blocks_per_group)) {
-                        sprintf(problem, "is in the inode table of group %d",
-                                i);
-                        break;
-                }
-                super += fs->super->s_blocks_per_group;
-        }
-        return(problem);
-}
-#endif
-
-/*
- * This is a helper function for check_blocks().
- */
-static int process_block(ext2_filsys fs,
-                  blk_t *block_nr,
-                  e2_blkcnt_t blockcnt,
-                  blk_t ref_block EXT2FS_ATTR((unused)),
-                  int ref_offset EXT2FS_ATTR((unused)),
-                  void *priv_data)
-{
-        struct process_block_struct *p;
-        struct problem_context *pctx;
-        blk_t   blk = *block_nr;
-        int     ret_code = 0;
-        int     problem = 0;
-        e2fsck_t        ctx;
-
-        p = (struct process_block_struct *) priv_data;
-        pctx = p->pctx;
-        ctx = p->ctx;
-
-        if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) {
-                /* todo: Check that the comprblk_fl is high, that the
-                   blkaddr pattern looks right (all non-holes up to
-                   first EXT2FS_COMPRESSED_BLKADDR, then all
-                   EXT2FS_COMPRESSED_BLKADDR up to end of cluster),
-                   that the feature_incompat bit is high, and that the
-                   inode is a regular file.  If we're doing a "full
-                   check" (a concept introduced to e2fsck by e2compr,
-                   meaning that we look at data blocks as well as
-                   metadata) then call some library routine that
-                   checks the compressed data.  I'll have to think
-                   about this, because one particularly important
-                   problem to be able to fix is to recalculate the
-                   cluster size if necessary.  I think that perhaps
-                   we'd better do most/all e2compr-specific checks
-                   separately, after the non-e2compr checks.  If not
-                   doing a full check, it may be useful to test that
-                   the personality is linux; e.g. if it isn't then
-                   perhaps this really is just an illegal block. */
-                return 0;
-        }
-
-        if (blk == 0) {
-                if (p->is_dir == 0) {
-                        /*
-                         * Should never happen, since only directories
-                         * get called with BLOCK_FLAG_HOLE
-                         */
-#if DEBUG_E2FSCK
-                        printf("process_block() called with blk == 0, "
-                               "blockcnt=%d, inode %lu???\n",
-                               blockcnt, p->ino);
-#endif
-                        return 0;
-                }
-                if (blockcnt < 0)
-                        return 0;
-                if (blockcnt * fs->blocksize < p->inode->i_size) {
-#if 0
-                        printf("Missing block (#%d) in directory inode %lu!\n",
-                               blockcnt, p->ino);
-#endif
-                        goto mark_dir;
-                }
-                return 0;
-        }
-
-#if 0
-        printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk,
-               blockcnt);
-#endif
-        
-        /*
-         * Simplistic fragmentation check.  We merely require that the
-         * file be contiguous.  (Which can never be true for really
-         * big files that are greater than a block group.)
-         */
-        if (!HOLE_BLKADDR(p->previous_block)) {
-                if (p->previous_block+1 != blk)
-                        p->fragmented = 1;
-        }
-        p->previous_block = blk;
-
-        if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size)))
-                problem = PR_1_TOOBIG_DIR;
-        if (p->is_reg && p->num_blocks+1 >= p->max_blocks)
-                problem = PR_1_TOOBIG_REG;
-        if (!p->is_dir && !p->is_reg && blockcnt > 0)
-                problem = PR_1_TOOBIG_SYMLINK;
-            
-        if (blk < fs->super->s_first_data_block ||
-            blk >= fs->super->s_blocks_count)
-                problem = PR_1_ILLEGAL_BLOCK_NUM;
-
-        if (problem) {
-                p->num_illegal_blocks++;
-                if (!p->suppress && (p->num_illegal_blocks % 12) == 0) {
-                        if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) {
-                                p->clear = 1;
-                                return BLOCK_ABORT;
-                        }
-                        if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) {
-                                p->suppress = 1;
-                                set_latch_flags(PR_LATCH_BLOCK,
-                                                PRL_SUPPRESS, 0);
-                        }
-                }
-                pctx->blk = blk;
-                pctx->blkcount = blockcnt;
-                if (fix_problem(ctx, problem, pctx)) {
-                        blk = *block_nr = 0;
-                        ret_code = BLOCK_CHANGED;
-                        goto mark_dir;
-                } else
-                        return 0;
-        }
-
-        if (p->ino == EXT2_RESIZE_INO) {
-                /* 
-                 * The resize inode has already be sanity checked
-                 * during pass #0 (the superblock checks).  All we
-                 * have to do is mark the double indirect block as
-                 * being in use; all of the other blocks are handled
-                 * by mark_table_blocks()).
-                 */
-                if (blockcnt == BLOCK_COUNT_DIND)
-                        mark_block_used(ctx, blk);
-        } else
-                mark_block_used(ctx, blk);
-        p->num_blocks++;
-        if (blockcnt >= 0)
-                p->last_block = blockcnt;
-mark_dir:
-        if (p->is_dir && (blockcnt >= 0)) {
-                pctx->errcode = ext2fs_add_dir_block(fs->dblist, p->ino,
-                                                    blk, blockcnt);
-                if (pctx->errcode) {
-                        pctx->blk = blk;
-                        pctx->num = blockcnt;
-                        fix_problem(ctx, PR_1_ADD_DBLOCK, pctx);
-                        /* Should never get here */
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return BLOCK_ABORT;
-                }
-        }
-        return ret_code;
-}
-
-static int process_bad_block(ext2_filsys fs,
-                      blk_t *block_nr,
-                      e2_blkcnt_t blockcnt,
-                      blk_t ref_block EXT2FS_ATTR((unused)),
-                      int ref_offset EXT2FS_ATTR((unused)),
-                      void *priv_data)
-{
-        struct process_block_struct *p;
-        blk_t           blk = *block_nr;
-        blk_t           first_block;
-        dgrp_t          i;
-        struct problem_context *pctx;
-        e2fsck_t        ctx;
-
-        /*
-         * Note: This function processes blocks for the bad blocks
-         * inode, which is never compressed.  So we don't use HOLE_BLKADDR().
-         */
-
-        if (!blk)
-                return 0;
-        
-        p = (struct process_block_struct *) priv_data;
-        ctx = p->ctx;
-        pctx = p->pctx;
-        
-        pctx->ino = EXT2_BAD_INO;
-        pctx->blk = blk;
-        pctx->blkcount = blockcnt;
-
-        if ((blk < fs->super->s_first_data_block) ||
-            (blk >= fs->super->s_blocks_count)) {
-                if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) {
-                        *block_nr = 0;
-                        return BLOCK_CHANGED;
-                } else
-                        return 0;
-        }
-
-        if (blockcnt < 0) {
-                if (ext2fs_test_block_bitmap(p->fs_meta_blocks, blk)) {
-                        p->bbcheck = 1;
-                        if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) {
-                                *block_nr = 0;
-                                return BLOCK_CHANGED;
-                        }
-                } else if (ext2fs_test_block_bitmap(ctx->block_found_map, 
-                                                    blk)) {
-                        p->bbcheck = 1;
-                        if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, 
-                                        pctx)) {
-                                *block_nr = 0;
-                                return BLOCK_CHANGED;
-                        }
-                        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                                return BLOCK_ABORT;
-                } else
-                        mark_block_used(ctx, blk);
-                return 0;
-        }
-#if 0 
-        printf ("DEBUG: Marking %u as bad.\n", blk);
-#endif
-        ctx->fs_badblocks_count++;
-        /*
-         * If the block is not used, then mark it as used and return.
-         * If it is already marked as found, this must mean that
-         * there's an overlap between the filesystem table blocks
-         * (bitmaps and inode table) and the bad block list.
-         */
-        if (!ext2fs_test_block_bitmap(ctx->block_found_map, blk)) {
-                ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
-                return 0;
-        }
-        /*
-         * Try to find the where the filesystem block was used...
-         */
-        first_block = fs->super->s_first_data_block;
-        
-        for (i = 0; i < fs->group_desc_count; i++ ) {
-                pctx->group = i;
-                pctx->blk = blk;
-                if (!ext2fs_bg_has_super(fs, i))
-                        goto skip_super;
-                if (blk == first_block) {
-                        if (i == 0) {
-                                if (fix_problem(ctx,
-                                                PR_1_BAD_PRIMARY_SUPERBLOCK,
-                                                pctx)) {
-                                        *block_nr = 0;
-                                        return BLOCK_CHANGED;
-                                }
-                                return 0;
-                        }
-                        fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx);
-                        return 0;
-                }
-                if ((blk > first_block) &&
-                    (blk <= first_block + fs->desc_blocks)) {
-                        if (i == 0) {
-                                pctx->blk = *block_nr;
-                                if (fix_problem(ctx,
-                        PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) {
-                                        *block_nr = 0;
-                                        return BLOCK_CHANGED;
-                                }
-                                return 0;
-                        }
-                        fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx);
-                        return 0;
-                }
-        skip_super:
-                if (blk == fs->group_desc[i].bg_block_bitmap) {
-                        if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) {
-                                ctx->invalid_block_bitmap_flag[i]++;
-                                ctx->invalid_bitmaps++;
-                        }
-                        return 0;
-                }
-                if (blk == fs->group_desc[i].bg_inode_bitmap) {
-                        if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) {
-                                ctx->invalid_inode_bitmap_flag[i]++;
-                                ctx->invalid_bitmaps++;
-                        }
-                        return 0;
-                }
-                if ((blk >= fs->group_desc[i].bg_inode_table) &&
-                    (blk < (fs->group_desc[i].bg_inode_table +
-                            fs->inode_blocks_per_group))) {
-                        /*
-                         * If there are bad blocks in the inode table,
-                         * the inode scan code will try to do
-                         * something reasonable automatically.
-                         */
-                        return 0;
-                }
-                first_block += fs->super->s_blocks_per_group;
-        }
-        /*
-         * If we've gotten to this point, then the only
-         * possibility is that the bad block inode meta data
-         * is using a bad block.
-         */
-        if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) ||
-            (blk == p->inode->i_block[EXT2_DIND_BLOCK]) ||
-            (blk == p->inode->i_block[EXT2_TIND_BLOCK])) {
-                p->bbcheck = 1;
-                if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) {
-                        *block_nr = 0;
-                        return BLOCK_CHANGED;
-                }
-                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                        return BLOCK_ABORT;
-                return 0;
-        }
-
-        pctx->group = -1;
-
-        /* Warn user that the block wasn't claimed */
-        fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx);
-
-        return 0;
-}
-
-static void new_table_block(e2fsck_t ctx, blk_t first_block, int group, 
-                            const char *name, int num, blk_t *new_block)
-{
-        ext2_filsys fs = ctx->fs;
-        blk_t           old_block = *new_block;
-        int             i;
-        char            *buf;
-        struct problem_context  pctx;
-
-        clear_problem_context(&pctx);
-
-        pctx.group = group;
-        pctx.blk = old_block;
-        pctx.str = name;
-
-        pctx.errcode = ext2fs_get_free_blocks(fs, first_block,
-                        first_block + fs->super->s_blocks_per_group,
-                                        num, ctx->block_found_map, new_block);
-        if (pctx.errcode) {
-                pctx.num = num;
-                fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx);
-                ext2fs_unmark_valid(fs);
-                return;
-        }
-        pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf);
-        if (pctx.errcode) {
-                fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx);
-                ext2fs_unmark_valid(fs);
-                return;
-        }
-        ext2fs_mark_super_dirty(fs);
-        fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
-        pctx.blk2 = *new_block;
-        fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO :
-                          PR_1_RELOC_TO), &pctx);
-        pctx.blk2 = 0;
-        for (i = 0; i < num; i++) {
-                pctx.blk = i;
-                ext2fs_mark_block_bitmap(ctx->block_found_map, (*new_block)+i);
-                if (old_block) {
-                        pctx.errcode = io_channel_read_blk(fs->io,
-                                   old_block + i, 1, buf);
-                        if (pctx.errcode)
-                                fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx);
-                } else
-                        memset(buf, 0, fs->blocksize);
-
-                pctx.blk = (*new_block) + i;
-                pctx.errcode = io_channel_write_blk(fs->io, pctx.blk,
-                                              1, buf);
-                if (pctx.errcode)
-                        fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx);
-        }
-        ext2fs_free_mem(&buf);
-}
-
-/*
- * This routine gets called at the end of pass 1 if bad blocks are
- * detected in the superblock, group descriptors, inode_bitmaps, or
- * block bitmaps.  At this point, all of the blocks have been mapped
- * out, so we can try to allocate new block(s) to replace the bad
- * blocks.
- */
-static void handle_fs_bad_blocks(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        dgrp_t          i;
-        int             first_block = fs->super->s_first_data_block;
-
-        for (i = 0; i < fs->group_desc_count; i++) {
-                if (ctx->invalid_block_bitmap_flag[i]) {
-                        new_table_block(ctx, first_block, i, _("block bitmap"),
-                                        1, &fs->group_desc[i].bg_block_bitmap);
-                }
-                if (ctx->invalid_inode_bitmap_flag[i]) {
-                        new_table_block(ctx, first_block, i, _("inode bitmap"),
-                                        1, &fs->group_desc[i].bg_inode_bitmap);
-                }
-                if (ctx->invalid_inode_table_flag[i]) {
-                        new_table_block(ctx, first_block, i, _("inode table"),
-                                        fs->inode_blocks_per_group, 
-                                        &fs->group_desc[i].bg_inode_table);
-                        ctx->flags |= E2F_FLAG_RESTART;
-                }
-                first_block += fs->super->s_blocks_per_group;
-        }
-        ctx->invalid_bitmaps = 0;
-}
-
-/*
- * This routine marks all blocks which are used by the superblock,
- * group descriptors, inode bitmaps, and block bitmaps.
- */
-static void mark_table_blocks(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        blk_t   block, b;
-        dgrp_t  i;
-        int     j;
-        struct problem_context pctx;
-        
-        clear_problem_context(&pctx);
-        
-        block = fs->super->s_first_data_block;
-        for (i = 0; i < fs->group_desc_count; i++) {
-                pctx.group = i;
-
-                ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map);
-
-                /*
-                 * Mark the blocks used for the inode table
-                 */
-                if (fs->group_desc[i].bg_inode_table) {
-                        for (j = 0, b = fs->group_desc[i].bg_inode_table;
-                             j < fs->inode_blocks_per_group;
-                             j++, b++) {
-                                if (ext2fs_test_block_bitmap(ctx->block_found_map,
-                                                             b)) {
-                                        pctx.blk = b;
-                                        if (fix_problem(ctx,
-                                                PR_1_ITABLE_CONFLICT, &pctx)) {
-                                                ctx->invalid_inode_table_flag[i]++;
-                                                ctx->invalid_bitmaps++;
-                                        }
-                                } else {
-                                    ext2fs_mark_block_bitmap(ctx->block_found_map,
-                                                             b);
-                                }
-                        }
-                }
-                            
-                /*
-                 * Mark block used for the block bitmap 
-                 */
-                if (fs->group_desc[i].bg_block_bitmap) {
-                        if (ext2fs_test_block_bitmap(ctx->block_found_map,
-                                     fs->group_desc[i].bg_block_bitmap)) {
-                                pctx.blk = fs->group_desc[i].bg_block_bitmap;
-                                if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) {
-                                        ctx->invalid_block_bitmap_flag[i]++;
-                                        ctx->invalid_bitmaps++;
-                                }
-                        } else {
-                            ext2fs_mark_block_bitmap(ctx->block_found_map,
-                                     fs->group_desc[i].bg_block_bitmap);
-                    }
-                        
-                }
-                /*
-                 * Mark block used for the inode bitmap 
-                 */
-                if (fs->group_desc[i].bg_inode_bitmap) {
-                        if (ext2fs_test_block_bitmap(ctx->block_found_map,
-                                     fs->group_desc[i].bg_inode_bitmap)) {
-                                pctx.blk = fs->group_desc[i].bg_inode_bitmap;
-                                if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) {
-                                        ctx->invalid_inode_bitmap_flag[i]++;
-                                        ctx->invalid_bitmaps++;
-                                } 
-                        } else {
-                            ext2fs_mark_block_bitmap(ctx->block_found_map,
-                                     fs->group_desc[i].bg_inode_bitmap);
-                        }
-                }
-                block += fs->super->s_blocks_per_group;
-        }
-}
-        
-/*
- * Thes subroutines short circuits ext2fs_get_blocks and
- * ext2fs_check_directory; we use them since we already have the inode
- * structure, so there's no point in letting the ext2fs library read
- * the inode again.
- */
-static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino,
-                                  blk_t *blocks)
-{
-        e2fsck_t ctx = (e2fsck_t) fs->priv_data;
-        int     i;
-        
-        if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
-                return EXT2_ET_CALLBACK_NOTHANDLED;
-
-        for (i=0; i < EXT2_N_BLOCKS; i++)
-                blocks[i] = ctx->stashed_inode->i_block[i];
-        return 0;
-}
-
-static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino,
-                                  struct ext2_inode *inode)
-{
-        e2fsck_t ctx = (e2fsck_t) fs->priv_data;
-
-        if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
-                return EXT2_ET_CALLBACK_NOTHANDLED;
-        *inode = *ctx->stashed_inode;
-        return 0;
-}
-
-static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino,
-                            struct ext2_inode *inode)
-{
-        e2fsck_t ctx = (e2fsck_t) fs->priv_data;
-
-        if ((ino == ctx->stashed_ino) && ctx->stashed_inode)
-                *ctx->stashed_inode = *inode;
-        return EXT2_ET_CALLBACK_NOTHANDLED;
-}
-
-static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino)
-{
-        e2fsck_t ctx = (e2fsck_t) fs->priv_data;
-
-        if ((ino != ctx->stashed_ino) || !ctx->stashed_inode)
-                return EXT2_ET_CALLBACK_NOTHANDLED;
-
-        if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode))
-                return EXT2_ET_NO_DIRECTORY;
-        return 0;
-}
-
-void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool)
-{
-        ext2_filsys fs = ctx->fs;
-
-        if (bool) {
-                fs->get_blocks = pass1_get_blocks;
-                fs->check_directory = pass1_check_directory;
-                fs->read_inode = pass1_read_inode;
-                fs->write_inode = pass1_write_inode;
-                ctx->stashed_ino = 0;
-        } else {
-                fs->get_blocks = 0;
-                fs->check_directory = 0;
-                fs->read_inode = 0;
-                fs->write_inode = 0;
-        }
-}
diff --git a/e2fsprogs/e2fsck/pass1b.c b/e2fsprogs/e2fsck/pass1b.c
deleted file mode 100644
index ff63807b7..000000000
--- a/e2fsprogs/e2fsck/pass1b.c
+++ /dev/null
@@ -1,805 +0,0 @@
-/*
- * pass1b.c --- Pass #1b of e2fsck
- *
- * This file contains pass1B, pass1C, and pass1D of e2fsck.  They are
- * only invoked if pass 1 discovered blocks which are in use by more
- * than one inode.
- * 
- * Pass1B scans the data blocks of all the inodes again, generating a
- * complete list of duplicate blocks and which inodes have claimed
- * them.
- *
- * Pass1C does a tree-traversal of the filesystem, to determine the
- * parent directories of these inodes.  This step is necessary so that
- * e2fsck can print out the pathnames of affected inodes.
- *
- * Pass1D is a reconciliation pass.  For each inode with duplicate
- * blocks, the user is prompted if s/he would like to clone the file
- * (so that the file gets a fresh copy of the duplicated blocks) or
- * simply to delete the file.
- * 
- * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- * 
- */
-
-#include <time.h>
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#endif
-
-#ifdef HAVE_INTTYPES_H
-#include <inttypes.h>
-#endif
-
-/* Needed for architectures where sizeof(int) != sizeof(void *) */
-#define INT_TO_VOIDPTR(val)  ((void *)(intptr_t)(val))
-#define VOIDPTR_TO_INT(ptr)  ((int)(intptr_t)(ptr))
-
-#include "e2fsck.h"
-
-#include "problem.h"
-#include "dict.h"
-
-/* Define an extension to the ext2 library's block count information */
-#define BLOCK_COUNT_EXTATTR     (-5)
-
-struct block_el {
-        blk_t   block;
-        struct block_el *next;
-};
-
-struct inode_el {
-        ext2_ino_t      inode;
-        struct inode_el *next;
-};
-
-struct dup_block {
-        int             num_bad;
-        struct inode_el *inode_list;
-};
-
-/*
- * This structure stores information about a particular inode which
- * is sharing blocks with other inodes.  This information is collected
- * to display to the user, so that the user knows what files he or she
- * is dealing with, when trying to decide how to resolve the conflict
- * of multiply-claimed blocks.
- */
-struct dup_inode {
-        ext2_ino_t              dir;
-        int                     num_dupblocks;
-        struct ext2_inode       inode;
-        struct block_el         *block_list;
-};
-
-static int process_pass1b_block(ext2_filsys fs, blk_t   *blocknr,
-                                e2_blkcnt_t blockcnt, blk_t ref_blk, 
-                                int ref_offset, void *priv_data);
-static void delete_file(e2fsck_t ctx, ext2_ino_t ino,
-                        struct dup_inode *dp, char *block_buf);
-static int clone_file(e2fsck_t ctx, ext2_ino_t ino,
-                      struct dup_inode *dp, char* block_buf);
-static int check_if_fs_block(e2fsck_t ctx, blk_t test_blk);
-
-static void pass1b(e2fsck_t ctx, char *block_buf);
-static void pass1c(e2fsck_t ctx, char *block_buf);
-static void pass1d(e2fsck_t ctx, char *block_buf);
-
-static int dup_inode_count = 0;
-
-static dict_t blk_dict, ino_dict;
-
-static ext2fs_inode_bitmap inode_dup_map;
-
-static int dict_int_cmp(const void *a, const void *b)
-{
-        intptr_t        ia, ib;
-
-        ia = (intptr_t)a;
-        ib = (intptr_t)b;
-
-        return (ia-ib);
-}
-
-/*
- * Add a duplicate block record
- */
-static void add_dupe(e2fsck_t ctx, ext2_ino_t ino, blk_t blk,
-                     struct ext2_inode *inode)
-{
-        dnode_t *n;
-        struct dup_block        *db;
-        struct dup_inode        *di;
-        struct block_el         *blk_el;
-        struct inode_el         *ino_el;
-
-        n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(blk));
-        if (n)
-                db = (struct dup_block *) dnode_get(n);
-        else {
-                db = (struct dup_block *) e2fsck_allocate_memory(ctx,
-                         sizeof(struct dup_block), "duplicate block header");
-                db->num_bad = 0;
-                db->inode_list = 0;
-                dict_alloc_insert(&blk_dict, INT_TO_VOIDPTR(blk), db);
-        }
-        ino_el = (struct inode_el *) e2fsck_allocate_memory(ctx,
-                         sizeof(struct inode_el), "inode element");
-        ino_el->inode = ino;
-        ino_el->next = db->inode_list;
-        db->inode_list = ino_el;
-        db->num_bad++;
-
-        n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(ino));
-        if (n)
-                di = (struct dup_inode *) dnode_get(n);
-        else {
-                di = (struct dup_inode *) e2fsck_allocate_memory(ctx,
-                         sizeof(struct dup_inode), "duplicate inode header");
-                di->dir = (ino == EXT2_ROOT_INO) ? EXT2_ROOT_INO : 0 ;
-                di->num_dupblocks = 0;
-                di->block_list = 0;
-                di->inode = *inode;
-                dict_alloc_insert(&ino_dict, INT_TO_VOIDPTR(ino), di);
-        }
-        blk_el = (struct block_el *) e2fsck_allocate_memory(ctx,
-                         sizeof(struct block_el), "block element");
-        blk_el->block = blk;
-        blk_el->next = di->block_list;
-        di->block_list = blk_el;
-        di->num_dupblocks++;
-}
-
-/*
- * Free a duplicate inode record
- */
-static void inode_dnode_free(dnode_t *node, 
-                             void *context EXT2FS_ATTR((unused)))
-{
-        struct dup_inode        *di;
-        struct block_el         *p, *next;
-
-        di = (struct dup_inode *) dnode_get(node);
-        for (p = di->block_list; p; p = next) {
-                next = p->next;
-                free(p);
-        }
-        free(node);
-}
-
-/*
- * Free a duplicate block record
- */
-static void block_dnode_free(dnode_t *node, 
-                             void *context EXT2FS_ATTR((unused)))
-{
-        struct dup_block        *db;
-        struct inode_el         *p, *next;
-
-        db = (struct dup_block *) dnode_get(node);
-        for (p = db->inode_list; p; p = next) {
-                next = p->next;
-                free(p);
-        }
-        free(node);
-}
-
-
-/*
- * Main procedure for handling duplicate blocks
- */
-void e2fsck_pass1_dupblocks(e2fsck_t ctx, char *block_buf)
-{
-        ext2_filsys             fs = ctx->fs;
-        struct problem_context  pctx;
-
-        clear_problem_context(&pctx);
-        
-        pctx.errcode = ext2fs_allocate_inode_bitmap(fs,
-                      _("multiply claimed inode map"), &inode_dup_map);
-        if (pctx.errcode) {
-                fix_problem(ctx, PR_1B_ALLOCATE_IBITMAP_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-
-        dict_init(&ino_dict, DICTCOUNT_T_MAX, dict_int_cmp);
-        dict_init(&blk_dict, DICTCOUNT_T_MAX, dict_int_cmp);
-        dict_set_allocator(&ino_dict, NULL, inode_dnode_free, NULL);
-        dict_set_allocator(&blk_dict, NULL, block_dnode_free, NULL);
-        
-        pass1b(ctx, block_buf);
-        pass1c(ctx, block_buf);
-        pass1d(ctx, block_buf);
-
-        /*
-         * Time to free all of the accumulated data structures that we
-         * don't need anymore.
-         */
-        dict_free_nodes(&ino_dict);
-        dict_free_nodes(&blk_dict);
-}
-
-/*
- * Scan the inodes looking for inodes that contain duplicate blocks.
- */
-struct process_block_struct {
-        e2fsck_t        ctx;
-        ext2_ino_t      ino;
-        int             dup_blocks;
-        struct ext2_inode *inode;
-        struct problem_context *pctx;
-};
-
-static void pass1b(e2fsck_t ctx, char *block_buf)
-{
-        ext2_filsys fs = ctx->fs;
-        ext2_ino_t ino;
-        struct ext2_inode inode;
-        ext2_inode_scan scan;
-        struct process_block_struct pb;
-        struct problem_context pctx;
-        
-        clear_problem_context(&pctx);
-        
-        if (!(ctx->options & E2F_OPT_PREEN))
-                fix_problem(ctx, PR_1B_PASS_HEADER, &pctx);
-        pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks,
-                                              &scan);
-        if (pctx.errcode) {
-                fix_problem(ctx, PR_1B_ISCAN_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        ctx->stashed_inode = &inode;
-        pb.ctx = ctx;
-        pb.pctx = &pctx;
-        pctx.str = "pass1b";
-        while (1) {
-                pctx.errcode = ext2fs_get_next_inode(scan, &ino, &inode);
-                if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE)
-                        continue;
-                if (pctx.errcode) {
-                        fix_problem(ctx, PR_1B_ISCAN_ERROR, &pctx);
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return;
-                }
-                if (!ino)
-                        break;
-                pctx.ino = ctx->stashed_ino = ino;
-                if ((ino != EXT2_BAD_INO) &&
-                    !ext2fs_test_inode_bitmap(ctx->inode_used_map, ino))
-                        continue;
-
-                pb.ino = ino;
-                pb.dup_blocks = 0;
-                pb.inode = &inode;
-
-                if (ext2fs_inode_has_valid_blocks(&inode) ||
-                    (ino == EXT2_BAD_INO))
-                        pctx.errcode = ext2fs_block_iterate2(fs, ino,
-                                     0, block_buf, process_pass1b_block, &pb);
-                if (inode.i_file_acl)
-                        process_pass1b_block(fs, &inode.i_file_acl,
-                                             BLOCK_COUNT_EXTATTR, 0, 0, &pb);
-                if (pb.dup_blocks) {
-                        end_problem_latch(ctx, PR_LATCH_DBLOCK);
-                        if (ino >= EXT2_FIRST_INODE(fs->super) ||
-                            ino == EXT2_ROOT_INO)
-                                dup_inode_count++;
-                }
-                if (pctx.errcode)
-                        fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx);
-        }
-        ext2fs_close_inode_scan(scan);
-        e2fsck_use_inode_shortcuts(ctx, 0);
-}
-
-static int process_pass1b_block(ext2_filsys fs EXT2FS_ATTR((unused)),
-                                blk_t   *block_nr,
-                                e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
-                                blk_t ref_blk EXT2FS_ATTR((unused)), 
-                                int ref_offset EXT2FS_ATTR((unused)),
-                                void *priv_data)
-{
-        struct process_block_struct *p;
-        e2fsck_t ctx;
-
-        if (HOLE_BLKADDR(*block_nr))
-                return 0;
-        p = (struct process_block_struct *) priv_data;
-        ctx = p->ctx;
-        
-        if (!ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr))
-                return 0;
-        
-        /* OK, this is a duplicate block */
-        if (p->ino != EXT2_BAD_INO) {
-                p->pctx->blk = *block_nr;
-                fix_problem(ctx, PR_1B_DUP_BLOCK, p->pctx);
-        }
-        p->dup_blocks++;
-        ext2fs_mark_inode_bitmap(inode_dup_map, p->ino);
-
-        add_dupe(ctx, p->ino, *block_nr, p->inode);
-        
-        return 0;
-}
-
-/*
- * Pass 1c: Scan directories for inodes with duplicate blocks.  This
- * is used so that we can print pathnames when prompting the user for
- * what to do.
- */
-struct search_dir_struct {
-        int             count;
-        ext2_ino_t      first_inode;
-        ext2_ino_t      max_inode;
-};
-
-static int search_dirent_proc(ext2_ino_t dir, int entry,
-                              struct ext2_dir_entry *dirent,
-                              int offset EXT2FS_ATTR((unused)), 
-                              int blocksize EXT2FS_ATTR((unused)),
-                              char *buf EXT2FS_ATTR((unused)), 
-                              void *priv_data)
-{
-        struct search_dir_struct *sd;
-        struct dup_inode        *p;
-        dnode_t                 *n;
-
-        sd = (struct search_dir_struct *) priv_data;
-
-        if (dirent->inode > sd->max_inode)
-                /* Should abort this inode, but not everything */
-                return 0;       
-
-        if ((dirent->inode < sd->first_inode) || (entry < DIRENT_OTHER_FILE) ||
-            !ext2fs_test_inode_bitmap(inode_dup_map, dirent->inode))
-                return 0;
-
-        n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(dirent->inode));
-        if (!n)
-                return 0;
-        p = (struct dup_inode *) dnode_get(n);
-        p->dir = dir;
-        sd->count--;
-
-        return(sd->count ? 0 : DIRENT_ABORT);
-}
-
-
-static void pass1c(e2fsck_t ctx, char *block_buf)
-{
-        ext2_filsys fs = ctx->fs;
-        struct search_dir_struct sd;
-        struct problem_context pctx;
-
-        clear_problem_context(&pctx);
-
-        if (!(ctx->options & E2F_OPT_PREEN))
-                fix_problem(ctx, PR_1C_PASS_HEADER, &pctx);
-
-        /*
-         * Search through all directories to translate inodes to names
-         * (by searching for the containing directory for that inode.)
-         */
-        sd.count = dup_inode_count;
-        sd.first_inode = EXT2_FIRST_INODE(fs->super);
-        sd.max_inode = fs->super->s_inodes_count;
-        ext2fs_dblist_dir_iterate(fs->dblist, 0, block_buf,
-                                  search_dirent_proc, &sd);
-}       
-
-static void pass1d(e2fsck_t ctx, char *block_buf)
-{
-        ext2_filsys fs = ctx->fs;
-        struct dup_inode        *p, *t;
-        struct dup_block        *q;
-        ext2_ino_t              *shared, ino;
-        int     shared_len;
-        int     i;
-        int     file_ok;
-        int     meta_data = 0;
-        struct problem_context pctx;
-        dnode_t *n, *m;
-        struct block_el *s;
-        struct inode_el *r;
-        
-        clear_problem_context(&pctx);
-        
-        if (!(ctx->options & E2F_OPT_PREEN))
-                fix_problem(ctx, PR_1D_PASS_HEADER, &pctx);
-        e2fsck_read_bitmaps(ctx);
-
-        pctx.num = dup_inode_count; /* dict_count(&ino_dict); */
-        fix_problem(ctx, PR_1D_NUM_DUP_INODES, &pctx);
-        shared = (ext2_ino_t *) e2fsck_allocate_memory(ctx,
-                                sizeof(ext2_ino_t) * dict_count(&ino_dict),
-                                "Shared inode list");
-        for (n = dict_first(&ino_dict); n; n = dict_next(&ino_dict, n)) {
-                p = (struct dup_inode *) dnode_get(n);
-                shared_len = 0;
-                file_ok = 1;
-                ino = (ext2_ino_t)VOIDPTR_TO_INT(dnode_getkey(n));
-                if (ino == EXT2_BAD_INO)
-                        continue;
-
-                /*
-                 * Find all of the inodes which share blocks with this
-                 * one.  First we find all of the duplicate blocks
-                 * belonging to this inode, and then search each block
-                 * get the list of inodes, and merge them together.
-                 */
-                for (s = p->block_list; s; s = s->next) {
-                        m = dict_lookup(&blk_dict, INT_TO_VOIDPTR(s->block));
-                        if (!m)
-                                continue; /* Should never happen... */
-                        q = (struct dup_block *) dnode_get(m);
-                        if (q->num_bad > 1)
-                                file_ok = 0;
-                        if (check_if_fs_block(ctx, s->block)) {
-                                file_ok = 0;
-                                meta_data = 1;
-                        }
-                        
-                        /*
-                         * Add all inodes used by this block to the
-                         * shared[] --- which is a unique list, so
-                         * if an inode is already in shared[], don't
-                         * add it again.
-                         */
-                        for (r = q->inode_list; r; r = r->next) {
-                                if (r->inode == ino)
-                                        continue;
-                                for (i = 0; i < shared_len; i++)
-                                        if (shared[i] == r->inode)
-                                                break;
-                                if (i == shared_len) {
-                                        shared[shared_len++] = r->inode;
-                                }
-                        }
-                }
-
-                /*
-                 * Report the inode that we are working on
-                 */
-                pctx.inode = &p->inode;
-                pctx.ino = ino;
-                pctx.dir = p->dir;
-                pctx.blkcount = p->num_dupblocks;
-                pctx.num = meta_data ? shared_len+1 : shared_len;
-                fix_problem(ctx, PR_1D_DUP_FILE, &pctx);
-                pctx.blkcount = 0;
-                pctx.num = 0;
-                
-                if (meta_data)
-                        fix_problem(ctx, PR_1D_SHARE_METADATA, &pctx);
-                
-                for (i = 0; i < shared_len; i++) {
-                        m = dict_lookup(&ino_dict, INT_TO_VOIDPTR(shared[i]));
-                        if (!m)
-                                continue; /* should never happen */
-                        t = (struct dup_inode *) dnode_get(m);
-                        /*
-                         * Report the inode that we are sharing with
-                         */
-                        pctx.inode = &t->inode;
-                        pctx.ino = shared[i];
-                        pctx.dir = t->dir;
-                        fix_problem(ctx, PR_1D_DUP_FILE_LIST, &pctx);
-                }
-                if (file_ok) {
-                        fix_problem(ctx, PR_1D_DUP_BLOCKS_DEALT, &pctx);
-                        continue;
-                }
-                if (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))
-                        delete_file(ctx, ino, p, block_buf);
-                else
-                        ext2fs_unmark_valid(fs);
-        }
-        ext2fs_free_mem(&shared);
-}
-
-/*
- * Drop the refcount on the dup_block structure, and clear the entry
- * in the block_dup_map if appropriate.
- */
-static void decrement_badcount(e2fsck_t ctx, blk_t block, struct dup_block *p)
-{
-        p->num_bad--;
-        if (p->num_bad <= 0 ||
-            (p->num_bad == 1 && !check_if_fs_block(ctx, block)))
-                ext2fs_unmark_block_bitmap(ctx->block_dup_map, block);
-}
-
-static int delete_file_block(ext2_filsys fs,
-                             blk_t      *block_nr,
-                             e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
-                             blk_t ref_block EXT2FS_ATTR((unused)),
-                             int ref_offset EXT2FS_ATTR((unused)),
-                             void *priv_data)
-{
-        struct process_block_struct *pb;
-        struct dup_block *p;
-        dnode_t *n;
-        e2fsck_t ctx;
-
-        pb = (struct process_block_struct *) priv_data;
-        ctx = pb->ctx;
-
-        if (HOLE_BLKADDR(*block_nr))
-                return 0;
-
-        if (ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr)) {
-                n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(*block_nr));
-                if (n) {
-                        p = (struct dup_block *) dnode_get(n);
-                        decrement_badcount(ctx, *block_nr, p);
-                } else
-                        com_err("delete_file_block", 0,
-                            _("internal error; can't find dup_blk for %d\n"),
-                                *block_nr);
-        } else {
-                ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr);
-                ext2fs_block_alloc_stats(fs, *block_nr, -1);
-        }
-                
-        return 0;
-}
-                
-static void delete_file(e2fsck_t ctx, ext2_ino_t ino,
-                        struct dup_inode *dp, char* block_buf)
-{
-        ext2_filsys fs = ctx->fs;
-        struct process_block_struct pb;
-        struct ext2_inode       inode;
-        struct problem_context  pctx;
-        unsigned int            count;
-
-        clear_problem_context(&pctx);
-        pctx.ino = pb.ino = ino;
-        pb.dup_blocks = dp->num_dupblocks;
-        pb.ctx = ctx;
-        pctx.str = "delete_file";
-
-        e2fsck_read_inode(ctx, ino, &inode, "delete_file");
-        if (ext2fs_inode_has_valid_blocks(&inode))
-                pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf,
-                                                     delete_file_block, &pb);
-        if (pctx.errcode)
-                fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx);
-        ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
-        ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
-        if (ctx->inode_bad_map)
-                ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino);
-        ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode));
-
-        /* Inode may have changed by block_iterate, so reread it */
-        e2fsck_read_inode(ctx, ino, &inode, "delete_file");
-        inode.i_links_count = 0;
-        inode.i_dtime = time(0);
-        if (inode.i_file_acl &&
-            (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) {
-                count = 1;
-                pctx.errcode = ext2fs_adjust_ea_refcount(fs, inode.i_file_acl,
-                                                   block_buf, -1, &count);
-                if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) {
-                        pctx.errcode = 0;
-                        count = 1;
-                }
-                if (pctx.errcode) {
-                        pctx.blk = inode.i_file_acl;
-                        fix_problem(ctx, PR_1B_ADJ_EA_REFCOUNT, &pctx);
-                }
-                /*
-                 * If the count is zero, then arrange to have the
-                 * block deleted.  If the block is in the block_dup_map,
-                 * also call delete_file_block since it will take care
-                 * of keeping the accounting straight.
-                 */
-                if ((count == 0) ||
-                    ext2fs_test_block_bitmap(ctx->block_dup_map,
-                                             inode.i_file_acl)) 
-                        delete_file_block(fs, &inode.i_file_acl,
-                                          BLOCK_COUNT_EXTATTR, 0, 0, &pb);
-        }
-        e2fsck_write_inode(ctx, ino, &inode, "delete_file");
-}
-
-struct clone_struct {
-        errcode_t       errcode;
-        ext2_ino_t      dir;
-        char    *buf;
-        e2fsck_t ctx;
-};
-
-static int clone_file_block(ext2_filsys fs,
-                            blk_t       *block_nr,
-                            e2_blkcnt_t blockcnt,
-                            blk_t ref_block EXT2FS_ATTR((unused)),
-                            int ref_offset EXT2FS_ATTR((unused)),
-                            void *priv_data)
-{
-        struct dup_block *p;
-        blk_t   new_block;
-        errcode_t       retval;
-        struct clone_struct *cs = (struct clone_struct *) priv_data;
-        dnode_t *n;
-        e2fsck_t ctx;
-
-        ctx = cs->ctx;
-        
-        if (HOLE_BLKADDR(*block_nr))
-                return 0;
-
-        if (ext2fs_test_block_bitmap(ctx->block_dup_map, *block_nr)) {
-                n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(*block_nr));
-                if (n) {
-                        p = (struct dup_block *) dnode_get(n);
-                        retval = ext2fs_new_block(fs, 0, ctx->block_found_map,
-                                                  &new_block);
-                        if (retval) {
-                                cs->errcode = retval;
-                                return BLOCK_ABORT;
-                        }
-                        if (cs->dir && (blockcnt >= 0)) {
-                                retval = ext2fs_set_dir_block(fs->dblist,
-                                      cs->dir, new_block, blockcnt);
-                                if (retval) {
-                                        cs->errcode = retval;
-                                        return BLOCK_ABORT;
-                                }
-                        }
-#if 0
-                        printf("Cloning block %u to %u\n", *block_nr,
-                               new_block);
-#endif
-                        retval = io_channel_read_blk(fs->io, *block_nr, 1,
-                                                     cs->buf);
-                        if (retval) {
-                                cs->errcode = retval;
-                                return BLOCK_ABORT;
-                        }
-                        retval = io_channel_write_blk(fs->io, new_block, 1,
-                                                      cs->buf);
-                        if (retval) {
-                                cs->errcode = retval;
-                                return BLOCK_ABORT;
-                        }
-                        decrement_badcount(ctx, *block_nr, p);
-                        *block_nr = new_block;
-                        ext2fs_mark_block_bitmap(ctx->block_found_map,
-                                                 new_block);
-                        ext2fs_mark_block_bitmap(fs->block_map, new_block);
-                        return BLOCK_CHANGED;
-                } else
-                        com_err("clone_file_block", 0,
-                            _("internal error; can't find dup_blk for %d\n"),
-                                *block_nr);
-        }
-        return 0;
-}
-                
-static int clone_file(e2fsck_t ctx, ext2_ino_t ino,
-                      struct dup_inode *dp, char* block_buf)
-{
-        ext2_filsys fs = ctx->fs;
-        errcode_t       retval;
-        struct clone_struct cs;
-        struct problem_context  pctx;
-        blk_t           blk;
-        dnode_t         *n;
-        struct inode_el *ino_el;
-        struct dup_block        *db;
-        struct dup_inode        *di;
-
-        clear_problem_context(&pctx);
-        cs.errcode = 0;
-        cs.dir = 0;
-        cs.ctx = ctx;
-        retval = ext2fs_get_mem(fs->blocksize, &cs.buf);
-        if (retval)
-                return retval;
-
-        if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, ino))
-                cs.dir = ino;
-
-        pctx.ino = ino;
-        pctx.str = "clone_file";
-        if (ext2fs_inode_has_valid_blocks(&dp->inode))
-                pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf,
-                                                     clone_file_block, &cs);
-        ext2fs_mark_bb_dirty(fs);
-        if (pctx.errcode) {
-                fix_problem(ctx, PR_1B_BLOCK_ITERATE, &pctx);
-                retval = pctx.errcode;
-                goto errout;
-        }
-        if (cs.errcode) {
-                com_err("clone_file", cs.errcode,
-                        _("returned from clone_file_block"));
-                retval = cs.errcode;
-                goto errout;
-        }
-        /* The inode may have changed on disk, so we have to re-read it */
-        e2fsck_read_inode(ctx, ino, &dp->inode, "clone file EA");
-        blk = dp->inode.i_file_acl;
-        if (blk && (clone_file_block(fs, &dp->inode.i_file_acl,
-                                     BLOCK_COUNT_EXTATTR, 0, 0, &cs) ==
-                    BLOCK_CHANGED)) {
-                e2fsck_write_inode(ctx, ino, &dp->inode, "clone file EA");
-                /*
-                 * If we cloned the EA block, find all other inodes
-                 * which refered to that EA block, and modify
-                 * them to point to the new EA block.
-                 */
-                n = dict_lookup(&blk_dict, INT_TO_VOIDPTR(blk));
-                db = (struct dup_block *) dnode_get(n);
-                for (ino_el = db->inode_list; ino_el; ino_el = ino_el->next) {
-                        if (ino_el->inode == ino)
-                                continue;
-                        n = dict_lookup(&ino_dict, INT_TO_VOIDPTR(ino_el->inode));
-                        di = (struct dup_inode *) dnode_get(n);
-                        if (di->inode.i_file_acl == blk) {
-                                di->inode.i_file_acl = dp->inode.i_file_acl;
-                                e2fsck_write_inode(ctx, ino_el->inode,
-                                           &di->inode, "clone file EA");
-                                decrement_badcount(ctx, blk, db);
-                        }
-                }
-        }
-        retval = 0;
-errout:
-        ext2fs_free_mem(&cs.buf);
-        return retval;
-}
-
-/*
- * This routine returns 1 if a block overlaps with one of the superblocks,
- * group descriptors, inode bitmaps, or block bitmaps.
- */
-static int check_if_fs_block(e2fsck_t ctx, blk_t test_block)
-{
-        ext2_filsys fs = ctx->fs;
-        blk_t   block;
-        dgrp_t  i;
-        
-        block = fs->super->s_first_data_block;
-        for (i = 0; i < fs->group_desc_count; i++) {
-
-                /* Check superblocks/block group descriptros */
-                if (ext2fs_bg_has_super(fs, i)) {
-                        if (test_block >= block &&
-                            (test_block <= block + fs->desc_blocks))
-                                return 1;
-                }
-                
-                /* Check the inode table */
-                if ((fs->group_desc[i].bg_inode_table) &&
-                    (test_block >= fs->group_desc[i].bg_inode_table) &&
-                    (test_block < (fs->group_desc[i].bg_inode_table +
-                                   fs->inode_blocks_per_group)))
-                        return 1;
-
-                /* Check the bitmap blocks */
-                if ((test_block == fs->group_desc[i].bg_block_bitmap) ||
-                    (test_block == fs->group_desc[i].bg_inode_bitmap))
-                        return 1;
-                
-                block += fs->super->s_blocks_per_group;
-        }
-        return 0;
-}
diff --git a/e2fsprogs/e2fsck/pass2.c b/e2fsprogs/e2fsck/pass2.c
deleted file mode 100644
index 69599fffc..000000000
--- a/e2fsprogs/e2fsck/pass2.c
+++ /dev/null
@@ -1,1414 +0,0 @@
-/*
- * pass2.c --- check directory structure
- * 
- * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- * 
- * Pass 2 of e2fsck iterates through all active directory inodes, and
- * applies to following tests to each directory entry in the directory
- * blocks in the inodes:
- *
- *      - The length of the directory entry (rec_len) should be at
- *              least 8 bytes, and no more than the remaining space
- *              left in the directory block.
- *      - The length of the name in the directory entry (name_len)
- *              should be less than (rec_len - 8).  
- *      - The inode number in the directory entry should be within
- *              legal bounds.
- *      - The inode number should refer to a in-use inode.
- *      - The first entry should be '.', and its inode should be
- *              the inode of the directory.
- *      - The second entry should be '..'.
- *
- * To minimize disk seek time, the directory blocks are processed in
- * sorted order of block numbers.
- *
- * Pass 2 also collects the following information:
- *      - The inode numbers of the subdirectories for each directory.
- *
- * Pass 2 relies on the following information from previous passes:
- *      - The directory information collected in pass 1.
- *      - The inode_used_map bitmap
- *      - The inode_bad_map bitmap
- *      - The inode_dir_map bitmap
- *
- * Pass 2 frees the following data structures
- *      - The inode_bad_map bitmap
- *      - The inode_reg_map bitmap
- */
-
-#define _GNU_SOURCE 1 /* get strnlen() */
-#include <string.h>
-
-#include "e2fsck.h"
-#include "problem.h"
-#include "dict.h"
-
-#ifdef NO_INLINE_FUNCS
-#define _INLINE_
-#else
-#define _INLINE_ inline
-#endif
-
-/* #define DX_DEBUG */
-
-/*
- * Keeps track of how many times an inode is referenced.
- */
-static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf);
-static int check_dir_block(ext2_filsys fs,
-                           struct ext2_db_entry *dir_blocks_info,
-                           void *priv_data);
-static int allocate_dir_block(e2fsck_t ctx,
-                              struct ext2_db_entry *dir_blocks_info,
-                              char *buf, struct problem_context *pctx);
-static int update_dir_block(ext2_filsys fs,
-                            blk_t       *block_nr,
-                            e2_blkcnt_t blockcnt,
-                            blk_t       ref_block,
-                            int         ref_offset, 
-                            void        *priv_data);
-static void clear_htree(e2fsck_t ctx, ext2_ino_t ino);
-static int htree_depth(struct dx_dir_info *dx_dir,
-                       struct dx_dirblock_info *dx_db);
-static EXT2_QSORT_TYPE special_dir_block_cmp(const void *a, const void *b);
-
-struct check_dir_struct {
-        char *buf;
-        struct problem_context  pctx;
-        int     count, max;
-        e2fsck_t ctx;
-};      
-
-void e2fsck_pass2(e2fsck_t ctx)
-{
-        struct ext2_super_block *sb = ctx->fs->super;
-        struct problem_context  pctx;
-        ext2_filsys             fs = ctx->fs;
-        char                    *buf;
-#ifdef RESOURCE_TRACK
-        struct resource_track   rtrack;
-#endif
-        struct dir_info         *dir;
-        struct check_dir_struct cd;
-        struct dx_dir_info      *dx_dir;
-        struct dx_dirblock_info *dx_db, *dx_parent;
-        int                     b;
-        int                     i, depth;
-        problem_t               code;
-        int                     bad_dir;
-
-#ifdef RESOURCE_TRACK
-        init_resource_track(&rtrack);
-#endif
-
-        clear_problem_context(&cd.pctx);
-
-#ifdef MTRACE
-        mtrace_print("Pass 2");
-#endif
-
-        if (!(ctx->options & E2F_OPT_PREEN))
-                fix_problem(ctx, PR_2_PASS_HEADER, &cd.pctx);
-
-        cd.pctx.errcode = ext2fs_create_icount2(fs, EXT2_ICOUNT_OPT_INCREMENT,
-                                                0, ctx->inode_link_info,
-                                                &ctx->inode_count);
-        if (cd.pctx.errcode) {
-                fix_problem(ctx, PR_2_ALLOCATE_ICOUNT, &cd.pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        buf = (char *) e2fsck_allocate_memory(ctx, 2*fs->blocksize,
-                                              "directory scan buffer");
-
-        /*
-         * Set up the parent pointer for the root directory, if
-         * present.  (If the root directory is not present, we will
-         * create it in pass 3.)
-         */
-        dir = e2fsck_get_dir_info(ctx, EXT2_ROOT_INO);
-        if (dir)
-                dir->parent = EXT2_ROOT_INO;
-
-        cd.buf = buf;
-        cd.ctx = ctx;
-        cd.count = 1;
-        cd.max = ext2fs_dblist_count(fs->dblist);
-
-        if (ctx->progress)
-                (void) (ctx->progress)(ctx, 2, 0, cd.max);
-
-        if (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX)
-                ext2fs_dblist_sort(fs->dblist, special_dir_block_cmp);
-        
-        cd.pctx.errcode = ext2fs_dblist_iterate(fs->dblist, check_dir_block,
-                                                &cd);
-        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                return;
-        if (cd.pctx.errcode) {
-                fix_problem(ctx, PR_2_DBLIST_ITERATE, &cd.pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-
-#ifdef ENABLE_HTREE
-        for (i=0; (dx_dir = e2fsck_dx_dir_info_iter(ctx, &i)) != 0;) {
-                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                        return;
-                if (dx_dir->numblocks == 0)
-                        continue;
-                clear_problem_context(&pctx);
-                bad_dir = 0;
-                pctx.dir = dx_dir->ino;
-                dx_db = dx_dir->dx_block;
-                if (dx_db->flags & DX_FLAG_REFERENCED)
-                        dx_db->flags |= DX_FLAG_DUP_REF;
-                else
-                        dx_db->flags |= DX_FLAG_REFERENCED;
-                /*
-                 * Find all of the first and last leaf blocks, and
-                 * update their parent's min and max hash values
-                 */
-                for (b=0, dx_db = dx_dir->dx_block;
-                     b < dx_dir->numblocks;
-                     b++, dx_db++) {
-                        if ((dx_db->type != DX_DIRBLOCK_LEAF) ||
-                            !(dx_db->flags & (DX_FLAG_FIRST | DX_FLAG_LAST)))
-                                continue;
-                        dx_parent = &dx_dir->dx_block[dx_db->parent];
-                        /*
-                         * XXX Make sure dx_parent->min_hash > dx_db->min_hash
-                         */
-                        if (dx_db->flags & DX_FLAG_FIRST)
-                                dx_parent->min_hash = dx_db->min_hash;
-                        /*
-                         * XXX Make sure dx_parent->max_hash < dx_db->max_hash
-                         */
-                        if (dx_db->flags & DX_FLAG_LAST)
-                                dx_parent->max_hash = dx_db->max_hash;
-                }
-                                
-                for (b=0, dx_db = dx_dir->dx_block;
-                     b < dx_dir->numblocks;
-                     b++, dx_db++) {
-                        pctx.blkcount = b;
-                        pctx.group = dx_db->parent;
-                        code = 0;
-                        if (!(dx_db->flags & DX_FLAG_FIRST) &&
-                            (dx_db->min_hash < dx_db->node_min_hash)) {
-                                pctx.blk = dx_db->min_hash;
-                                pctx.blk2 = dx_db->node_min_hash;
-                                code = PR_2_HTREE_MIN_HASH;
-                                fix_problem(ctx, code, &pctx);
-                                bad_dir++;
-                        }
-                        if (dx_db->type == DX_DIRBLOCK_LEAF) {
-                                depth = htree_depth(dx_dir, dx_db);
-                                if (depth != dx_dir->depth) {
-                                        code = PR_2_HTREE_BAD_DEPTH;
-                                        fix_problem(ctx, code, &pctx);
-                                        bad_dir++;
-                                }
-                        }
-                        /*
-                         * This test doesn't apply for the root block 
-                         * at block #0
-                         */
-                        if (b &&
-                            (dx_db->max_hash > dx_db->node_max_hash)) {
-                                pctx.blk = dx_db->max_hash;
-                                pctx.blk2 = dx_db->node_max_hash;
-                                code = PR_2_HTREE_MAX_HASH;
-                                fix_problem(ctx, code, &pctx);
-                                bad_dir++;
-                        }
-                        if (!(dx_db->flags & DX_FLAG_REFERENCED)) {
-                                code = PR_2_HTREE_NOTREF;
-                                fix_problem(ctx, code, &pctx);
-                                bad_dir++;
-                        } else if (dx_db->flags & DX_FLAG_DUP_REF) {
-                                code = PR_2_HTREE_DUPREF;
-                                fix_problem(ctx, code, &pctx);
-                                bad_dir++;
-                        }
-                        if (code == 0)
-                                continue;
-                }
-                if (bad_dir && fix_problem(ctx, PR_2_HTREE_CLEAR, &pctx)) {
-                        clear_htree(ctx, dx_dir->ino);
-                        dx_dir->numblocks = 0;
-                }
-        }
-#endif
-        ext2fs_free_mem(&buf);
-        ext2fs_free_dblist(fs->dblist);
-
-        if (ctx->inode_bad_map) {
-                ext2fs_free_inode_bitmap(ctx->inode_bad_map);
-                ctx->inode_bad_map = 0;
-        }
-        if (ctx->inode_reg_map) {
-                ext2fs_free_inode_bitmap(ctx->inode_reg_map);
-                ctx->inode_reg_map = 0;
-        }
-
-        clear_problem_context(&pctx);
-        if (ctx->large_files) {
-                if (!(sb->s_feature_ro_compat &
-                      EXT2_FEATURE_RO_COMPAT_LARGE_FILE) &&
-                    fix_problem(ctx, PR_2_FEATURE_LARGE_FILES, &pctx)) {
-                        sb->s_feature_ro_compat |=
-                                EXT2_FEATURE_RO_COMPAT_LARGE_FILE;
-                        ext2fs_mark_super_dirty(fs);
-                }
-                if (sb->s_rev_level == EXT2_GOOD_OLD_REV &&
-                    fix_problem(ctx, PR_1_FS_REV_LEVEL, &pctx)) {
-                        ext2fs_update_dynamic_rev(fs);
-                        ext2fs_mark_super_dirty(fs);
-                }
-        } else if (!ctx->large_files &&
-            (sb->s_feature_ro_compat &
-              EXT2_FEATURE_RO_COMPAT_LARGE_FILE)) {
-                if (fs->flags & EXT2_FLAG_RW) {
-                        sb->s_feature_ro_compat &= 
-                                ~EXT2_FEATURE_RO_COMPAT_LARGE_FILE;
-                        ext2fs_mark_super_dirty(fs);
-                }
-        }
-        
-#ifdef RESOURCE_TRACK
-        if (ctx->options & E2F_OPT_TIME2) {
-                e2fsck_clear_progbar(ctx);
-                print_resource_track(_("Pass 2"), &rtrack);
-        }
-#endif
-}
-
-#define MAX_DEPTH 32000
-static int htree_depth(struct dx_dir_info *dx_dir,
-                       struct dx_dirblock_info *dx_db)
-{
-        int     depth = 0;
-
-        while (dx_db->type != DX_DIRBLOCK_ROOT && depth < MAX_DEPTH) {
-                dx_db = &dx_dir->dx_block[dx_db->parent];
-                depth++;
-        }
-        return depth;
-}
-
-static int dict_de_cmp(const void *a, const void *b)
-{
-        const struct ext2_dir_entry *de_a, *de_b;
-        int     a_len, b_len;
-
-        de_a = (const struct ext2_dir_entry *) a;
-        a_len = de_a->name_len & 0xFF;
-        de_b = (const struct ext2_dir_entry *) b;
-        b_len = de_b->name_len & 0xFF;
-
-        if (a_len != b_len)
-                return (a_len - b_len);
-
-        return strncmp(de_a->name, de_b->name, a_len);
-}
-
-/*
- * This is special sort function that makes sure that directory blocks
- * with a dirblock of zero are sorted to the beginning of the list.
- * This guarantees that the root node of the htree directories are
- * processed first, so we know what hash version to use.
- */
-static EXT2_QSORT_TYPE special_dir_block_cmp(const void *a, const void *b)
-{
-        const struct ext2_db_entry *db_a =
-                (const struct ext2_db_entry *) a;
-        const struct ext2_db_entry *db_b =
-                (const struct ext2_db_entry *) b;
-
-        if (db_a->blockcnt && !db_b->blockcnt)
-                return 1;
-
-        if (!db_a->blockcnt && db_b->blockcnt)
-                return -1;
-        
-        if (db_a->blk != db_b->blk)
-                return (int) (db_a->blk - db_b->blk);
-        
-        if (db_a->ino != db_b->ino)
-                return (int) (db_a->ino - db_b->ino);
-
-        return (int) (db_a->blockcnt - db_b->blockcnt);
-}
-
-
-/*
- * Make sure the first entry in the directory is '.', and that the
- * directory entry is sane.
- */
-static int check_dot(e2fsck_t ctx,
-                     struct ext2_dir_entry *dirent,
-                     ext2_ino_t ino, struct problem_context *pctx)
-{
-        struct ext2_dir_entry *nextdir;
-        int     status = 0;
-        int     created = 0;
-        int     new_len;
-        int     problem = 0;
-        
-        if (!dirent->inode)
-                problem = PR_2_MISSING_DOT;
-        else if (((dirent->name_len & 0xFF) != 1) ||
-                 (dirent->name[0] != '.'))
-                problem = PR_2_1ST_NOT_DOT;
-        else if (dirent->name[1] != '\0')
-                problem = PR_2_DOT_NULL_TERM;
-        
-        if (problem) {
-                if (fix_problem(ctx, problem, pctx)) {
-                        if (dirent->rec_len < 12)
-                                dirent->rec_len = 12;
-                        dirent->inode = ino;
-                        dirent->name_len = 1;
-                        dirent->name[0] = '.';
-                        dirent->name[1] = '\0';
-                        status = 1;
-                        created = 1;
-                }
-        }
-        if (dirent->inode != ino) {
-                if (fix_problem(ctx, PR_2_BAD_INODE_DOT, pctx)) {
-                        dirent->inode = ino;
-                        status = 1;
-                }
-        }
-        if (dirent->rec_len > 12) {
-                new_len = dirent->rec_len - 12;
-                if (new_len > 12) {
-                        if (created ||
-                            fix_problem(ctx, PR_2_SPLIT_DOT, pctx)) {
-                                nextdir = (struct ext2_dir_entry *)
-                                        ((char *) dirent + 12);
-                                dirent->rec_len = 12;
-                                nextdir->rec_len = new_len;
-                                nextdir->inode = 0;
-                                nextdir->name_len = 0;
-                                status = 1;
-                        }
-                }
-        }
-        return status;
-}
-
-/*
- * Make sure the second entry in the directory is '..', and that the
- * directory entry is sane.  We do not check the inode number of '..'
- * here; this gets done in pass 3.
- */
-static int check_dotdot(e2fsck_t ctx,
-                        struct ext2_dir_entry *dirent,
-                        struct dir_info *dir, struct problem_context *pctx)
-{
-        int             problem = 0;
-        
-        if (!dirent->inode)
-                problem = PR_2_MISSING_DOT_DOT;
-        else if (((dirent->name_len & 0xFF) != 2) ||
-                 (dirent->name[0] != '.') ||
-                 (dirent->name[1] != '.'))
-                problem = PR_2_2ND_NOT_DOT_DOT;
-        else if (dirent->name[2] != '\0')
-                problem = PR_2_DOT_DOT_NULL_TERM;
-
-        if (problem) {
-                if (fix_problem(ctx, problem, pctx)) {
-                        if (dirent->rec_len < 12)
-                                dirent->rec_len = 12;
-                        /*
-                         * Note: we don't have the parent inode just
-                         * yet, so we will fill it in with the root
-                         * inode.  This will get fixed in pass 3.
-                         */
-                        dirent->inode = EXT2_ROOT_INO;
-                        dirent->name_len = 2;
-                        dirent->name[0] = '.';
-                        dirent->name[1] = '.';
-                        dirent->name[2] = '\0';
-                        return 1;
-                } 
-                return 0;
-        }
-        dir->dotdot = dirent->inode;
-        return 0;
-}
-
-/*
- * Check to make sure a directory entry doesn't contain any illegal
- * characters.
- */
-static int check_name(e2fsck_t ctx,
-                      struct ext2_dir_entry *dirent,
-                      ext2_ino_t dir_ino EXT2FS_ATTR((unused)), 
-                      struct problem_context *pctx)
-{
-        int     i;
-        int     fixup = -1;
-        int     ret = 0;
-        
-        for ( i = 0; i < (dirent->name_len & 0xFF); i++) {
-                if (dirent->name[i] == '/' || dirent->name[i] == '\0') {
-                        if (fixup < 0) {
-                                fixup = fix_problem(ctx, PR_2_BAD_NAME, pctx);
-                        }
-                        if (fixup) {
-                                dirent->name[i] = '.';
-                                ret = 1;
-                        }
-                }
-        }
-        return ret;
-}
-
-/*
- * Check the directory filetype (if present)
- */
-static _INLINE_ int check_filetype(e2fsck_t ctx,
-                                   struct ext2_dir_entry *dirent,
-                                   ext2_ino_t dir_ino EXT2FS_ATTR((unused)),
-                                   struct problem_context *pctx)
-{
-        int     filetype = dirent->name_len >> 8;
-        int     should_be = EXT2_FT_UNKNOWN;
-        struct ext2_inode       inode;
-
-        if (!(ctx->fs->super->s_feature_incompat &
-              EXT2_FEATURE_INCOMPAT_FILETYPE)) {
-                if (filetype == 0 ||
-                    !fix_problem(ctx, PR_2_CLEAR_FILETYPE, pctx))
-                        return 0;
-                dirent->name_len = dirent->name_len & 0xFF;
-                return 1;
-        }
-
-        if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, dirent->inode)) {
-                should_be = EXT2_FT_DIR;
-        } else if (ext2fs_test_inode_bitmap(ctx->inode_reg_map,
-                                            dirent->inode)) {
-                should_be = EXT2_FT_REG_FILE;
-        } else if (ctx->inode_bad_map &&
-                   ext2fs_test_inode_bitmap(ctx->inode_bad_map,
-                                            dirent->inode))
-                should_be = 0;
-        else {
-                e2fsck_read_inode(ctx, dirent->inode, &inode,
-                                  "check_filetype");
-                should_be = ext2_file_type(inode.i_mode);
-        }
-        if (filetype == should_be)
-                return 0;
-        pctx->num = should_be;
-
-        if (fix_problem(ctx, filetype ? PR_2_BAD_FILETYPE : PR_2_SET_FILETYPE,
-                        pctx) == 0)
-                return 0;
-                        
-        dirent->name_len = (dirent->name_len & 0xFF) | should_be << 8;
-        return 1;
-}
-
-#ifdef ENABLE_HTREE
-static void parse_int_node(ext2_filsys fs,
-                           struct ext2_db_entry *db,
-                           struct check_dir_struct *cd,
-                           struct dx_dir_info   *dx_dir,
-                           char *block_buf)
-{
-        struct          ext2_dx_root_info  *root;
-        struct          ext2_dx_entry *ent;
-        struct          ext2_dx_countlimit *limit;
-        struct dx_dirblock_info *dx_db;
-        int             i, expect_limit, count;
-        blk_t           blk;
-        ext2_dirhash_t  min_hash = 0xffffffff;
-        ext2_dirhash_t  max_hash = 0;
-        ext2_dirhash_t  hash = 0, prev_hash;
-
-        if (db->blockcnt == 0) {
-                root = (struct ext2_dx_root_info *) (block_buf + 24);
-                
-#ifdef DX_DEBUG
-                printf("Root node dump:\n");
-                printf("\t Reserved zero: %d\n", root->reserved_zero);
-                printf("\t Hash Version: %d\n", root->hash_version);
-                printf("\t Info length: %d\n", root->info_length);
-                printf("\t Indirect levels: %d\n", root->indirect_levels);
-                printf("\t Flags: %d\n", root->unused_flags);
-#endif
-
-                ent = (struct ext2_dx_entry *) (block_buf + 24 + root->info_length);
-        } else {
-                ent = (struct ext2_dx_entry *) (block_buf+8);
-        }
-        limit = (struct ext2_dx_countlimit *) ent;
-
-#ifdef DX_DEBUG
-        printf("Number of entries (count): %d\n", 
-               ext2fs_le16_to_cpu(limit->count));
-        printf("Number of entries (limit): %d\n", 
-               ext2fs_le16_to_cpu(limit->limit));
-#endif
-
-        count = ext2fs_le16_to_cpu(limit->count);
-        expect_limit = (fs->blocksize - ((char *) ent - block_buf)) /
-                sizeof(struct ext2_dx_entry);
-        if (ext2fs_le16_to_cpu(limit->limit) != expect_limit) {
-                cd->pctx.num = ext2fs_le16_to_cpu(limit->limit);
-                if (fix_problem(cd->ctx, PR_2_HTREE_BAD_LIMIT, &cd->pctx))
-                        goto clear_and_exit;
-        }
-        if (count > expect_limit) {
-                cd->pctx.num = count;
-                if (fix_problem(cd->ctx, PR_2_HTREE_BAD_COUNT, &cd->pctx))
-                        goto clear_and_exit;
-                count = expect_limit;
-        }
-        
-        for (i=0; i < count; i++) {
-                prev_hash = hash;
-                hash = i ? (ext2fs_le32_to_cpu(ent[i].hash) & ~1) : 0;
-#ifdef DX_DEBUG
-                printf("Entry #%d: Hash 0x%08x, block %d\n", i,
-                       hash, ext2fs_le32_to_cpu(ent[i].block));
-#endif
-                blk = ext2fs_le32_to_cpu(ent[i].block) & 0x0ffffff;
-                /* Check to make sure the block is valid */
-                if (blk > (blk_t) dx_dir->numblocks) {
-                        cd->pctx.blk = blk;
-                        if (fix_problem(cd->ctx, PR_2_HTREE_BADBLK,
-                                        &cd->pctx))
-                                goto clear_and_exit;
-                }
-                if (hash < prev_hash &&
-                    fix_problem(cd->ctx, PR_2_HTREE_HASH_ORDER, &cd->pctx))
-                        goto clear_and_exit;
-                dx_db = &dx_dir->dx_block[blk];
-                if (dx_db->flags & DX_FLAG_REFERENCED) {
-                        dx_db->flags |= DX_FLAG_DUP_REF;
-                } else {
-                        dx_db->flags |= DX_FLAG_REFERENCED;
-                        dx_db->parent = db->blockcnt;
-                }
-                if (hash < min_hash)
-                        min_hash = hash;
-                if (hash > max_hash)
-                        max_hash = hash;
-                dx_db->node_min_hash = hash;
-                if ((i+1) < count)
-                        dx_db->node_max_hash = 
-                          ext2fs_le32_to_cpu(ent[i+1].hash) & ~1;
-                else {
-                        dx_db->node_max_hash = 0xfffffffe;
-                        dx_db->flags |= DX_FLAG_LAST;
-                }
-                if (i == 0)
-                        dx_db->flags |= DX_FLAG_FIRST;
-        }
-#ifdef DX_DEBUG
-        printf("Blockcnt = %d, min hash 0x%08x, max hash 0x%08x\n",
-               db->blockcnt, min_hash, max_hash);
-#endif
-        dx_db = &dx_dir->dx_block[db->blockcnt];
-        dx_db->min_hash = min_hash;
-        dx_db->max_hash = max_hash;
-        return;
-
-clear_and_exit:
-        clear_htree(cd->ctx, cd->pctx.ino);
-        dx_dir->numblocks = 0;
-}
-#endif /* ENABLE_HTREE */
-
-/*
- * Given a busted directory, try to salvage it somehow.
- * 
- */
-static void salvage_directory(ext2_filsys fs,
-                              struct ext2_dir_entry *dirent,
-                              struct ext2_dir_entry *prev,
-                              unsigned int *offset)
-{
-        char    *cp = (char *) dirent;
-        int left = fs->blocksize - *offset - dirent->rec_len;
-        int name_len = dirent->name_len & 0xFF;
-
-        /*
-         * Special case of directory entry of size 8: copy what's left
-         * of the directory block up to cover up the invalid hole.
-         */
-        if ((left >= 12) && (dirent->rec_len == 8)) {
-                memmove(cp, cp+8, left);
-                memset(cp + left, 0, 8);
-                return;
-        }
-        /*
-         * If the directory entry overruns the end of the directory
-         * block, and the name is small enough to fit, then adjust the
-         * record length.
-         */
-        if ((left < 0) &&
-            (name_len + 8 <= dirent->rec_len + left) &&
-            dirent->inode <= fs->super->s_inodes_count &&
-            strnlen(dirent->name, name_len) == name_len) {
-                dirent->rec_len += left;
-                return;
-        }
-        /*
-         * If the directory entry is a multiple of four, so it is
-         * valid, let the previous directory entry absorb the invalid
-         * one. 
-         */
-        if (prev && dirent->rec_len && (dirent->rec_len % 4) == 0) {
-                prev->rec_len += dirent->rec_len;
-                *offset += dirent->rec_len;
-                return;
-        }
-        /*
-         * Default salvage method --- kill all of the directory
-         * entries for the rest of the block.  We will either try to
-         * absorb it into the previous directory entry, or create a
-         * new empty directory entry the rest of the directory block.
-         */
-        if (prev) {
-                prev->rec_len += fs->blocksize - *offset;
-                *offset = fs->blocksize;
-        } else {
-                dirent->rec_len = fs->blocksize - *offset;
-                dirent->name_len = 0;
-                dirent->inode = 0;
-        }
-}
-
-static int check_dir_block(ext2_filsys fs,
-                           struct ext2_db_entry *db,
-                           void *priv_data)
-{
-        struct dir_info         *subdir, *dir;
-        struct dx_dir_info      *dx_dir;
-#ifdef ENABLE_HTREE
-        struct dx_dirblock_info *dx_db = 0;
-#endif /* ENABLE_HTREE */
-        struct ext2_dir_entry   *dirent, *prev;
-        ext2_dirhash_t          hash;
-        unsigned int            offset = 0;
-        int                     dir_modified = 0;
-        int                     dot_state;
-        blk_t                   block_nr = db->blk;
-        ext2_ino_t              ino = db->ino;
-        __u16                   links;
-        struct check_dir_struct *cd;
-        char                    *buf;
-        e2fsck_t                ctx;
-        int                     problem;
-        struct ext2_dx_root_info *root;
-        struct ext2_dx_countlimit *limit;
-        static dict_t de_dict;
-        struct problem_context  pctx;
-        int     dups_found = 0;
-
-        cd = (struct check_dir_struct *) priv_data;
-        buf = cd->buf;
-        ctx = cd->ctx;
-
-        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                return DIRENT_ABORT;
-        
-        if (ctx->progress && (ctx->progress)(ctx, 2, cd->count++, cd->max))
-                return DIRENT_ABORT;
-        
-        /*
-         * Make sure the inode is still in use (could have been 
-         * deleted in the duplicate/bad blocks pass.
-         */
-        if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, ino))) 
-                return 0;
-
-        cd->pctx.ino = ino;
-        cd->pctx.blk = block_nr;
-        cd->pctx.blkcount = db->blockcnt;
-        cd->pctx.ino2 = 0;
-        cd->pctx.dirent = 0;
-        cd->pctx.num = 0;
-
-        if (db->blk == 0) {
-                if (allocate_dir_block(ctx, db, buf, &cd->pctx))
-                        return 0;
-                block_nr = db->blk;
-        }
-        
-        if (db->blockcnt)
-                dot_state = 2;
-        else
-                dot_state = 0;
-
-        if (ctx->dirs_to_hash &&
-            ext2fs_u32_list_test(ctx->dirs_to_hash, ino))
-                dups_found++;
-
-#if 0
-        printf("In process_dir_block block %lu, #%d, inode %lu\n", block_nr,
-               db->blockcnt, ino);
-#endif
-        
-        cd->pctx.errcode = ext2fs_read_dir_block(fs, block_nr, buf);
-        if (cd->pctx.errcode == EXT2_ET_DIR_CORRUPTED)
-                cd->pctx.errcode = 0; /* We'll handle this ourselves */
-        if (cd->pctx.errcode) {
-                if (!fix_problem(ctx, PR_2_READ_DIRBLOCK, &cd->pctx)) {
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return DIRENT_ABORT;
-                }
-                memset(buf, 0, fs->blocksize);
-        }
-#ifdef ENABLE_HTREE
-        dx_dir = e2fsck_get_dx_dir_info(ctx, ino);
-        if (dx_dir && dx_dir->numblocks) {
-                if (db->blockcnt >= dx_dir->numblocks) {
-                        printf("XXX should never happen!!!\n");
-                        abort();
-                }
-                dx_db = &dx_dir->dx_block[db->blockcnt];
-                dx_db->type = DX_DIRBLOCK_LEAF;
-                dx_db->phys = block_nr;
-                dx_db->min_hash = ~0;
-                dx_db->max_hash = 0;
-                        
-                dirent = (struct ext2_dir_entry *) buf;
-                limit = (struct ext2_dx_countlimit *) (buf+8);
-                if (db->blockcnt == 0) {
-                        root = (struct ext2_dx_root_info *) (buf + 24);
-                        dx_db->type = DX_DIRBLOCK_ROOT;
-                        dx_db->flags |= DX_FLAG_FIRST | DX_FLAG_LAST;
-                        if ((root->reserved_zero ||
-                             root->info_length < 8 ||
-                             root->indirect_levels > 1) &&
-                            fix_problem(ctx, PR_2_HTREE_BAD_ROOT, &cd->pctx)) {
-                                clear_htree(ctx, ino);
-                                dx_dir->numblocks = 0;
-                                dx_db = 0;
-                        } 
-                        dx_dir->hashversion = root->hash_version;
-                        dx_dir->depth = root->indirect_levels + 1;
-                } else if ((dirent->inode == 0) &&
-                           (dirent->rec_len == fs->blocksize) &&
-                           (dirent->name_len == 0) &&
-                           (ext2fs_le16_to_cpu(limit->limit) == 
-                            ((fs->blocksize-8) / 
-                             sizeof(struct ext2_dx_entry))))
-                        dx_db->type = DX_DIRBLOCK_NODE;
-        }
-#endif /* ENABLE_HTREE */
-
-        dict_init(&de_dict, DICTCOUNT_T_MAX, dict_de_cmp);
-        prev = 0;
-        do {
-                problem = 0;
-                dirent = (struct ext2_dir_entry *) (buf + offset);
-                cd->pctx.dirent = dirent;
-                cd->pctx.num = offset;
-                if (((offset + dirent->rec_len) > fs->blocksize) ||
-                    (dirent->rec_len < 12) ||
-                    ((dirent->rec_len % 4) != 0) ||
-                    (((dirent->name_len & 0xFF)+8) > dirent->rec_len)) {
-                        if (fix_problem(ctx, PR_2_DIR_CORRUPTED, &cd->pctx)) {
-                                salvage_directory(fs, dirent, prev, &offset);
-                                dir_modified++;
-                                continue;
-                        } else
-                                goto abort_free_dict;
-                }
-                if ((dirent->name_len & 0xFF) > EXT2_NAME_LEN) {
-                        if (fix_problem(ctx, PR_2_FILENAME_LONG, &cd->pctx)) {
-                                dirent->name_len = EXT2_NAME_LEN;
-                                dir_modified++;
-                        }
-                }
-
-                if (dot_state == 0) {
-                        if (check_dot(ctx, dirent, ino, &cd->pctx))
-                                dir_modified++;
-                } else if (dot_state == 1) {
-                        dir = e2fsck_get_dir_info(ctx, ino);
-                        if (!dir) {
-                                fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx);
-                                goto abort_free_dict;
-                        }
-                        if (check_dotdot(ctx, dirent, dir, &cd->pctx))
-                                dir_modified++;
-                } else if (dirent->inode == ino) {
-                        problem = PR_2_LINK_DOT;
-                        if (fix_problem(ctx, PR_2_LINK_DOT, &cd->pctx)) {
-                                dirent->inode = 0;
-                                dir_modified++;
-                                goto next;
-                        }
-                }
-                if (!dirent->inode) 
-                        goto next;
-                
-                /*
-                 * Make sure the inode listed is a legal one.
-                 */ 
-                if (((dirent->inode != EXT2_ROOT_INO) &&
-                     (dirent->inode < EXT2_FIRST_INODE(fs->super))) ||
-                    (dirent->inode > fs->super->s_inodes_count)) {
-                        problem = PR_2_BAD_INO;
-                } else if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map,
-                                               dirent->inode))) {
-                        /*
-                         * If the inode is unused, offer to clear it.
-                         */
-                        problem = PR_2_UNUSED_INODE;
-                } else if (ctx->inode_bb_map &&
-                           (ext2fs_test_inode_bitmap(ctx->inode_bb_map,
-                                                     dirent->inode))) {
-                        /*
-                         * If the inode is in a bad block, offer to
-                         * clear it.
-                         */
-                        problem = PR_2_BB_INODE;
-                } else if ((dot_state > 1) &&
-                           ((dirent->name_len & 0xFF) == 1) &&
-                           (dirent->name[0] == '.')) {
-                        /*
-                         * If there's a '.' entry in anything other
-                         * than the first directory entry, it's a
-                         * duplicate entry that should be removed.
-                         */
-                        problem = PR_2_DUP_DOT;
-                } else if ((dot_state > 1) &&
-                           ((dirent->name_len & 0xFF) == 2) &&
-                           (dirent->name[0] == '.') && 
-                           (dirent->name[1] == '.')) {
-                        /*
-                         * If there's a '..' entry in anything other
-                         * than the second directory entry, it's a
-                         * duplicate entry that should be removed.
-                         */
-                        problem = PR_2_DUP_DOT_DOT;
-                } else if ((dot_state > 1) &&
-                           (dirent->inode == EXT2_ROOT_INO)) {
-                        /*
-                         * Don't allow links to the root directory.
-                         * We check this specially to make sure we
-                         * catch this error case even if the root
-                         * directory hasn't been created yet.
-                         */
-                        problem = PR_2_LINK_ROOT;
-                } else if ((dot_state > 1) &&
-                           (dirent->name_len & 0xFF) == 0) {
-                        /*
-                         * Don't allow zero-length directory names.
-                         */
-                        problem = PR_2_NULL_NAME;
-                }
-
-                if (problem) {
-                        if (fix_problem(ctx, problem, &cd->pctx)) {
-                                dirent->inode = 0;
-                                dir_modified++;
-                                goto next;
-                        } else {
-                                ext2fs_unmark_valid(fs);
-                                if (problem == PR_2_BAD_INO)
-                                        goto next;
-                        }
-                }
-
-                /*
-                 * If the inode was marked as having bad fields in
-                 * pass1, process it and offer to fix/clear it.
-                 * (We wait until now so that we can display the
-                 * pathname to the user.)
-                 */
-                if (ctx->inode_bad_map &&
-                    ext2fs_test_inode_bitmap(ctx->inode_bad_map,
-                                             dirent->inode)) {
-                        if (e2fsck_process_bad_inode(ctx, ino,
-                                                     dirent->inode,
-                                                     buf + fs->blocksize)) {
-                                dirent->inode = 0;
-                                dir_modified++;
-                                goto next;
-                        }
-                        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                                return DIRENT_ABORT;
-                }
-
-                if (check_name(ctx, dirent, ino, &cd->pctx))
-                        dir_modified++;
-
-                if (check_filetype(ctx, dirent, ino, &cd->pctx))
-                        dir_modified++;
-
-#ifdef ENABLE_HTREE
-                if (dx_db) {
-                        ext2fs_dirhash(dx_dir->hashversion, dirent->name,
-                                       (dirent->name_len & 0xFF),
-                                       fs->super->s_hash_seed, &hash, 0);
-                        if (hash < dx_db->min_hash)
-                                dx_db->min_hash = hash;
-                        if (hash > dx_db->max_hash)
-                                dx_db->max_hash = hash;
-                }
-#endif
-
-                /*
-                 * If this is a directory, then mark its parent in its
-                 * dir_info structure.  If the parent field is already
-                 * filled in, then this directory has more than one
-                 * hard link.  We assume the first link is correct,
-                 * and ask the user if he/she wants to clear this one.
-                 */
-                if ((dot_state > 1) &&
-                    (ext2fs_test_inode_bitmap(ctx->inode_dir_map,
-                                              dirent->inode))) {
-                        subdir = e2fsck_get_dir_info(ctx, dirent->inode);
-                        if (!subdir) {
-                                cd->pctx.ino = dirent->inode;
-                                fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx);
-                                goto abort_free_dict;
-                        }
-                        if (subdir->parent) {
-                                cd->pctx.ino2 = subdir->parent;
-                                if (fix_problem(ctx, PR_2_LINK_DIR,
-                                                &cd->pctx)) {
-                                        dirent->inode = 0;
-                                        dir_modified++;
-                                        goto next;
-                                }
-                                cd->pctx.ino2 = 0;
-                        } else
-                                subdir->parent = ino;
-                }
-
-                if (dups_found) {
-                        ;
-                } else if (dict_lookup(&de_dict, dirent)) {
-                        clear_problem_context(&pctx);
-                        pctx.ino = ino;
-                        pctx.dirent = dirent;
-                        fix_problem(ctx, PR_2_REPORT_DUP_DIRENT, &pctx);
-                        if (!ctx->dirs_to_hash)
-                                ext2fs_u32_list_create(&ctx->dirs_to_hash, 50);
-                        if (ctx->dirs_to_hash)
-                                ext2fs_u32_list_add(ctx->dirs_to_hash, ino);
-                        dups_found++;
-                } else
-                        dict_alloc_insert(&de_dict, dirent, dirent);
-                
-                ext2fs_icount_increment(ctx->inode_count, dirent->inode,
-                                        &links);
-                if (links > 1)
-                        ctx->fs_links_count++;
-                ctx->fs_total_count++;
-        next:
-                prev = dirent;
-                offset += dirent->rec_len;
-                dot_state++;
-        } while (offset < fs->blocksize);
-#if 0
-        printf("\n");
-#endif
-#ifdef ENABLE_HTREE
-        if (dx_db) {
-#ifdef DX_DEBUG
-                printf("db_block %d, type %d, min_hash 0x%0x, max_hash 0x%0x\n",
-                       db->blockcnt, dx_db->type,
-                       dx_db->min_hash, dx_db->max_hash);
-#endif
-                cd->pctx.dir = cd->pctx.ino;
-                if ((dx_db->type == DX_DIRBLOCK_ROOT) ||
-                    (dx_db->type == DX_DIRBLOCK_NODE))
-                        parse_int_node(fs, db, cd, dx_dir, buf);
-        }
-#endif /* ENABLE_HTREE */
-        if (offset != fs->blocksize) {
-                cd->pctx.num = dirent->rec_len - fs->blocksize + offset;
-                if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) {
-                        dirent->rec_len = cd->pctx.num;
-                        dir_modified++;
-                }
-        }
-        if (dir_modified) {
-                cd->pctx.errcode = ext2fs_write_dir_block(fs, block_nr, buf);
-                if (cd->pctx.errcode) {
-                        if (!fix_problem(ctx, PR_2_WRITE_DIRBLOCK,
-                                         &cd->pctx))
-                                goto abort_free_dict;
-                }
-                ext2fs_mark_changed(fs);
-        }
-        dict_free_nodes(&de_dict);
-        return 0;
-abort_free_dict:
-        dict_free_nodes(&de_dict);
-        ctx->flags |= E2F_FLAG_ABORT;
-        return DIRENT_ABORT;
-}
-
-/*
- * This function is called to deallocate a block, and is an interator
- * functioned called by deallocate inode via ext2fs_iterate_block().
- */
-static int deallocate_inode_block(ext2_filsys fs,
-                                  blk_t *block_nr,
-                                  e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
-                                  blk_t ref_block EXT2FS_ATTR((unused)),
-                                  int ref_offset EXT2FS_ATTR((unused)),
-                                  void *priv_data)
-{
-        e2fsck_t        ctx = (e2fsck_t) priv_data;
-        
-        if (HOLE_BLKADDR(*block_nr))
-                return 0;
-        if ((*block_nr < fs->super->s_first_data_block) ||
-            (*block_nr >= fs->super->s_blocks_count))
-                return 0;
-        ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr);
-        ext2fs_block_alloc_stats(fs, *block_nr, -1);
-        return 0;
-}
-                
-/*
- * This fuction deallocates an inode
- */
-static void deallocate_inode(e2fsck_t ctx, ext2_ino_t ino, char* block_buf)
-{
-        ext2_filsys fs = ctx->fs;
-        struct ext2_inode       inode;
-        struct problem_context  pctx;
-        __u32                   count;
-        
-        ext2fs_icount_store(ctx->inode_link_info, ino, 0);
-        e2fsck_read_inode(ctx, ino, &inode, "deallocate_inode");
-        inode.i_links_count = 0;
-        inode.i_dtime = time(0);
-        e2fsck_write_inode(ctx, ino, &inode, "deallocate_inode");
-        clear_problem_context(&pctx);
-        pctx.ino = ino;
-
-        /*
-         * Fix up the bitmaps...
-         */
-        e2fsck_read_bitmaps(ctx);
-        ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino);
-        ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino);
-        if (ctx->inode_bad_map)
-                ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino);
-        ext2fs_inode_alloc_stats2(fs, ino, -1, LINUX_S_ISDIR(inode.i_mode));
-
-        if (inode.i_file_acl &&
-            (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR)) {
-                pctx.errcode = ext2fs_adjust_ea_refcount(fs, inode.i_file_acl,
-                                                   block_buf, -1, &count);
-                if (pctx.errcode == EXT2_ET_BAD_EA_BLOCK_NUM) {
-                        pctx.errcode = 0;
-                        count = 1;
-                }
-                if (pctx.errcode) {
-                        pctx.blk = inode.i_file_acl;
-                        fix_problem(ctx, PR_2_ADJ_EA_REFCOUNT, &pctx);
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return;
-                }
-                if (count == 0) {
-                        ext2fs_unmark_block_bitmap(ctx->block_found_map,
-                                                   inode.i_file_acl);
-                        ext2fs_block_alloc_stats(fs, inode.i_file_acl, -1);
-                }
-                inode.i_file_acl = 0;
-        }
-
-        if (!ext2fs_inode_has_valid_blocks(&inode))
-                return;
-
-        if (LINUX_S_ISREG(inode.i_mode) &&
-            (inode.i_size_high || inode.i_size & 0x80000000UL))
-                ctx->large_files--;
-
-        pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, block_buf,
-                                            deallocate_inode_block, ctx);
-        if (pctx.errcode) {
-                fix_problem(ctx, PR_2_DEALLOC_INODE, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-}
-
-/*
- * This fuction clears the htree flag on an inode
- */
-static void clear_htree(e2fsck_t ctx, ext2_ino_t ino)
-{
-        struct ext2_inode       inode;
-        
-        e2fsck_read_inode(ctx, ino, &inode, "clear_htree");
-        inode.i_flags = inode.i_flags & ~EXT2_INDEX_FL;
-        e2fsck_write_inode(ctx, ino, &inode, "clear_htree");
-        if (ctx->dirs_to_hash)
-                ext2fs_u32_list_add(ctx->dirs_to_hash, ino);
-}
-
-
-extern int e2fsck_process_bad_inode(e2fsck_t ctx, ext2_ino_t dir,
-                                    ext2_ino_t ino, char *buf)
-{
-        ext2_filsys fs = ctx->fs;
-        struct ext2_inode       inode;
-        int                     inode_modified = 0;
-        int                     not_fixed = 0;
-        unsigned char           *frag, *fsize;
-        struct problem_context  pctx;
-        int     problem = 0;
-
-        e2fsck_read_inode(ctx, ino, &inode, "process_bad_inode");
-
-        clear_problem_context(&pctx);
-        pctx.ino = ino;
-        pctx.dir = dir;
-        pctx.inode = &inode;
-
-        if (inode.i_file_acl &&
-            !(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) &&
-            fix_problem(ctx, PR_2_FILE_ACL_ZERO, &pctx)) {
-                inode.i_file_acl = 0;
-#ifdef EXT2FS_ENABLE_SWAPFS
-                /* 
-                 * This is a special kludge to deal with long symlinks
-                 * on big endian systems.  i_blocks had already been
-                 * decremented earlier in pass 1, but since i_file_acl
-                 * hadn't yet been cleared, ext2fs_read_inode()
-                 * assumed that the file was short symlink and would
-                 * not have byte swapped i_block[0].  Hence, we have
-                 * to byte-swap it here.
-                 */
-                if (LINUX_S_ISLNK(inode.i_mode) &&
-                    (fs->flags & EXT2_FLAG_SWAP_BYTES) &&
-                    (inode.i_blocks == fs->blocksize >> 9))
-                        inode.i_block[0] = ext2fs_swab32(inode.i_block[0]);
-#endif
-                inode_modified++;
-        } else
-                not_fixed++;
-
-        if (!LINUX_S_ISDIR(inode.i_mode) && !LINUX_S_ISREG(inode.i_mode) &&
-            !LINUX_S_ISCHR(inode.i_mode) && !LINUX_S_ISBLK(inode.i_mode) &&
-            !LINUX_S_ISLNK(inode.i_mode) && !LINUX_S_ISFIFO(inode.i_mode) &&
-            !(LINUX_S_ISSOCK(inode.i_mode)))
-                problem = PR_2_BAD_MODE;
-        else if (LINUX_S_ISCHR(inode.i_mode)
-                 && !e2fsck_pass1_check_device_inode(fs, &inode))
-                problem = PR_2_BAD_CHAR_DEV;
-        else if (LINUX_S_ISBLK(inode.i_mode)
-                 && !e2fsck_pass1_check_device_inode(fs, &inode))
-                problem = PR_2_BAD_BLOCK_DEV;
-        else if (LINUX_S_ISFIFO(inode.i_mode)
-                 && !e2fsck_pass1_check_device_inode(fs, &inode))
-                problem = PR_2_BAD_FIFO;
-        else if (LINUX_S_ISSOCK(inode.i_mode)
-                 && !e2fsck_pass1_check_device_inode(fs, &inode))
-                problem = PR_2_BAD_SOCKET;
-        else if (LINUX_S_ISLNK(inode.i_mode)
-                 && !e2fsck_pass1_check_symlink(fs, &inode, buf)) {
-                problem = PR_2_INVALID_SYMLINK;
-        }
-
-        if (problem) {
-                if (fix_problem(ctx, problem, &pctx)) {
-                        deallocate_inode(ctx, ino, 0);
-                        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                                return 0;
-                        return 1;
-                } else
-                        not_fixed++;
-                problem = 0;
-        }
-                
-        if (inode.i_faddr) {
-                if (fix_problem(ctx, PR_2_FADDR_ZERO, &pctx)) {
-                        inode.i_faddr = 0;
-                        inode_modified++;
-                } else
-                        not_fixed++;
-        }
-
-        switch (fs->super->s_creator_os) {
-            case EXT2_OS_LINUX:
-                frag = &inode.osd2.linux2.l_i_frag;
-                fsize = &inode.osd2.linux2.l_i_fsize;
-                break;
-            case EXT2_OS_HURD:
-                frag = &inode.osd2.hurd2.h_i_frag;
-                fsize = &inode.osd2.hurd2.h_i_fsize;
-                break;
-            case EXT2_OS_MASIX:
-                frag = &inode.osd2.masix2.m_i_frag;
-                fsize = &inode.osd2.masix2.m_i_fsize;
-                break;
-            default:
-                frag = fsize = 0;
-        }
-        if (frag && *frag) {
-                pctx.num = *frag;
-                if (fix_problem(ctx, PR_2_FRAG_ZERO, &pctx)) {
-                        *frag = 0;
-                        inode_modified++;
-                } else
-                        not_fixed++;
-                pctx.num = 0;
-        }
-        if (fsize && *fsize) {
-                pctx.num = *fsize;
-                if (fix_problem(ctx, PR_2_FSIZE_ZERO, &pctx)) {
-                        *fsize = 0;
-                        inode_modified++;
-                } else
-                        not_fixed++;
-                pctx.num = 0;
-        }
-
-        if (inode.i_file_acl &&
-            ((inode.i_file_acl < fs->super->s_first_data_block) ||
-             (inode.i_file_acl >= fs->super->s_blocks_count))) {
-                if (fix_problem(ctx, PR_2_FILE_ACL_BAD, &pctx)) {
-                        inode.i_file_acl = 0;
-                        inode_modified++;
-                } else
-                        not_fixed++;
-        }
-        if (inode.i_dir_acl &&
-            LINUX_S_ISDIR(inode.i_mode)) {
-                if (fix_problem(ctx, PR_2_DIR_ACL_ZERO, &pctx)) {
-                        inode.i_dir_acl = 0;
-                        inode_modified++;
-                } else
-                        not_fixed++;
-        }
-
-        if (inode_modified)
-                e2fsck_write_inode(ctx, ino, &inode, "process_bad_inode");
-        if (!not_fixed)
-                ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino);
-        return 0;
-}
-
-
-/*
- * allocate_dir_block --- this function allocates a new directory
- *      block for a particular inode; this is done if a directory has
- *      a "hole" in it, or if a directory has a illegal block number
- *      that was zeroed out and now needs to be replaced.
- */
-static int allocate_dir_block(e2fsck_t ctx,
-                              struct ext2_db_entry *db,
-                              char *buf EXT2FS_ATTR((unused)), 
-                              struct problem_context *pctx)
-{
-        ext2_filsys fs = ctx->fs;
-        blk_t                   blk;
-        char                    *block;
-        struct ext2_inode       inode;
-
-        if (fix_problem(ctx, PR_2_DIRECTORY_HOLE, pctx) == 0)
-                return 1;
-
-        /*
-         * Read the inode and block bitmaps in; we'll be messing with
-         * them.
-         */
-        e2fsck_read_bitmaps(ctx);
-        
-        /*
-         * First, find a free block
-         */
-        pctx->errcode = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk);
-        if (pctx->errcode) {
-                pctx->str = "ext2fs_new_block";
-                fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
-                return 1;
-        }
-        ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
-        ext2fs_mark_block_bitmap(fs->block_map, blk);
-        ext2fs_mark_bb_dirty(fs);
-
-        /*
-         * Now let's create the actual data block for the inode
-         */
-        if (db->blockcnt)
-                pctx->errcode = ext2fs_new_dir_block(fs, 0, 0, &block);
-        else
-                pctx->errcode = ext2fs_new_dir_block(fs, db->ino,
-                                                     EXT2_ROOT_INO, &block);
-
-        if (pctx->errcode) {
-                pctx->str = "ext2fs_new_dir_block";
-                fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
-                return 1;
-        }
-
-        pctx->errcode = ext2fs_write_dir_block(fs, blk, block);
-        ext2fs_free_mem(&block);
-        if (pctx->errcode) {
-                pctx->str = "ext2fs_write_dir_block";
-                fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
-                return 1;
-        }
-
-        /*
-         * Update the inode block count
-         */
-        e2fsck_read_inode(ctx, db->ino, &inode, "allocate_dir_block");
-        inode.i_blocks += fs->blocksize / 512;
-        if (inode.i_size < (db->blockcnt+1) * fs->blocksize)
-                inode.i_size = (db->blockcnt+1) * fs->blocksize;
-        e2fsck_write_inode(ctx, db->ino, &inode, "allocate_dir_block");
-
-        /*
-         * Finally, update the block pointers for the inode
-         */
-        db->blk = blk;
-        pctx->errcode = ext2fs_block_iterate2(fs, db->ino, BLOCK_FLAG_HOLE,
-                                      0, update_dir_block, db);
-        if (pctx->errcode) {
-                pctx->str = "ext2fs_block_iterate";
-                fix_problem(ctx, PR_2_ALLOC_DIRBOCK, pctx);
-                return 1;
-        }
-
-        return 0;
-}
-
-/*
- * This is a helper function for allocate_dir_block().
- */
-static int update_dir_block(ext2_filsys fs EXT2FS_ATTR((unused)),
-                            blk_t       *block_nr,
-                            e2_blkcnt_t blockcnt,
-                            blk_t ref_block EXT2FS_ATTR((unused)),
-                            int ref_offset EXT2FS_ATTR((unused)), 
-                            void *priv_data)
-{
-        struct ext2_db_entry *db;
-
-        db = (struct ext2_db_entry *) priv_data;
-        if (db->blockcnt == (int) blockcnt) {
-                *block_nr = db->blk;
-                return BLOCK_CHANGED;
-        }
-        return 0;
-}
diff --git a/e2fsprogs/e2fsck/pass3.c b/e2fsprogs/e2fsck/pass3.c
deleted file mode 100644
index a92c8904c..000000000
--- a/e2fsprogs/e2fsck/pass3.c
+++ /dev/null
@@ -1,804 +0,0 @@
-/*
- * pass3.c -- pass #3 of e2fsck: Check for directory connectivity
- *
- * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999 Theodore Ts'o.
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- * 
- * Pass #3 assures that all directories are connected to the
- * filesystem tree, using the following algorithm:
- *
- * First, the root directory is checked to make sure it exists; if
- * not, e2fsck will offer to create a new one.  It is then marked as
- * "done".
- * 
- * Then, pass3 interates over all directory inodes; for each directory
- * it attempts to trace up the filesystem tree, using dirinfo.parent
- * until it reaches a directory which has been marked "done".  If it
- * can not do so, then the directory must be disconnected, and e2fsck
- * will offer to reconnect it to /lost+found.  While it is chasing
- * parent pointers up the filesystem tree, if pass3 sees a directory
- * twice, then it has detected a filesystem loop, and it will again
- * offer to reconnect the directory to /lost+found in to break the
- * filesystem loop.
- * 
- * Pass 3 also contains the subroutine, e2fsck_reconnect_file() to
- * reconnect inodes to /lost+found; this subroutine is also used by
- * pass 4.  e2fsck_reconnect_file() calls get_lost_and_found(), which
- * is responsible for creating /lost+found if it does not exist.
- *
- * Pass 3 frees the following data structures:
- *      - The dirinfo directory information cache.
- */
-
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#endif
-
-#include "e2fsck.h"
-#include "problem.h"
-
-static void check_root(e2fsck_t ctx);
-static int check_directory(e2fsck_t ctx, struct dir_info *dir,
-                           struct problem_context *pctx);
-static void fix_dotdot(e2fsck_t ctx, struct dir_info *dir, ext2_ino_t parent);
-
-static ext2fs_inode_bitmap inode_loop_detect = 0;
-static ext2fs_inode_bitmap inode_done_map = 0;
-        
-void e2fsck_pass3(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        int             i;
-#ifdef RESOURCE_TRACK
-        struct resource_track   rtrack;
-#endif
-        struct problem_context  pctx;
-        struct dir_info *dir;
-        unsigned long maxdirs, count;
-
-#ifdef RESOURCE_TRACK
-        init_resource_track(&rtrack);
-#endif
-
-        clear_problem_context(&pctx);
-
-#ifdef MTRACE
-        mtrace_print("Pass 3");
-#endif
-
-        if (!(ctx->options & E2F_OPT_PREEN))
-                fix_problem(ctx, PR_3_PASS_HEADER, &pctx);
-
-        /*
-         * Allocate some bitmaps to do loop detection.
-         */
-        pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("inode done bitmap"),
-                                                    &inode_done_map);
-        if (pctx.errcode) {
-                pctx.num = 2;
-                fix_problem(ctx, PR_3_ALLOCATE_IBITMAP_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                goto abort_exit;
-        }
-#ifdef RESOURCE_TRACK
-        if (ctx->options & E2F_OPT_TIME) {
-                e2fsck_clear_progbar(ctx);
-                print_resource_track(_("Peak memory"), &ctx->global_rtrack);
-        }
-#endif
-
-        check_root(ctx);
-        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                goto abort_exit;
-
-        ext2fs_mark_inode_bitmap(inode_done_map, EXT2_ROOT_INO);
-
-        maxdirs = e2fsck_get_num_dirinfo(ctx);
-        count = 1;
-
-        if (ctx->progress)
-                if ((ctx->progress)(ctx, 3, 0, maxdirs))
-                        goto abort_exit;
-        
-        for (i=0; (dir = e2fsck_dir_info_iter(ctx, &i)) != 0;) {
-                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                        goto abort_exit;
-                if (ctx->progress && (ctx->progress)(ctx, 3, count++, maxdirs))
-                        goto abort_exit;
-                if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, dir->ino))
-                        if (check_directory(ctx, dir, &pctx))
-                                goto abort_exit;
-        }
-
-        /*
-         * Force the creation of /lost+found if not present
-         */
-        if ((ctx->flags & E2F_OPT_READONLY) == 0)
-                e2fsck_get_lost_and_found(ctx, 1);
-
-        /*
-         * If there are any directories that need to be indexed or
-         * optimized, do it here.
-         */
-        e2fsck_rehash_directories(ctx);
-        
-abort_exit:
-        e2fsck_free_dir_info(ctx);
-        if (inode_loop_detect) {
-                ext2fs_free_inode_bitmap(inode_loop_detect);
-                inode_loop_detect = 0;
-        }
-        if (inode_done_map) {
-                ext2fs_free_inode_bitmap(inode_done_map);
-                inode_done_map = 0;
-        }
-
-#ifdef RESOURCE_TRACK
-        if (ctx->options & E2F_OPT_TIME2) {
-                e2fsck_clear_progbar(ctx);
-                print_resource_track(_("Pass 3"), &rtrack);
-        }
-#endif
-}
-
-/*
- * This makes sure the root inode is present; if not, we ask if the
- * user wants us to create it.  Not creating it is a fatal error.
- */
-static void check_root(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        blk_t                   blk;
-        struct ext2_inode       inode;
-        char *                  block;
-        struct problem_context  pctx;
-        
-        clear_problem_context(&pctx);
-        
-        if (ext2fs_test_inode_bitmap(ctx->inode_used_map, EXT2_ROOT_INO)) {
-                /*
-                 * If the root inode is not a directory, die here.  The
-                 * user must have answered 'no' in pass1 when we
-                 * offered to clear it.
-                 */
-                if (!(ext2fs_test_inode_bitmap(ctx->inode_dir_map,
-                                               EXT2_ROOT_INO))) {
-                        fix_problem(ctx, PR_3_ROOT_NOT_DIR_ABORT, &pctx);
-                        ctx->flags |= E2F_FLAG_ABORT;
-                }
-                return;
-        }
-
-        if (!fix_problem(ctx, PR_3_NO_ROOT_INODE, &pctx)) {
-                fix_problem(ctx, PR_3_NO_ROOT_INODE_ABORT, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-
-        e2fsck_read_bitmaps(ctx);
-        
-        /*
-         * First, find a free block
-         */
-        pctx.errcode = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk);
-        if (pctx.errcode) {
-                pctx.str = "ext2fs_new_block";
-                fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
-        ext2fs_mark_block_bitmap(fs->block_map, blk);
-        ext2fs_mark_bb_dirty(fs);
-
-        /*
-         * Now let's create the actual data block for the inode
-         */
-        pctx.errcode = ext2fs_new_dir_block(fs, EXT2_ROOT_INO, EXT2_ROOT_INO,
-                                            &block);
-        if (pctx.errcode) {
-                pctx.str = "ext2fs_new_dir_block";
-                fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-
-        pctx.errcode = ext2fs_write_dir_block(fs, blk, block);
-        if (pctx.errcode) {
-                pctx.str = "ext2fs_write_dir_block";
-                fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        ext2fs_free_mem(&block);
-
-        /*
-         * Set up the inode structure
-         */
-        memset(&inode, 0, sizeof(inode));
-        inode.i_mode = 040755;
-        inode.i_size = fs->blocksize;
-        inode.i_atime = inode.i_ctime = inode.i_mtime = time(0);
-        inode.i_links_count = 2;
-        inode.i_blocks = fs->blocksize / 512;
-        inode.i_block[0] = blk;
-
-        /*
-         * Write out the inode.
-         */
-        pctx.errcode = ext2fs_write_new_inode(fs, EXT2_ROOT_INO, &inode);
-        if (pctx.errcode) {
-                pctx.str = "ext2fs_write_inode";
-                fix_problem(ctx, PR_3_CREATE_ROOT_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        
-        /*
-         * Miscellaneous bookkeeping...
-         */
-        e2fsck_add_dir_info(ctx, EXT2_ROOT_INO, EXT2_ROOT_INO);
-        ext2fs_icount_store(ctx->inode_count, EXT2_ROOT_INO, 2);
-        ext2fs_icount_store(ctx->inode_link_info, EXT2_ROOT_INO, 2);
-
-        ext2fs_mark_inode_bitmap(ctx->inode_used_map, EXT2_ROOT_INO);
-        ext2fs_mark_inode_bitmap(ctx->inode_dir_map, EXT2_ROOT_INO);
-        ext2fs_mark_inode_bitmap(fs->inode_map, EXT2_ROOT_INO);
-        ext2fs_mark_ib_dirty(fs);
-}
-
-/*
- * This subroutine is responsible for making sure that a particular
- * directory is connected to the root; if it isn't we trace it up as
- * far as we can go, and then offer to connect the resulting parent to
- * the lost+found.  We have to do loop detection; if we ever discover
- * a loop, we treat that as a disconnected directory and offer to
- * reparent it to lost+found.
- * 
- * However, loop detection is expensive, because for very large
- * filesystems, the inode_loop_detect bitmap is huge, and clearing it
- * is non-trivial.  Loops in filesystems are also a rare error case,
- * and we shouldn't optimize for error cases.  So we try two passes of
- * the algorithm.  The first time, we ignore loop detection and merely
- * increment a counter; if the counter exceeds some extreme threshold,
- * then we try again with the loop detection bitmap enabled.
- */
-static int check_directory(e2fsck_t ctx, struct dir_info *dir,
-                           struct problem_context *pctx)
-{
-        ext2_filsys     fs = ctx->fs;
-        struct dir_info *p = dir;
-        int             loop_pass = 0, parent_count = 0;
-
-        if (!p)
-                return 0;
-
-        while (1) {
-                /*
-                 * Mark this inode as being "done"; by the time we
-                 * return from this function, the inode we either be
-                 * verified as being connected to the directory tree,
-                 * or we will have offered to reconnect this to
-                 * lost+found.
-                 *
-                 * If it was marked done already, then we've reached a
-                 * parent we've already checked.
-                 */
-                if (ext2fs_mark_inode_bitmap(inode_done_map, p->ino))
-                        break;
-
-                /*
-                 * If this directory doesn't have a parent, or we've
-                 * seen the parent once already, then offer to
-                 * reparent it to lost+found
-                 */
-                if (!p->parent ||
-                    (loop_pass && 
-                     (ext2fs_test_inode_bitmap(inode_loop_detect,
-                                              p->parent)))) {
-                        pctx->ino = p->ino;
-                        if (fix_problem(ctx, PR_3_UNCONNECTED_DIR, pctx)) {
-                                if (e2fsck_reconnect_file(ctx, pctx->ino))
-                                        ext2fs_unmark_valid(fs);
-                                else {
-                                        p = e2fsck_get_dir_info(ctx, pctx->ino);
-                                        p->parent = ctx->lost_and_found;
-                                        fix_dotdot(ctx, p, ctx->lost_and_found);
-                                }
-                        }
-                        break;
-                }
-                p = e2fsck_get_dir_info(ctx, p->parent);
-                if (!p) {
-                        fix_problem(ctx, PR_3_NO_DIRINFO, pctx);
-                        return 0;
-                }
-                if (loop_pass) {
-                        ext2fs_mark_inode_bitmap(inode_loop_detect,
-                                                 p->ino);
-                } else if (parent_count++ > 2048) {
-                        /*
-                         * If we've run into a path depth that's
-                         * greater than 2048, try again with the inode
-                         * loop bitmap turned on and start from the
-                         * top.
-                         */
-                        loop_pass = 1;
-                        if (inode_loop_detect)
-                                ext2fs_clear_inode_bitmap(inode_loop_detect);
-                        else {
-                                pctx->errcode = ext2fs_allocate_inode_bitmap(fs, _("inode loop detection bitmap"), &inode_loop_detect);
-                                if (pctx->errcode) {
-                                        pctx->num = 1;
-                                        fix_problem(ctx, 
-                                    PR_3_ALLOCATE_IBITMAP_ERROR, pctx);
-                                        ctx->flags |= E2F_FLAG_ABORT;
-                                        return -1;
-                                }
-                        }
-                        p = dir;
-                }
-        }
-
-        /*
-         * Make sure that .. and the parent directory are the same;
-         * offer to fix it if not.
-         */
-        if (dir->parent != dir->dotdot) {
-                pctx->ino = dir->ino;
-                pctx->ino2 = dir->dotdot;
-                pctx->dir = dir->parent;
-                if (fix_problem(ctx, PR_3_BAD_DOT_DOT, pctx))
-                        fix_dotdot(ctx, dir, dir->parent);
-        }
-        return 0;
-}
-
-/*
- * This routine gets the lost_and_found inode, making it a directory
- * if necessary
- */
-ext2_ino_t e2fsck_get_lost_and_found(e2fsck_t ctx, int fix)
-{
-        ext2_filsys fs = ctx->fs;
-        ext2_ino_t                      ino;
-        blk_t                   blk;
-        errcode_t               retval;
-        struct ext2_inode       inode;
-        char *                  block;
-        static const char       name[] = "lost+found";
-        struct  problem_context pctx;
-        struct dir_info         *dirinfo;
-
-        if (ctx->lost_and_found)
-                return ctx->lost_and_found;
-
-        clear_problem_context(&pctx);
-        
-        retval = ext2fs_lookup(fs, EXT2_ROOT_INO, name,
-                               sizeof(name)-1, 0, &ino);
-        if (retval && !fix)
-                return 0;
-        if (!retval) {
-                if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, ino)) {
-                        ctx->lost_and_found = ino;
-                        return ino;
-                }
-                                
-                /* Lost+found isn't a directory! */
-                if (!fix)
-                        return 0;
-                pctx.ino = ino;
-                if (!fix_problem(ctx, PR_3_LPF_NOTDIR, &pctx))
-                        return 0;
-
-                /* OK, unlink the old /lost+found file. */
-                pctx.errcode = ext2fs_unlink(fs, EXT2_ROOT_INO, name, ino, 0);
-                if (pctx.errcode) {
-                        pctx.str = "ext2fs_unlink";
-                        fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
-                        return 0;
-                }
-                dirinfo = e2fsck_get_dir_info(ctx, ino);
-                if (dirinfo)
-                        dirinfo->parent = 0;
-                e2fsck_adjust_inode_count(ctx, ino, -1);
-        } else if (retval != EXT2_ET_FILE_NOT_FOUND) {
-                pctx.errcode = retval;
-                fix_problem(ctx, PR_3_ERR_FIND_LPF, &pctx);
-        }
-        if (!fix_problem(ctx, PR_3_NO_LF_DIR, 0))
-                return 0;
-
-        /*
-         * Read the inode and block bitmaps in; we'll be messing with
-         * them.
-         */
-        e2fsck_read_bitmaps(ctx);
-        
-        /*
-         * First, find a free block
-         */
-        retval = ext2fs_new_block(fs, 0, ctx->block_found_map, &blk);
-        if (retval) {
-                pctx.errcode = retval;
-                fix_problem(ctx, PR_3_ERR_LPF_NEW_BLOCK, &pctx);
-                return 0;
-        }
-        ext2fs_mark_block_bitmap(ctx->block_found_map, blk);
-        ext2fs_block_alloc_stats(fs, blk, +1);
-
-        /*
-         * Next find a free inode.
-         */
-        retval = ext2fs_new_inode(fs, EXT2_ROOT_INO, 040700,
-                                  ctx->inode_used_map, &ino);
-        if (retval) {
-                pctx.errcode = retval;
-                fix_problem(ctx, PR_3_ERR_LPF_NEW_INODE, &pctx);
-                return 0;
-        }
-        ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino);
-        ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino);
-        ext2fs_inode_alloc_stats2(fs, ino, +1, 1);
-
-        /*
-         * Now let's create the actual data block for the inode
-         */
-        retval = ext2fs_new_dir_block(fs, ino, EXT2_ROOT_INO, &block);
-        if (retval) {
-                pctx.errcode = retval;
-                fix_problem(ctx, PR_3_ERR_LPF_NEW_DIR_BLOCK, &pctx);
-                return 0;
-        }
-
-        retval = ext2fs_write_dir_block(fs, blk, block);
-        ext2fs_free_mem(&block);
-        if (retval) {
-                pctx.errcode = retval;
-                fix_problem(ctx, PR_3_ERR_LPF_WRITE_BLOCK, &pctx);
-                return 0;
-        }
-
-        /*
-         * Set up the inode structure
-         */
-        memset(&inode, 0, sizeof(inode));
-        inode.i_mode = 040700;
-        inode.i_size = fs->blocksize;
-        inode.i_atime = inode.i_ctime = inode.i_mtime = time(0);
-        inode.i_links_count = 2;
-        inode.i_blocks = fs->blocksize / 512;
-        inode.i_block[0] = blk;
-
-        /*
-         * Next, write out the inode.
-         */
-        pctx.errcode = ext2fs_write_new_inode(fs, ino, &inode);
-        if (pctx.errcode) {
-                pctx.str = "ext2fs_write_inode";
-                fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
-                return 0;
-        }
-        /*
-         * Finally, create the directory link
-         */
-        pctx.errcode = ext2fs_link(fs, EXT2_ROOT_INO, name, ino, EXT2_FT_DIR);
-        if (pctx.errcode) {
-                pctx.str = "ext2fs_link";
-                fix_problem(ctx, PR_3_CREATE_LPF_ERROR, &pctx);
-                return 0;
-        }
-
-        /*
-         * Miscellaneous bookkeeping that needs to be kept straight.
-         */
-        e2fsck_add_dir_info(ctx, ino, EXT2_ROOT_INO);
-        e2fsck_adjust_inode_count(ctx, EXT2_ROOT_INO, 1);
-        ext2fs_icount_store(ctx->inode_count, ino, 2);
-        ext2fs_icount_store(ctx->inode_link_info, ino, 2);
-        ctx->lost_and_found = ino;
-#if 0
-        printf("/lost+found created; inode #%lu\n", ino);
-#endif
-        return ino;
-}
-
-/*
- * This routine will connect a file to lost+found
- */
-int e2fsck_reconnect_file(e2fsck_t ctx, ext2_ino_t ino)
-{
-        ext2_filsys fs = ctx->fs;
-        errcode_t       retval;
-        char            name[80];
-        struct problem_context  pctx;
-        struct ext2_inode       inode;
-        int             file_type = 0;
-
-        clear_problem_context(&pctx);
-        pctx.ino = ino;
-
-        if (!ctx->bad_lost_and_found && !ctx->lost_and_found) {
-                if (e2fsck_get_lost_and_found(ctx, 1) == 0)
-                        ctx->bad_lost_and_found++;
-        }
-        if (ctx->bad_lost_and_found) {
-                fix_problem(ctx, PR_3_NO_LPF, &pctx);
-                return 1;
-        }
-        
-        sprintf(name, "#%u", ino);
-        if (ext2fs_read_inode(fs, ino, &inode) == 0)
-                file_type = ext2_file_type(inode.i_mode);
-        retval = ext2fs_link(fs, ctx->lost_and_found, name, ino, file_type);
-        if (retval == EXT2_ET_DIR_NO_SPACE) {
-                if (!fix_problem(ctx, PR_3_EXPAND_LF_DIR, &pctx))
-                        return 1;
-                retval = e2fsck_expand_directory(ctx, ctx->lost_and_found, 
-                                                 1, 0);
-                if (retval) {
-                        pctx.errcode = retval;
-                        fix_problem(ctx, PR_3_CANT_EXPAND_LPF, &pctx);
-                        return 1;
-                }
-                retval = ext2fs_link(fs, ctx->lost_and_found, name,
-                                     ino, file_type);
-        }
-        if (retval) {
-                pctx.errcode = retval;
-                fix_problem(ctx, PR_3_CANT_RECONNECT, &pctx);
-                return 1;
-        }
-        e2fsck_adjust_inode_count(ctx, ino, 1);
-
-        return 0;
-}
-
-/*
- * Utility routine to adjust the inode counts on an inode.
- */
-errcode_t e2fsck_adjust_inode_count(e2fsck_t ctx, ext2_ino_t ino, int adj)
-{
-        ext2_filsys fs = ctx->fs;
-        errcode_t               retval;
-        struct ext2_inode       inode;
-        
-        if (!ino)
-                return 0;
-
-        retval = ext2fs_read_inode(fs, ino, &inode);
-        if (retval)
-                return retval;
-
-#if 0
-        printf("Adjusting link count for inode %lu by %d (from %d)\n", ino, adj,
-               inode.i_links_count);
-#endif
-
-        if (adj == 1) {
-                ext2fs_icount_increment(ctx->inode_count, ino, 0);
-                if (inode.i_links_count == (__u16) ~0)
-                        return 0;
-                ext2fs_icount_increment(ctx->inode_link_info, ino, 0);
-                inode.i_links_count++;
-        } else if (adj == -1) {
-                ext2fs_icount_decrement(ctx->inode_count, ino, 0);
-                if (inode.i_links_count == 0)
-                        return 0;
-                ext2fs_icount_decrement(ctx->inode_link_info, ino, 0);
-                inode.i_links_count--;
-        }
-        
-        retval = ext2fs_write_inode(fs, ino, &inode);
-        if (retval)
-                return retval;
-
-        return 0;
-}
-
-/*
- * Fix parent --- this routine fixes up the parent of a directory.
- */
-struct fix_dotdot_struct {
-        ext2_filsys     fs;
-        ext2_ino_t      parent;
-        int             done;
-        e2fsck_t        ctx;
-};
-
-static int fix_dotdot_proc(struct ext2_dir_entry *dirent,
-                           int  offset EXT2FS_ATTR((unused)),
-                           int  blocksize EXT2FS_ATTR((unused)),
-                           char *buf EXT2FS_ATTR((unused)),
-                           void *priv_data)
-{
-        struct fix_dotdot_struct *fp = (struct fix_dotdot_struct *) priv_data;
-        errcode_t       retval;
-        struct problem_context pctx;
-
-        if ((dirent->name_len & 0xFF) != 2)
-                return 0;
-        if (strncmp(dirent->name, "..", 2))
-                return 0;
-
-        clear_problem_context(&pctx);
-        
-        retval = e2fsck_adjust_inode_count(fp->ctx, dirent->inode, -1);
-        if (retval) {
-                pctx.errcode = retval;
-                fix_problem(fp->ctx, PR_3_ADJUST_INODE, &pctx);
-        }
-        retval = e2fsck_adjust_inode_count(fp->ctx, fp->parent, 1);
-        if (retval) {
-                pctx.errcode = retval;
-                fix_problem(fp->ctx, PR_3_ADJUST_INODE, &pctx);
-        }
-        dirent->inode = fp->parent;
-
-        fp->done++;
-        return DIRENT_ABORT | DIRENT_CHANGED;
-}
-
-static void fix_dotdot(e2fsck_t ctx, struct dir_info *dir, ext2_ino_t parent)
-{
-        ext2_filsys fs = ctx->fs;
-        errcode_t       retval;
-        struct fix_dotdot_struct fp;
-        struct problem_context pctx;
-
-        fp.fs = fs;
-        fp.parent = parent;
-        fp.done = 0;
-        fp.ctx = ctx;
-
-#if 0
-        printf("Fixing '..' of inode %lu to be %lu...\n", dir->ino, parent);
-#endif
-        
-        retval = ext2fs_dir_iterate(fs, dir->ino, DIRENT_FLAG_INCLUDE_EMPTY,
-                                    0, fix_dotdot_proc, &fp);
-        if (retval || !fp.done) {
-                clear_problem_context(&pctx);
-                pctx.ino = dir->ino;
-                pctx.errcode = retval;
-                fix_problem(ctx, retval ? PR_3_FIX_PARENT_ERR :
-                            PR_3_FIX_PARENT_NOFIND, &pctx);
-                ext2fs_unmark_valid(fs);
-        }
-        dir->dotdot = parent;
-        
-        return;
-}
-
-/*
- * These routines are responsible for expanding a /lost+found if it is
- * too small.
- */
-
-struct expand_dir_struct {
-        int                     num;
-        int                     guaranteed_size;
-        int                     newblocks;
-        int                     last_block;
-        errcode_t               err;
-        e2fsck_t                ctx;
-};
-
-static int expand_dir_proc(ext2_filsys fs,
-                           blk_t        *blocknr,
-                           e2_blkcnt_t  blockcnt,
-                           blk_t ref_block EXT2FS_ATTR((unused)),
-                           int ref_offset EXT2FS_ATTR((unused)),
-                           void *priv_data)
-{
-        struct expand_dir_struct *es = (struct expand_dir_struct *) priv_data;
-        blk_t   new_blk;
-        static blk_t    last_blk = 0;
-        char            *block;
-        errcode_t       retval;
-        e2fsck_t        ctx;
-
-        ctx = es->ctx;
-        
-        if (es->guaranteed_size && blockcnt >= es->guaranteed_size)
-                return BLOCK_ABORT;
-
-        if (blockcnt > 0)
-                es->last_block = blockcnt;
-        if (*blocknr) {
-                last_blk = *blocknr;
-                return 0;
-        }
-        retval = ext2fs_new_block(fs, last_blk, ctx->block_found_map,
-                                  &new_blk);
-        if (retval) {
-                es->err = retval;
-                return BLOCK_ABORT;
-        }
-        if (blockcnt > 0) {
-                retval = ext2fs_new_dir_block(fs, 0, 0, &block);
-                if (retval) {
-                        es->err = retval;
-                        return BLOCK_ABORT;
-                }
-                es->num--;
-                retval = ext2fs_write_dir_block(fs, new_blk, block);
-        } else {
-                retval = ext2fs_get_mem(fs->blocksize, &block);
-                if (retval) {
-                        es->err = retval;
-                        return BLOCK_ABORT;
-                }
-                memset(block, 0, fs->blocksize);
-                retval = io_channel_write_blk(fs->io, new_blk, 1, block);
-        }       
-        if (retval) {
-                es->err = retval;
-                return BLOCK_ABORT;
-        }
-        ext2fs_free_mem(&block);
-        *blocknr = new_blk;
-        ext2fs_mark_block_bitmap(ctx->block_found_map, new_blk);
-        ext2fs_block_alloc_stats(fs, new_blk, +1);
-        es->newblocks++;
-        
-        if (es->num == 0)
-                return (BLOCK_CHANGED | BLOCK_ABORT);
-        else
-                return BLOCK_CHANGED;
-}
-
-errcode_t e2fsck_expand_directory(e2fsck_t ctx, ext2_ino_t dir,
-                                  int num, int guaranteed_size)
-{
-        ext2_filsys fs = ctx->fs;
-        errcode_t       retval;
-        struct expand_dir_struct es;
-        struct ext2_inode       inode;
-        
-        if (!(fs->flags & EXT2_FLAG_RW))
-                return EXT2_ET_RO_FILSYS;
-
-        /*
-         * Read the inode and block bitmaps in; we'll be messing with
-         * them.
-         */
-        e2fsck_read_bitmaps(ctx);
-
-        retval = ext2fs_check_directory(fs, dir);
-        if (retval)
-                return retval;
-        
-        es.num = num;
-        es.guaranteed_size = guaranteed_size;
-        es.last_block = 0;
-        es.err = 0;
-        es.newblocks = 0;
-        es.ctx = ctx;
-        
-        retval = ext2fs_block_iterate2(fs, dir, BLOCK_FLAG_APPEND,
-                                       0, expand_dir_proc, &es);
-
-        if (es.err)
-                return es.err;
-
-        /*
-         * Update the size and block count fields in the inode.
-         */
-        retval = ext2fs_read_inode(fs, dir, &inode);
-        if (retval)
-                return retval;
-        
-        inode.i_size = (es.last_block + 1) * fs->blocksize;
-        inode.i_blocks += (fs->blocksize / 512) * es.newblocks;
-
-        e2fsck_write_inode(ctx, dir, &inode, "expand_directory");
-
-        return 0;
-}
-
diff --git a/e2fsprogs/e2fsck/pass4.c b/e2fsprogs/e2fsck/pass4.c
deleted file mode 100644
index a9e49f178..000000000
--- a/e2fsprogs/e2fsck/pass4.c
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- * pass4.c -- pass #4 of e2fsck: Check reference counts
- *
- * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- *
- * Pass 4 frees the following data structures:
- *      - A bitmap of which inodes are in bad blocks.   (inode_bb_map)
- *      - A bitmap of which inodes are imagic inodes.   (inode_imagic_map)
- */
-
-#include "e2fsck.h"
-#include "problem.h"
-
-/*
- * This routine is called when an inode is not connected to the
- * directory tree.
- * 
- * This subroutine returns 1 then the caller shouldn't bother with the
- * rest of the pass 4 tests.
- */
-static int disconnect_inode(e2fsck_t ctx, ext2_ino_t i)
-{
-        ext2_filsys fs = ctx->fs;
-        struct ext2_inode       inode;
-        struct problem_context  pctx;
-
-        e2fsck_read_inode(ctx, i, &inode, "pass4: disconnect_inode");
-        clear_problem_context(&pctx);
-        pctx.ino = i;
-        pctx.inode = &inode;
-        
-        /*
-         * Offer to delete any zero-length files that does not have
-         * blocks.  If there is an EA block, it might have useful
-         * information, so we won't prompt to delete it, but let it be
-         * reconnected to lost+found.
-         */
-        if (!inode.i_blocks && (LINUX_S_ISREG(inode.i_mode) ||
-                                LINUX_S_ISDIR(inode.i_mode))) {
-                if (fix_problem(ctx, PR_4_ZERO_LEN_INODE, &pctx)) {
-                        ext2fs_icount_store(ctx->inode_link_info, i, 0);
-                        inode.i_links_count = 0;
-                        inode.i_dtime = time(0);
-                        e2fsck_write_inode(ctx, i, &inode,
-                                           "disconnect_inode");
-                        /*
-                         * Fix up the bitmaps...
-                         */
-                        e2fsck_read_bitmaps(ctx);
-                        ext2fs_unmark_inode_bitmap(ctx->inode_used_map, i);
-                        ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, i);
-                        ext2fs_inode_alloc_stats2(fs, i, -1,
-                                                  LINUX_S_ISDIR(inode.i_mode));
-                        return 0;
-                }
-        }
-        
-        /*
-         * Prompt to reconnect.
-         */
-        if (fix_problem(ctx, PR_4_UNATTACHED_INODE, &pctx)) {
-                if (e2fsck_reconnect_file(ctx, i))
-                        ext2fs_unmark_valid(fs);
-        } else {
-                /*
-                 * If we don't attach the inode, then skip the
-                 * i_links_test since there's no point in trying to
-                 * force i_links_count to zero.
-                 */
-                ext2fs_unmark_valid(fs);
-                return 1;
-        }
-        return 0;
-}
-
-
-void e2fsck_pass4(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        ext2_ino_t      i;
-        struct ext2_inode       inode;
-#ifdef RESOURCE_TRACK
-        struct resource_track   rtrack;
-#endif
-        struct problem_context  pctx;
-        __u16   link_count, link_counted;
-        char    *buf = 0;
-        int     group, maxgroup;
-        
-#ifdef RESOURCE_TRACK
-        init_resource_track(&rtrack);
-#endif
-
-#ifdef MTRACE
-        mtrace_print("Pass 4");
-#endif
-
-        clear_problem_context(&pctx);
-
-        if (!(ctx->options & E2F_OPT_PREEN))
-                fix_problem(ctx, PR_4_PASS_HEADER, &pctx);
-
-        group = 0;
-        maxgroup = fs->group_desc_count;
-        if (ctx->progress)
-                if ((ctx->progress)(ctx, 4, 0, maxgroup))
-                        return;
-        
-        for (i=1; i <= fs->super->s_inodes_count; i++) {
-                if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                        return;
-                if ((i % fs->super->s_inodes_per_group) == 0) {
-                        group++;
-                        if (ctx->progress)
-                                if ((ctx->progress)(ctx, 4, group, maxgroup))
-                                        return;
-                }
-                if (i == EXT2_BAD_INO ||
-                    (i > EXT2_ROOT_INO && i < EXT2_FIRST_INODE(fs->super)))
-                        continue;
-                if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, i)) ||
-                    (ctx->inode_imagic_map &&
-                     ext2fs_test_inode_bitmap(ctx->inode_imagic_map, i)) ||
-                    (ctx->inode_bb_map &&
-                     ext2fs_test_inode_bitmap(ctx->inode_bb_map, i)))
-                        continue;
-                ext2fs_icount_fetch(ctx->inode_link_info, i, &link_count);
-                ext2fs_icount_fetch(ctx->inode_count, i, &link_counted);
-                if (link_counted == 0) {
-                        if (!buf)
-                                buf = e2fsck_allocate_memory(ctx,
-                                     fs->blocksize, "bad_inode buffer");
-                        if (e2fsck_process_bad_inode(ctx, 0, i, buf))
-                                continue;
-                        if (disconnect_inode(ctx, i))
-                                continue;
-                        ext2fs_icount_fetch(ctx->inode_link_info, i,
-                                            &link_count);
-                        ext2fs_icount_fetch(ctx->inode_count, i,
-                                            &link_counted);
-                }
-                if (link_counted != link_count) {
-                        e2fsck_read_inode(ctx, i, &inode, "pass4");
-                        pctx.ino = i;
-                        pctx.inode = &inode;
-                        if (link_count != inode.i_links_count) {
-                                pctx.num = link_count;
-                                fix_problem(ctx,
-                                            PR_4_INCONSISTENT_COUNT, &pctx);
-                        }
-                        pctx.num = link_counted;
-                        if (fix_problem(ctx, PR_4_BAD_REF_COUNT, &pctx)) {
-                                inode.i_links_count = link_counted;
-                                e2fsck_write_inode(ctx, i, &inode, "pass4");
-                        }
-                }
-        }
-        ext2fs_free_icount(ctx->inode_link_info); ctx->inode_link_info = 0;
-        ext2fs_free_icount(ctx->inode_count); ctx->inode_count = 0;
-        ext2fs_free_inode_bitmap(ctx->inode_bb_map);
-        ctx->inode_bb_map = 0;
-        ext2fs_free_inode_bitmap(ctx->inode_imagic_map);
-        ctx->inode_imagic_map = 0;
-        if (buf)
-                ext2fs_free_mem(&buf);
-#ifdef RESOURCE_TRACK
-        if (ctx->options & E2F_OPT_TIME2) {
-                e2fsck_clear_progbar(ctx);
-                print_resource_track(_("Pass 4"), &rtrack);
-        }
-#endif
-}
-
diff --git a/e2fsprogs/e2fsck/pass5.c b/e2fsprogs/e2fsck/pass5.c
deleted file mode 100644
index e708fa41d..000000000
--- a/e2fsprogs/e2fsck/pass5.c
+++ /dev/null
@@ -1,547 +0,0 @@
-/*
- * pass5.c --- check block and inode bitmaps against on-disk bitmaps
- * 
- * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- * 
- */
-
-#include "e2fsck.h"
-#include "problem.h"
-
-static void check_block_bitmaps(e2fsck_t ctx);
-static void check_inode_bitmaps(e2fsck_t ctx);
-static void check_inode_end(e2fsck_t ctx);
-static void check_block_end(e2fsck_t ctx);
-
-void e2fsck_pass5(e2fsck_t ctx)
-{
-#ifdef RESOURCE_TRACK
-        struct resource_track   rtrack;
-#endif
-        struct problem_context  pctx;
-        
-#ifdef MTRACE
-        mtrace_print("Pass 5");
-#endif
-
-#ifdef RESOURCE_TRACK
-        init_resource_track(&rtrack);
-#endif
-        
-        clear_problem_context(&pctx);
-
-        if (!(ctx->options & E2F_OPT_PREEN))
-                fix_problem(ctx, PR_5_PASS_HEADER, &pctx);
-
-        if (ctx->progress)
-                if ((ctx->progress)(ctx, 5, 0, ctx->fs->group_desc_count*2))
-                        return;
-
-        e2fsck_read_bitmaps(ctx);
-
-        check_block_bitmaps(ctx);
-        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                return;
-        check_inode_bitmaps(ctx);
-        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                return;
-        check_inode_end(ctx);
-        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                return;
-        check_block_end(ctx);
-        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                return;
-
-        ext2fs_free_inode_bitmap(ctx->inode_used_map);
-        ctx->inode_used_map = 0;
-        ext2fs_free_inode_bitmap(ctx->inode_dir_map);
-        ctx->inode_dir_map = 0;
-        ext2fs_free_block_bitmap(ctx->block_found_map);
-        ctx->block_found_map = 0;
-
-#ifdef RESOURCE_TRACK
-        if (ctx->options & E2F_OPT_TIME2) {
-                e2fsck_clear_progbar(ctx);
-                print_resource_track(_("Pass 5"), &rtrack);
-        }
-#endif
-}
-
-#define NO_BLK ((blk_t) -1)
-
-static void print_bitmap_problem(e2fsck_t ctx, int problem,
-                            struct problem_context *pctx)
-{
-        switch (problem) {
-        case PR_5_BLOCK_UNUSED:
-                if (pctx->blk == pctx->blk2)
-                        pctx->blk2 = 0;
-                else
-                        problem = PR_5_BLOCK_RANGE_UNUSED;
-                break;
-        case PR_5_BLOCK_USED:
-                if (pctx->blk == pctx->blk2)
-                        pctx->blk2 = 0;
-                else
-                        problem = PR_5_BLOCK_RANGE_USED;
-                break;
-        case PR_5_INODE_UNUSED:
-                if (pctx->ino == pctx->ino2)
-                        pctx->ino2 = 0;
-                else
-                        problem = PR_5_INODE_RANGE_UNUSED;
-                break;
-        case PR_5_INODE_USED:
-                if (pctx->ino == pctx->ino2)
-                        pctx->ino2 = 0;
-                else
-                        problem = PR_5_INODE_RANGE_USED;
-                break;
-        }
-        fix_problem(ctx, problem, pctx);
-        pctx->blk = pctx->blk2 = NO_BLK;
-        pctx->ino = pctx->ino2 = 0;
-}
-        
-static void check_block_bitmaps(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        blk_t   i;
-        int     *free_array;
-        int     group = 0;
-        unsigned int    blocks = 0;
-        unsigned int    free_blocks = 0;
-        int     group_free = 0;
-        int     actual, bitmap;
-        struct problem_context  pctx;
-        int     problem, save_problem, fixit, had_problem;
-        errcode_t       retval;
-        
-        clear_problem_context(&pctx);
-        free_array = (int *) e2fsck_allocate_memory(ctx,
-            fs->group_desc_count * sizeof(int), "free block count array");
-
-        if ((fs->super->s_first_data_block <
-             ext2fs_get_block_bitmap_start(ctx->block_found_map)) ||
-            (fs->super->s_blocks_count-1 >
-             ext2fs_get_block_bitmap_end(ctx->block_found_map))) {
-                pctx.num = 1;
-                pctx.blk = fs->super->s_first_data_block;
-                pctx.blk2 = fs->super->s_blocks_count -1;
-                pctx.ino = ext2fs_get_block_bitmap_start(ctx->block_found_map);
-                pctx.ino2 = ext2fs_get_block_bitmap_end(ctx->block_found_map);
-                fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
-
-                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
-                return;
-        }
-                       
-        if ((fs->super->s_first_data_block <
-             ext2fs_get_block_bitmap_start(fs->block_map)) ||
-            (fs->super->s_blocks_count-1 >
-             ext2fs_get_block_bitmap_end(fs->block_map))) {
-                pctx.num = 2;
-                pctx.blk = fs->super->s_first_data_block;
-                pctx.blk2 = fs->super->s_blocks_count -1;
-                pctx.ino = ext2fs_get_block_bitmap_start(fs->block_map);
-                pctx.ino2 = ext2fs_get_block_bitmap_end(fs->block_map);
-                fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
-
-                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
-                return;
-        }
-                       
-redo_counts:
-        had_problem = 0;
-        save_problem = 0;
-        pctx.blk = pctx.blk2 = NO_BLK;
-        for (i = fs->super->s_first_data_block;
-             i < fs->super->s_blocks_count;
-             i++) {
-                actual = ext2fs_fast_test_block_bitmap(ctx->block_found_map, i);
-                bitmap = ext2fs_fast_test_block_bitmap(fs->block_map, i);
-                
-                if (actual == bitmap)
-                        goto do_counts;
-                
-                if (!actual && bitmap) {
-                        /*
-                         * Block not used, but marked in use in the bitmap.
-                         */
-                        problem = PR_5_BLOCK_UNUSED;
-                } else {
-                        /*
-                         * Block used, but not marked in use in the bitmap.
-                         */
-                        problem = PR_5_BLOCK_USED;
-                }
-                if (pctx.blk == NO_BLK) {
-                        pctx.blk = pctx.blk2 = i;
-                        save_problem = problem;
-                } else {
-                        if ((problem == save_problem) &&
-                            (pctx.blk2 == i-1))
-                                pctx.blk2++;
-                        else {
-                                print_bitmap_problem(ctx, save_problem, &pctx);
-                                pctx.blk = pctx.blk2 = i;
-                                save_problem = problem;
-                        }
-                }
-                ctx->flags |= E2F_FLAG_PROG_SUPPRESS;
-                had_problem++;
-                
-        do_counts:
-                if (!bitmap) {
-                        group_free++;
-                        free_blocks++;
-                }
-                blocks ++;
-                if ((blocks == fs->super->s_blocks_per_group) ||
-                    (i == fs->super->s_blocks_count-1)) {
-                        free_array[group] = group_free;
-                        group ++;
-                        blocks = 0;
-                        group_free = 0;
-                        if (ctx->progress)
-                                if ((ctx->progress)(ctx, 5, group,
-                                                    fs->group_desc_count*2))
-                                        return;
-                }
-        }
-        if (pctx.blk != NO_BLK)
-                print_bitmap_problem(ctx, save_problem, &pctx);
-        if (had_problem)
-                fixit = end_problem_latch(ctx, PR_LATCH_BBITMAP);
-        else
-                fixit = -1;
-        ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS;
-        
-        if (fixit == 1) {
-                ext2fs_free_block_bitmap(fs->block_map);
-                retval = ext2fs_copy_bitmap(ctx->block_found_map,
-                                                  &fs->block_map);
-                if (retval) {
-                        clear_problem_context(&pctx);
-                        fix_problem(ctx, PR_5_COPY_BBITMAP_ERROR, &pctx);
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return;
-                }
-                ext2fs_set_bitmap_padding(fs->block_map);
-                ext2fs_mark_bb_dirty(fs);
-                
-                /* Redo the counts */
-                blocks = 0; free_blocks = 0; group_free = 0; group = 0;
-                memset(free_array, 0, fs->group_desc_count * sizeof(int));
-                goto redo_counts;
-        } else if (fixit == 0)
-                ext2fs_unmark_valid(fs);
-
-        for (i = 0; i < fs->group_desc_count; i++) {
-                if (free_array[i] != fs->group_desc[i].bg_free_blocks_count) {
-                        pctx.group = i;
-                        pctx.blk = fs->group_desc[i].bg_free_blocks_count;
-                        pctx.blk2 = free_array[i];
-
-                        if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP,
-                                        &pctx)) {
-                                fs->group_desc[i].bg_free_blocks_count =
-                                        free_array[i];
-                                ext2fs_mark_super_dirty(fs);
-                        } else
-                                ext2fs_unmark_valid(fs);
-                }
-        }
-        if (free_blocks != fs->super->s_free_blocks_count) {
-                pctx.group = 0;
-                pctx.blk = fs->super->s_free_blocks_count;
-                pctx.blk2 = free_blocks;
-
-                if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) {
-                        fs->super->s_free_blocks_count = free_blocks;
-                        ext2fs_mark_super_dirty(fs);
-                } else
-                        ext2fs_unmark_valid(fs);
-        }
-        ext2fs_free_mem(&free_array);
-}
-                        
-static void check_inode_bitmaps(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        ext2_ino_t      i;
-        unsigned int    free_inodes = 0;
-        int             group_free = 0;
-        int             dirs_count = 0;
-        int             group = 0;
-        unsigned int    inodes = 0;
-        int             *free_array;
-        int             *dir_array;
-        int             actual, bitmap;
-        errcode_t       retval;
-        struct problem_context  pctx;
-        int             problem, save_problem, fixit, had_problem;
-        
-        clear_problem_context(&pctx);
-        free_array = (int *) e2fsck_allocate_memory(ctx,
-            fs->group_desc_count * sizeof(int), "free inode count array");
-                                     
-        dir_array = (int *) e2fsck_allocate_memory(ctx,
-           fs->group_desc_count * sizeof(int), "directory count array");
-                                     
-        if ((1 < ext2fs_get_inode_bitmap_start(ctx->inode_used_map)) ||
-            (fs->super->s_inodes_count > 
-             ext2fs_get_inode_bitmap_end(ctx->inode_used_map))) {
-                pctx.num = 3;
-                pctx.blk = 1;
-                pctx.blk2 = fs->super->s_inodes_count;
-                pctx.ino = ext2fs_get_inode_bitmap_start(ctx->inode_used_map);
-                pctx.ino2 = ext2fs_get_inode_bitmap_end(ctx->inode_used_map);
-                fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
-
-                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
-                return;
-        }
-        if ((1 < ext2fs_get_inode_bitmap_start(fs->inode_map)) ||
-            (fs->super->s_inodes_count > 
-             ext2fs_get_inode_bitmap_end(fs->inode_map))) {
-                pctx.num = 4;
-                pctx.blk = 1;
-                pctx.blk2 = fs->super->s_inodes_count;
-                pctx.ino = ext2fs_get_inode_bitmap_start(fs->inode_map);
-                pctx.ino2 = ext2fs_get_inode_bitmap_end(fs->inode_map);
-                fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
-
-                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
-                return;
-        }
-
-redo_counts:
-        had_problem = 0;
-        save_problem = 0;
-        pctx.ino = pctx.ino2 = 0;
-        for (i = 1; i <= fs->super->s_inodes_count; i++) {
-                actual = ext2fs_fast_test_inode_bitmap(ctx->inode_used_map, i);
-                bitmap = ext2fs_fast_test_inode_bitmap(fs->inode_map, i);
-                
-                if (actual == bitmap)
-                        goto do_counts;
-                
-                if (!actual && bitmap) {
-                        /*
-                         * Inode wasn't used, but marked in bitmap
-                         */
-                        problem = PR_5_INODE_UNUSED;
-                } else /* if (actual && !bitmap) */ {
-                        /*
-                         * Inode used, but not in bitmap
-                         */
-                        problem = PR_5_INODE_USED;
-                }
-                if (pctx.ino == 0) {
-                        pctx.ino = pctx.ino2 = i;
-                        save_problem = problem;
-                } else {
-                        if ((problem == save_problem) &&
-                            (pctx.ino2 == i-1))
-                                pctx.ino2++;
-                        else {
-                                print_bitmap_problem(ctx, save_problem, &pctx);
-                                pctx.ino = pctx.ino2 = i;
-                                save_problem = problem;
-                        }
-                }
-                ctx->flags |= E2F_FLAG_PROG_SUPPRESS;
-                had_problem++;
-                
-do_counts:
-                if (!bitmap) {
-                        group_free++;
-                        free_inodes++;
-                } else {
-                        if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, i))
-                                dirs_count++;
-                }
-                inodes++;
-                if ((inodes == fs->super->s_inodes_per_group) ||
-                    (i == fs->super->s_inodes_count)) {
-                        free_array[group] = group_free;
-                        dir_array[group] = dirs_count;
-                        group ++;
-                        inodes = 0;
-                        group_free = 0;
-                        dirs_count = 0;
-                        if (ctx->progress)
-                                if ((ctx->progress)(ctx, 5,
-                                            group + fs->group_desc_count,
-                                            fs->group_desc_count*2))
-                                        return;
-                }
-        }
-        if (pctx.ino)
-                print_bitmap_problem(ctx, save_problem, &pctx);
-        
-        if (had_problem)
-                fixit = end_problem_latch(ctx, PR_LATCH_IBITMAP);
-        else
-                fixit = -1;
-        ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS;
-        
-        if (fixit == 1) {
-                ext2fs_free_inode_bitmap(fs->inode_map);
-                retval = ext2fs_copy_bitmap(ctx->inode_used_map,
-                                                  &fs->inode_map);
-                if (retval) {
-                        clear_problem_context(&pctx);
-                        fix_problem(ctx, PR_5_COPY_IBITMAP_ERROR, &pctx);
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return;
-                }
-                ext2fs_set_bitmap_padding(fs->inode_map);
-                ext2fs_mark_ib_dirty(fs);
-
-                /* redo counts */
-                inodes = 0; free_inodes = 0; group_free = 0;
-                dirs_count = 0; group = 0;
-                memset(free_array, 0, fs->group_desc_count * sizeof(int));
-                memset(dir_array, 0, fs->group_desc_count * sizeof(int));
-                goto redo_counts;
-        } else if (fixit == 0)
-                ext2fs_unmark_valid(fs);
-        
-        for (i = 0; i < fs->group_desc_count; i++) {
-                if (free_array[i] != fs->group_desc[i].bg_free_inodes_count) {
-                        pctx.group = i;
-                        pctx.ino = fs->group_desc[i].bg_free_inodes_count;
-                        pctx.ino2 = free_array[i];
-                        if (fix_problem(ctx, PR_5_FREE_INODE_COUNT_GROUP,
-                                        &pctx)) {
-                                fs->group_desc[i].bg_free_inodes_count =
-                                        free_array[i];
-                                ext2fs_mark_super_dirty(fs);
-                        } else
-                                ext2fs_unmark_valid(fs);
-                }
-                if (dir_array[i] != fs->group_desc[i].bg_used_dirs_count) {
-                        pctx.group = i;
-                        pctx.ino = fs->group_desc[i].bg_used_dirs_count;
-                        pctx.ino2 = dir_array[i];
-
-                        if (fix_problem(ctx, PR_5_FREE_DIR_COUNT_GROUP,
-                                        &pctx)) {
-                                fs->group_desc[i].bg_used_dirs_count =
-                                        dir_array[i];
-                                ext2fs_mark_super_dirty(fs);
-                        } else
-                                ext2fs_unmark_valid(fs);
-                }
-        }
-        if (free_inodes != fs->super->s_free_inodes_count) {
-                pctx.group = -1;
-                pctx.ino = fs->super->s_free_inodes_count;
-                pctx.ino2 = free_inodes;
-
-                if (fix_problem(ctx, PR_5_FREE_INODE_COUNT, &pctx)) {
-                        fs->super->s_free_inodes_count = free_inodes;
-                        ext2fs_mark_super_dirty(fs);
-                } else
-                        ext2fs_unmark_valid(fs);
-        }
-        ext2fs_free_mem(&free_array);
-        ext2fs_free_mem(&dir_array);
-}
-
-static void check_inode_end(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        ext2_ino_t      end, save_inodes_count, i;
-        struct problem_context  pctx;
-
-        clear_problem_context(&pctx);
-
-        end = EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count;
-        pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, end,
-                                                     &save_inodes_count);
-        if (pctx.errcode) {
-                pctx.num = 1;
-                fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
-                return;
-        }
-        if (save_inodes_count == end)
-                return;
-        
-        for (i = save_inodes_count + 1; i <= end; i++) {
-                if (!ext2fs_test_inode_bitmap(fs->inode_map, i)) {
-                        if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) {
-                                for (i = save_inodes_count + 1; i <= end; i++)
-                                        ext2fs_mark_inode_bitmap(fs->inode_map,
-                                                                 i);
-                                ext2fs_mark_ib_dirty(fs);
-                        } else
-                                ext2fs_unmark_valid(fs);
-                        break;
-                }
-        }
-
-        pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map,
-                                                     save_inodes_count, 0);
-        if (pctx.errcode) {
-                pctx.num = 2;
-                fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
-                return;
-        }
-}
-
-static void check_block_end(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        blk_t   end, save_blocks_count, i;
-        struct problem_context  pctx;
-
-        clear_problem_context(&pctx);
-
-        end = fs->block_map->start +
-                (EXT2_BLOCKS_PER_GROUP(fs->super) * fs->group_desc_count) - 1;
-        pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map, end,
-                                                     &save_blocks_count);
-        if (pctx.errcode) {
-                pctx.num = 3;
-                fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
-                return;
-        }
-        if (save_blocks_count == end)
-                return;
-        
-        for (i = save_blocks_count + 1; i <= end; i++) {
-                if (!ext2fs_test_block_bitmap(fs->block_map, i)) {
-                        if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) {
-                                for (i = save_blocks_count + 1; i <= end; i++)
-                                        ext2fs_mark_block_bitmap(fs->block_map,
-                                                                 i);
-                                ext2fs_mark_bb_dirty(fs);
-                        } else
-                                ext2fs_unmark_valid(fs);
-                        break;
-                }
-        }
-
-        pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map,
-                                                     save_blocks_count, 0);
-        if (pctx.errcode) {
-                pctx.num = 4;
-                fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT; /* fatal */
-                return;
-        }
-}
-
-
-
diff --git a/e2fsprogs/e2fsck/problem.c b/e2fsprogs/e2fsck/problem.c
deleted file mode 100644
index 7be4d6245..000000000
--- a/e2fsprogs/e2fsck/problem.c
+++ /dev/null
@@ -1,1655 +0,0 @@
-/*
- * problem.c --- report filesystem problems to the user
- *
- * Copyright 1996, 1997 by Theodore Ts'o
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- */
-
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <ctype.h>
-#include <termios.h>
-
-#include "e2fsck.h"
-
-#include "problem.h"
-#include "problemP.h"
-
-#define PROMPT_NONE     0
-#define PROMPT_FIX      1
-#define PROMPT_CLEAR    2
-#define PROMPT_RELOCATE 3
-#define PROMPT_ALLOCATE 4
-#define PROMPT_EXPAND   5
-#define PROMPT_CONNECT  6
-#define PROMPT_CREATE   7
-#define PROMPT_SALVAGE  8
-#define PROMPT_TRUNCATE 9
-#define PROMPT_CLEAR_INODE 10
-#define PROMPT_ABORT    11
-#define PROMPT_SPLIT    12
-#define PROMPT_CONTINUE 13
-#define PROMPT_CLONE    14
-#define PROMPT_DELETE   15
-#define PROMPT_SUPPRESS 16
-#define PROMPT_UNLINK   17
-#define PROMPT_CLEAR_HTREE 18
-#define PROMPT_RECREATE 19
-#define PROMPT_NULL     20
-
-/*
- * These are the prompts which are used to ask the user if they want
- * to fix a problem.
- */
-static const char *prompt[] = {
-        N_("(no prompt)"),      /* 0 */
-        N_("Fix"),              /* 1 */
-        N_("Clear"),            /* 2 */
-        N_("Relocate"),         /* 3 */
-        N_("Allocate"),         /* 4 */
-        N_("Expand"),           /* 5 */
-        N_("Connect to /lost+found"), /* 6 */
-        N_("Create"),           /* 7 */ 
-        N_("Salvage"),          /* 8 */
-        N_("Truncate"),         /* 9 */
-        N_("Clear inode"),      /* 10 */
-        N_("Abort"),            /* 11 */
-        N_("Split"),            /* 12 */
-        N_("Continue"),         /* 13 */
-        N_("Clone duplicate/bad blocks"), /* 14 */
-        N_("Delete file"),      /* 15 */
-        N_("Suppress messages"),/* 16 */
-        N_("Unlink"),           /* 17 */
-        N_("Clear HTree index"),/* 18 */
-        N_("Recreate"),         /* 19 */
-        "",                     /* 20 */
-};
-
-/*
- * These messages are printed when we are preen mode and we will be
- * automatically fixing the problem.
- */
-static const char *preen_msg[] = {
-        N_("(NONE)"),           /* 0 */
-        N_("FIXED"),            /* 1 */
-        N_("CLEARED"),          /* 2 */
-        N_("RELOCATED"),        /* 3 */
-        N_("ALLOCATED"),        /* 4 */
-        N_("EXPANDED"),         /* 5 */
-        N_("RECONNECTED"),      /* 6 */
-        N_("CREATED"),          /* 7 */
-        N_("SALVAGED"),         /* 8 */
-        N_("TRUNCATED"),        /* 9 */
-        N_("INODE CLEARED"),    /* 10 */
-        N_("ABORTED"),          /* 11 */
-        N_("SPLIT"),            /* 12 */
-        N_("CONTINUING"),       /* 13 */
-        N_("DUPLICATE/BAD BLOCKS CLONED"), /* 14 */
-        N_("FILE DELETED"),     /* 15 */
-        N_("SUPPRESSED"),       /* 16 */
-        N_("UNLINKED"),         /* 17 */
-        N_("HTREE INDEX CLEARED"),/* 18 */
-        N_("WILL RECREATE"),    /* 19 */
-        "",                     /* 20 */
-};
-
-static const struct e2fsck_problem problem_table[] = {
-
-        /* Pre-Pass 1 errors */
-
-        /* Block bitmap not in group */
-        { PR_0_BB_NOT_GROUP, N_("@b @B for @g %g is not in @g.  (@b %b)\n"),
-          PROMPT_RELOCATE, PR_LATCH_RELOC }, 
-
-        /* Inode bitmap not in group */
-        { PR_0_IB_NOT_GROUP, N_("@i @B for @g %g is not in @g.  (@b %b)\n"),
-          PROMPT_RELOCATE, PR_LATCH_RELOC }, 
-
-        /* Inode table not in group */
-        { PR_0_ITABLE_NOT_GROUP,
-          N_("@i table for @g %g is not in @g.  (@b %b)\n"
-          "WARNING: SEVERE DATA LOSS POSSIBLE.\n"),
-          PROMPT_RELOCATE, PR_LATCH_RELOC },
-
-        /* Superblock corrupt */
-        { PR_0_SB_CORRUPT,
-          N_("\nThe @S could not be read or does not describe a correct ext2\n"
-          "@f.  If the @v is valid and it really contains an ext2\n"
-          "@f (and not swap or ufs or something else), then the @S\n"
-          "is corrupt, and you might try running e2fsck with an alternate @S:\n"
-          "    e2fsck -b %S <@v>\n\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Filesystem size is wrong */
-        { PR_0_FS_SIZE_WRONG,
-          N_("The @f size (according to the @S) is %b @bs\n"
-          "The physical size of the @v is %c @bs\n"
-          "Either the @S or the partition table is likely to be corrupt!\n"),
-          PROMPT_ABORT, 0 },
-
-        /* Fragments not supported */             
-        { PR_0_NO_FRAGMENTS,
-          N_("@S @b_size = %b, fragsize = %c.\n"
-          "This version of e2fsck does not support fragment sizes different\n"
-          "from the @b size.\n"),
-          PROMPT_NONE, PR_FATAL },
-
-          /* Bad blocks_per_group */
-        { PR_0_BLOCKS_PER_GROUP,
-          N_("@S @bs_per_group = %b, should have been %c\n"),
-          PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT },
-
-        /* Bad first_data_block */
-        { PR_0_FIRST_DATA_BLOCK,
-          N_("@S first_data_@b = %b, should have been %c\n"),
-          PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT },
-        
-        /* Adding UUID to filesystem */
-        { PR_0_ADD_UUID,
-          N_("@f did not have a UUID; generating one.\n\n"),
-          PROMPT_NONE, 0 },
-
-        /* Relocate hint */
-        { PR_0_RELOCATE_HINT,
-          N_("Note: if there is several inode or block bitmap blocks\n"
-          "which require relocation, or one part of the inode table\n"
-          "which must be moved, you may wish to try running e2fsck\n"
-          "with the '-b %S' option first.  The problem may lie only\n"
-          "with the primary block group descriptor, and the backup\n"
-          "block group descriptor may be OK.\n\n"),
-          PROMPT_NONE, PR_PREEN_OK | PR_NOCOLLATE },
-
-        /* Miscellaneous superblock corruption */
-        { PR_0_MISC_CORRUPT_SUPER,
-          N_("Corruption found in @S.  (%s = %N).\n"),
-          PROMPT_NONE, PR_AFTER_CODE, PR_0_SB_CORRUPT },
-
-        /* Error determing physical device size of filesystem */
-        { PR_0_GETSIZE_ERROR,     
-          N_("Error determining size of the physical @v: %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Inode count in superblock is incorrect */
-        { PR_0_INODE_COUNT_WRONG,
-          N_("@i count in @S is %i, should be %j.\n"),
-          PROMPT_FIX, 0 },
-
-        { PR_0_HURD_CLEAR_FILETYPE,
-          N_("The Hurd does not support the filetype feature.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* Journal inode is invalid */
-        { PR_0_JOURNAL_BAD_INODE,
-          N_("@S has a bad ext3 @j (@i %i).\n"),
-          PROMPT_CLEAR, PR_PREEN_OK },
-
-        /* The external journal has (unsupported) multiple filesystems */
-        { PR_0_JOURNAL_UNSUPP_MULTIFS,
-          N_("External @j has multiple @f users (unsupported).\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Can't find external journal */
-        { PR_0_CANT_FIND_JOURNAL,
-          N_("Can't find external @j\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* External journal has bad superblock */
-        { PR_0_EXT_JOURNAL_BAD_SUPER,
-          N_("External @j has bad @S\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Superblock has a bad journal UUID */
-        { PR_0_JOURNAL_BAD_UUID,
-          N_("External @j does not support this @f\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Journal has an unknown superblock type */
-        { PR_0_JOURNAL_UNSUPP_SUPER,
-          N_("Ext3 @j @S is unknown type %N (unsupported).\n"
-             "It is likely that your copy of e2fsck is old and/or doesn't "
-             "support this @j format.\n"
-             "It is also possible the @j @S is corrupt.\n"),
-          PROMPT_ABORT, PR_NO_OK | PR_AFTER_CODE, PR_0_JOURNAL_BAD_SUPER },
-
-        /* Journal superblock is corrupt */
-        { PR_0_JOURNAL_BAD_SUPER,
-          N_("Ext3 @j @S is corrupt.\n"),
-          PROMPT_FIX, PR_PREEN_OK },
-
-        /* Superblock flag should be cleared */
-        { PR_0_JOURNAL_HAS_JOURNAL,
-          N_("@S doesn't have has_@j flag, but has ext3 @j %s.\n"),
-          PROMPT_CLEAR, PR_PREEN_OK },
-
-        /* Superblock flag is incorrect */
-        { PR_0_JOURNAL_RECOVER_SET,
-          N_("@S has ext3 needs_recovery flag set, but no @j.\n"),
-          PROMPT_CLEAR, PR_PREEN_OK },
-
-        /* Journal has data, but recovery flag is clear */
-        { PR_0_JOURNAL_RECOVERY_CLEAR,
-          N_("ext3 recovery flag clear, but @j has data.\n"),
-          PROMPT_NONE, 0 },
-
-        /* Ask if we should clear the journal */
-        { PR_0_JOURNAL_RESET_JOURNAL,
-          N_("Clear @j"),
-          PROMPT_NULL, PR_PREEN_NOMSG },
-
-        /* Ask if we should run the journal anyway */
-        { PR_0_JOURNAL_RUN,
-          N_("Run @j anyway"),
-          PROMPT_NULL, 0 },
-
-        /* Run the journal by default */
-        { PR_0_JOURNAL_RUN_DEFAULT,
-          N_("Recovery flag not set in backup @S, so running @j anyway.\n"),
-          PROMPT_NONE, 0 },
-
-        /* Clearing orphan inode */
-        { PR_0_ORPHAN_CLEAR_INODE,
-          N_("%s @o @i %i (uid=%Iu, gid=%Ig, mode=%Im, size=%Is)\n"),
-          PROMPT_NONE, 0 },
-
-        /* Illegal block found in orphaned inode */
-        { PR_0_ORPHAN_ILLEGAL_BLOCK_NUM,
-           N_("@I @b #%B (%b) found in @o @i %i.\n"),
-          PROMPT_NONE, 0 },
-                  
-        /* Already cleared block found in orphaned inode */
-        { PR_0_ORPHAN_ALREADY_CLEARED_BLOCK,
-           N_("Already cleared @b #%B (%b) found in @o @i %i.\n"),
-          PROMPT_NONE, 0 },
-  
-        /* Illegal orphan inode in superblock */
-        { PR_0_ORPHAN_ILLEGAL_HEAD_INODE,
-          N_("@I @o @i %i in @S.\n"),
-          PROMPT_NONE, 0 },
-
-        /* Illegal inode in orphaned inode list */
-        { PR_0_ORPHAN_ILLEGAL_INODE,
-          N_("@I @i %i in @o @i list.\n"),
-          PROMPT_NONE, 0 },
-
-        /* Filesystem revision is 0, but feature flags are set */
-        { PR_0_FS_REV_LEVEL,
-          "@f has feature flag(s) set, but is a revision 0 @f.  ",
-          PROMPT_FIX, PR_PREEN_OK | PR_NO_OK },
-
-        /* Journal superblock has an unknown read-only feature flag set */
-        { PR_0_JOURNAL_UNSUPP_ROCOMPAT,
-          N_("Ext3 @j @S has an unknown read-only feature flag set.\n"),
-          PROMPT_ABORT, 0 },
-
-        /* Journal superblock has an unknown incompatible feature flag set */
-        { PR_0_JOURNAL_UNSUPP_INCOMPAT,
-          N_("Ext3 @j @S has an unknown incompatible feature flag set.\n"),
-          PROMPT_ABORT, 0 },
-
-        /* Journal has unsupported version number */
-        { PR_0_JOURNAL_UNSUPP_VERSION,
-          N_("@j version not supported by this e2fsck.\n"),
-          PROMPT_ABORT, 0 },
-
-        /* Moving journal to hidden file */
-        { PR_0_MOVE_JOURNAL,
-          N_("Moving @j from /%s to hidden inode.\n\n"),
-          PROMPT_NONE, 0 },
-
-        /* Error moving journal to hidden file */
-        { PR_0_ERR_MOVE_JOURNAL,
-          N_("Error moving @j: %m\n\n"),
-          PROMPT_NONE, 0 },
-
-        /* Clearing V2 journal superblock */
-        { PR_0_CLEAR_V2_JOURNAL,
-          N_("Found invalid V2 @j @S fields (from V1 journal).\n"
-             "Clearing fields beyond the V1 @j @S...\n\n"),
-          PROMPT_NONE, 0 },
-
-        /* Backup journal inode blocks */
-        { PR_0_BACKUP_JNL,
-          N_("Backing up @j @i @b information.\n\n"),
-          PROMPT_NONE, 0 },
-
-        /* Reserved blocks w/o resize_inode */
-        { PR_0_NONZERO_RESERVED_GDT_BLOCKS,
-          N_("@f does not have resize_@i enabled, but s_reserved_gdt_@bs\n"
-             "is %N; @s zero.  "),
-          PROMPT_FIX, 0 },
-
-        /* Resize_inode not enabled, but resize inode is non-zero */
-        { PR_0_CLEAR_RESIZE_INODE,
-          N_("Resize_@i not enabled, but the resize inode is non-zero.  "),
-          PROMPT_CLEAR, 0 },
-
-        /* Resize inode invalid */
-        { PR_0_RESIZE_INODE_INVALID,
-          N_("Resize @i not valid.  "),
-          PROMPT_RECREATE, 0 },
-
-        /* Pass 1 errors */
-        
-        /* Pass 1: Checking inodes, blocks, and sizes */
-        { PR_1_PASS_HEADER,
-          N_("Pass 1: Checking @is, @bs, and sizes\n"),
-          PROMPT_NONE, 0 },
-                  
-        /* Root directory is not an inode */
-        { PR_1_ROOT_NO_DIR, N_("@r is not a @d.  "),
-          PROMPT_CLEAR, 0 }, 
-
-        /* Root directory has dtime set */
-        { PR_1_ROOT_DTIME,
-          N_("@r has dtime set (probably due to old mke2fs).  "),
-          PROMPT_FIX, PR_PREEN_OK },
-
-        /* Reserved inode has bad mode */
-        { PR_1_RESERVED_BAD_MODE,
-          N_("Reserved @i %i %Q has bad mode.  "),
-          PROMPT_CLEAR, PR_PREEN_OK },
-
-        /* Deleted inode has zero dtime */
-        { PR_1_ZERO_DTIME,
-          N_("@D @i %i has zero dtime.  "),
-          PROMPT_FIX, PR_PREEN_OK },
-
-        /* Inode in use, but dtime set */
-        { PR_1_SET_DTIME,
-          N_("@i %i is in use, but has dtime set.  "),
-          PROMPT_FIX, PR_PREEN_OK },
-
-        /* Zero-length directory */
-        { PR_1_ZERO_LENGTH_DIR,
-          N_("@i %i is a @z @d.  "),
-          PROMPT_CLEAR, PR_PREEN_OK },
-
-        /* Block bitmap conflicts with some other fs block */
-        { PR_1_BB_CONFLICT,
-          N_("@g %g's @b @B at %b @C.\n"),
-          PROMPT_RELOCATE, 0 },
-
-        /* Inode bitmap conflicts with some other fs block */
-        { PR_1_IB_CONFLICT,
-          N_("@g %g's @i @B at %b @C.\n"),
-          PROMPT_RELOCATE, 0 },
-
-        /* Inode table conflicts with some other fs block */
-        { PR_1_ITABLE_CONFLICT,
-          N_("@g %g's @i table at %b @C.\n"),
-          PROMPT_RELOCATE, 0 },
-
-        /* Block bitmap is on a bad block */
-        { PR_1_BB_BAD_BLOCK,
-          N_("@g %g's @b @B (%b) is bad.  "),
-          PROMPT_RELOCATE, 0 },
-
-        /* Inode bitmap is on a bad block */
-        { PR_1_IB_BAD_BLOCK,
-          N_("@g %g's @i @B (%b) is bad.  "),
-          PROMPT_RELOCATE, 0 },
-
-        /* Inode has incorrect i_size */
-        { PR_1_BAD_I_SIZE,
-          N_("@i %i, i_size is %Is, @s %N.  "),
-          PROMPT_FIX, PR_PREEN_OK },
-                  
-        /* Inode has incorrect i_blocks */
-        { PR_1_BAD_I_BLOCKS,
-          N_("@i %i, i_@bs is %Ib, @s %N.  "),
-          PROMPT_FIX, PR_PREEN_OK },
-
-        /* Illegal blocknumber in inode */
-        { PR_1_ILLEGAL_BLOCK_NUM,
-          N_("@I @b #%B (%b) in @i %i.  "),
-          PROMPT_CLEAR, PR_LATCH_BLOCK },
-
-        /* Block number overlaps fs metadata */
-        { PR_1_BLOCK_OVERLAPS_METADATA,
-          N_("@b #%B (%b) overlaps @f metadata in @i %i.  "),
-          PROMPT_CLEAR, PR_LATCH_BLOCK },
-
-        /* Inode has illegal blocks (latch question) */
-        { PR_1_INODE_BLOCK_LATCH,
-          N_("@i %i has illegal @b(s).  "),
-          PROMPT_CLEAR, 0 },
-
-        /* Too many bad blocks in inode */
-        { PR_1_TOO_MANY_BAD_BLOCKS,
-          N_("Too many illegal @bs in @i %i.\n"),
-          PROMPT_CLEAR_INODE, PR_NO_OK },       
-
-        /* Illegal block number in bad block inode */
-        { PR_1_BB_ILLEGAL_BLOCK_NUM,
-          N_("@I @b #%B (%b) in bad @b @i.  "),
-          PROMPT_CLEAR, PR_LATCH_BBLOCK },
-
-        /* Bad block inode has illegal blocks (latch question) */
-        { PR_1_INODE_BBLOCK_LATCH,
-          N_("Bad @b @i has illegal @b(s).  "),
-          PROMPT_CLEAR, 0 },
-
-        /* Duplicate or bad blocks in use! */
-        { PR_1_DUP_BLOCKS_PREENSTOP,
-          N_("Duplicate or bad @b in use!\n"),
-          PROMPT_NONE, 0 },
-
-        /* Bad block used as bad block indirect block */          
-        { PR_1_BBINODE_BAD_METABLOCK,
-          N_("Bad @b %b used as bad @b @i indirect @b.  "),
-          PROMPT_CLEAR, PR_LATCH_BBLOCK },
-
-        /* Inconsistency can't be fixed prompt */         
-        { PR_1_BBINODE_BAD_METABLOCK_PROMPT,
-          N_("\nThe bad @b @i has probably been corrupted.  You probably\n"
-             "should stop now and run ""e2fsck -c"" to scan for bad blocks\n"
-             "in the @f.\n"),
-          PROMPT_CONTINUE, PR_PREEN_NOMSG },
-
-        /* Bad primary block */
-        { PR_1_BAD_PRIMARY_BLOCK,  
-          N_("\nIf the @b is really bad, the @f can not be fixed.\n"),
-          PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK_PROMPT },
-                  
-        /* Bad primary block prompt */
-        { PR_1_BAD_PRIMARY_BLOCK_PROMPT,          
-          N_("You can clear the this @b (and hope for the best) from the\n"
-          "bad @b list and hope that @b is really OK, but there are no\n"
-          "guarantees.\n\n"),
-          PROMPT_CLEAR, PR_PREEN_NOMSG },
-
-        /* Bad primary superblock */
-        { PR_1_BAD_PRIMARY_SUPERBLOCK,
-          N_("The primary @S (%b) is on the bad @b list.\n"),
-          PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK },
-                  
-        /* Bad primary block group descriptors */
-        { PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR,
-          N_("Block %b in the primary @g descriptors "
-          "is on the bad @b list\n"),
-          PROMPT_NONE, PR_AFTER_CODE, PR_1_BAD_PRIMARY_BLOCK },
-                  
-        /* Bad superblock in group */
-        { PR_1_BAD_SUPERBLOCK,
-          N_("Warning: Group %g's @S (%b) is bad.\n"),
-          PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG },
-                  
-        /* Bad block group descriptors in group */
-        { PR_1_BAD_GROUP_DESCRIPTORS,
-          N_("Warning: Group %g's copy of the @g descriptors has a bad "
-          "@b (%b).\n"),
-          PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG },
-
-        /* Block claimed for no reason */         
-        { PR_1_PROGERR_CLAIMED_BLOCK,
-          N_("Programming error?  @b #%b claimed for no reason in "
-          "process_bad_@b.\n"),
-          PROMPT_NONE, PR_PREEN_OK },
-
-        /* Error allocating blocks for relocating metadata */
-        { PR_1_RELOC_BLOCK_ALLOCATE,
-          N_("@A %N contiguous @b(s) in @b @g %g for %s: %m\n"),
-          PROMPT_NONE, PR_PREEN_OK },
-                
-        /* Error allocating block buffer during relocation process */
-        { PR_1_RELOC_MEMORY_ALLOCATE,
-          N_("@A @b buffer for relocating %s\n"),
-          PROMPT_NONE, PR_PREEN_OK },
-                
-        /* Relocating metadata group information from X to Y */ 
-        { PR_1_RELOC_FROM_TO,
-          N_("Relocating @g %g's %s from %b to %c...\n"),
-          PROMPT_NONE, PR_PREEN_OK },
-                
-        /* Relocating metatdata group information to X */
-        { PR_1_RELOC_TO,
-          N_("Relocating @g %g's %s to %c...\n"), /* xgettext:no-c-format */
-          PROMPT_NONE, PR_PREEN_OK },
-                
-        /* Block read error during relocation process */
-        { PR_1_RELOC_READ_ERR,
-          N_("Warning: could not read @b %b of %s: %m\n"),
-          PROMPT_NONE, PR_PREEN_OK },
-                
-        /* Block write error during relocation process */
-        { PR_1_RELOC_WRITE_ERR,
-          N_("Warning: could not write @b %b for %s: %m\n"),
-          PROMPT_NONE, PR_PREEN_OK },
-
-        /* Error allocating inode bitmap */
-        { PR_1_ALLOCATE_IBITMAP_ERROR,
-          "@A @i @B (%N): %m\n",
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error allocating block bitmap */
-        { PR_1_ALLOCATE_BBITMAP_ERROR,
-          "@A @b @B (%N): %m\n",
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error allocating icount structure */
-        { PR_1_ALLOCATE_ICOUNT,
-          N_("@A icount link information: %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error allocating dbcount */
-        { PR_1_ALLOCATE_DBCOUNT,
-          N_("@A @d @b array: %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error while scanning inodes */
-        { PR_1_ISCAN_ERROR,
-          N_("Error while scanning @is (%i): %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error while iterating over blocks */
-        { PR_1_BLOCK_ITERATE,
-          N_("Error while iterating over @bs in @i %i: %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error while storing inode count information */         
-        { PR_1_ICOUNT_STORE,
-          N_("Error storing @i count information (@i=%i, count=%N): %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error while storing directory block information */     
-        { PR_1_ADD_DBLOCK,
-          N_("Error storing @d @b information "
-          "(@i=%i, @b=%b, num=%N): %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error while reading inode (for clearing) */    
-        { PR_1_READ_INODE,
-          N_("Error reading @i %i: %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Suppress messages prompt */
-        { PR_1_SUPPRESS_MESSAGES, "", PROMPT_SUPPRESS, PR_NO_OK },
-                  
-        /* Imagic flag set on an inode when filesystem doesn't support it */
-        { PR_1_SET_IMAGIC,
-          N_("@i %i has imagic flag set.  "),
-          PROMPT_CLEAR, 0 },
-
-        /* Immutable flag set on a device or socket inode */
-        { PR_1_SET_IMMUTABLE,
-          N_("Special (@v/socket/fifo/symlink) file (@i %i) has immutable\n"
-             "or append-only flag set.  "),
-          PROMPT_CLEAR, PR_PREEN_OK | PR_PREEN_NO | PR_NO_OK },
-
-        /* Compression flag set on an inode when filesystem doesn't support it */
-        { PR_1_COMPR_SET,
-          N_("@i %i has @cion flag set on @f without @cion support.  "),
-          PROMPT_CLEAR, 0 },
-
-        /* Non-zero size for device, fifo or socket inode */
-        { PR_1_SET_NONZSIZE,
-          "Special (@v/socket/fifo) @i %i has non-zero size.  ",
-          PROMPT_FIX, PR_PREEN_OK },
-
-        /* Filesystem revision is 0, but feature flags are set */
-        { PR_1_FS_REV_LEVEL,
-          "@f has feature flag(s) set, but is a revision 0 @f.  ",
-          PROMPT_FIX, PR_PREEN_OK | PR_NO_OK },
-
-        /* Journal inode is not in use, but contains data */      
-        { PR_1_JOURNAL_INODE_NOT_CLEAR,
-          "@j @i is not in use, but contains data.  ",
-          PROMPT_CLEAR, PR_PREEN_OK },    
-          
-        /* Journal has bad mode */
-        { PR_1_JOURNAL_BAD_MODE,
-          N_("@j is not regular file.  "),
-          PROMPT_FIX, PR_PREEN_OK },
-
-        /* Deal with inodes that were part of orphan linked list */
-        { PR_1_LOW_DTIME,
-          N_("@i %i was part of the orphaned @i list.  "),
-          PROMPT_FIX, PR_LATCH_LOW_DTIME, 0 },    
-
-        /* Deal with inodes that were part of corrupted orphan linked
-           list (latch question) */
-        { PR_1_ORPHAN_LIST_REFUGEES,
-          N_("@is that were part of a corrupted orphan linked list found.  "),
-          PROMPT_FIX, 0 },                
-                  
-        /* Error allocating refcount structure */
-        { PR_1_ALLOCATE_REFCOUNT,
-          "@A refcount structure (%N): %m\n",
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error reading extended attribute block */
-        { PR_1_READ_EA_BLOCK,
-          N_("Error reading @a @b %b for @i %i.  "),
-          PROMPT_CLEAR, 0 },
-
-        /* Invalid extended attribute block */
-        { PR_1_BAD_EA_BLOCK,
-          N_("@i %i has a bad @a @b %b.  "),
-          PROMPT_CLEAR, 0 },
-
-        /* Error reading Extended Attribute block while fixing refcount */
-        { PR_1_EXTATTR_READ_ABORT,
-          N_("Error reading @a @b %b (%m).  "),
-          PROMPT_ABORT, 0 },
-                  
-        /* Extended attribute reference count incorrect */
-        { PR_1_EXTATTR_REFCOUNT,
-          N_("@a @b %b has reference count %B, should be %N.  "),
-          PROMPT_FIX, 0 },
-                  
-        /* Error writing Extended Attribute block while fixing refcount */ 
-        { PR_1_EXTATTR_WRITE,
-          N_("Error writing @a @b %b (%m).  "),
-          PROMPT_ABORT, 0 },
-
-        /* Multiple EA blocks not supported */
-        { PR_1_EA_MULTI_BLOCK,
-          N_("@a @b %b has h_blocks > 1.  "),
-          PROMPT_CLEAR, 0},       
-
-        /* Error allocating EA region allocation structure */
-        { PR_1_EA_ALLOC_REGION,
-          N_("Error allocating @a @b %b.  "),
-          PROMPT_ABORT, 0},
-        
-        /* Error EA allocation collision */
-        { PR_1_EA_ALLOC_COLLISION,
-          N_("@a @b %b is corrupt (allocation collision).  "),
-          PROMPT_CLEAR, 0},
-        
-        /* Bad extended attribute name */
-        { PR_1_EA_BAD_NAME,
-          N_("@a @b %b is corrupt (invalid name).  "),
-          PROMPT_CLEAR, 0},       
-
-        /* Bad extended attribute value */
-        { PR_1_EA_BAD_VALUE,
-          N_("@a @b %b is corrupt (invalid value).  "),
-          PROMPT_CLEAR, 0},
-
-        /* Inode too big (latch question) */
-        { PR_1_INODE_TOOBIG,
-          N_("@i %i is too big.  "), PROMPT_TRUNCATE, 0 },
-
-        /* Directory too big */
-        { PR_1_TOOBIG_DIR, 
-          N_("@b #%B (%b) causes @d to be too big.  "),
-          PROMPT_CLEAR, PR_LATCH_TOOBIG },
-
-        /* Regular file too big */
-        { PR_1_TOOBIG_REG,
-          N_("@b #%B (%b) causes file to be too big.  "),
-          PROMPT_CLEAR, PR_LATCH_TOOBIG },
-
-        /* Symlink too big */
-        { PR_1_TOOBIG_SYMLINK,
-          N_("@b #%B (%b) causes symlink to be too big.  "),
-          PROMPT_CLEAR, PR_LATCH_TOOBIG },
-
-        /* INDEX_FL flag set on a non-HTREE filesystem */
-        { PR_1_HTREE_SET,
-          N_("@i %i has INDEX_FL flag set on @f without htree support.\n"),
-          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
-
-        /* INDEX_FL flag set on a non-directory */      
-        { PR_1_HTREE_NODIR,
-          N_("@i %i has INDEX_FL flag set but is not a @d.\n"),
-          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
-
-        /* Invalid root node in HTREE directory */      
-        { PR_1_HTREE_BADROOT,
-          N_("@h %i has an invalid root node.\n"),
-          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
-
-        /* Unsupported hash version in HTREE directory */       
-        { PR_1_HTREE_HASHV,
-          N_("@h %i has an unsupported hash version (%N)\n"),
-          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
-
-        /* Incompatible flag in HTREE root node */      
-        { PR_1_HTREE_INCOMPAT,
-          N_("@h %i uses an incompatible htree root node flag.\n"),
-          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
-
-        /* HTREE too deep */    
-        { PR_1_HTREE_DEPTH,
-          N_("@h %i has a tree depth (%N) which is too big\n"),
-          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
-                  
-        /* Bad block has indirect block that conflicts with filesystem block */
-        { PR_1_BB_FS_BLOCK,
-          N_("Bad @b @i has an indirect @b (%b) that conflicts with\n"
-             "@f metadata.  "),
-          PROMPT_CLEAR, PR_LATCH_BBLOCK },
-
-        /* Resize inode failed */
-        { PR_1_RESIZE_INODE_CREATE,
-          N_("Resize @i (re)creation failed: %m."),
-          PROMPT_ABORT, 0 },
-
-        /* invalid inode->i_extra_isize */      
-        { PR_1_EXTRA_ISIZE,
-          N_("@i %i has a extra size (%IS) which is invalid\n"),
-          PROMPT_FIX, PR_PREEN_OK },
-
-        /* invalid ea entry->e_name_len */      
-        { PR_1_ATTR_NAME_LEN,
-          N_("@a in @i %i has a namelen (%N) which is invalid\n"),
-          PROMPT_CLEAR, PR_PREEN_OK },
-
-        /* invalid ea entry->e_value_size */    
-        { PR_1_ATTR_VALUE_SIZE,
-          N_("@a in @i %i has a value size (%N) which is invalid\n"),
-          PROMPT_CLEAR, PR_PREEN_OK },
-
-        /* invalid ea entry->e_value_offs */    
-        { PR_1_ATTR_VALUE_OFFSET,
-          N_("@a in @i %i has a value offset (%N) which is invalid\n"),
-          PROMPT_CLEAR, PR_PREEN_OK },
-
-        /* invalid ea entry->e_value_block */   
-        { PR_1_ATTR_VALUE_BLOCK,
-          N_("@a in @i %i has a value block (%N) which is invalid (must be 0)\n"),
-          PROMPT_CLEAR, PR_PREEN_OK },
-
-        /* invalid ea entry->e_hash */  
-        { PR_1_ATTR_HASH,
-          N_("@a in @i %i has a hash (%N) which is invalid (must be 0)\n"),
-          PROMPT_CLEAR, PR_PREEN_OK },
-
-        /* Pass 1b errors */
-
-        /* Pass 1B: Rescan for duplicate/bad blocks */
-        { PR_1B_PASS_HEADER,
-          N_("Duplicate @bs found... invoking duplicate @b passes.\n"
-          "Pass 1B: Rescan for duplicate/bad @bs\n"),
-          PROMPT_NONE, 0 },
-
-        /* Duplicate/bad block(s) header */
-        { PR_1B_DUP_BLOCK_HEADER,         
-          N_("Duplicate/bad @b(s) in @i %i:"),
-          PROMPT_NONE, 0 },
-
-        /* Duplicate/bad block(s) in inode */
-        { PR_1B_DUP_BLOCK,        
-          " %b",
-          PROMPT_NONE, PR_LATCH_DBLOCK | PR_PREEN_NOHDR },
-
-        /* Duplicate/bad block(s) end */
-        { PR_1B_DUP_BLOCK_END,
-          "\n",
-          PROMPT_NONE, PR_PREEN_NOHDR },
-                  
-        /* Error while scanning inodes */
-        { PR_1B_ISCAN_ERROR,
-          N_("Error while scanning inodes (%i): %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error allocating inode bitmap */
-        { PR_1B_ALLOCATE_IBITMAP_ERROR,
-          N_("@A @i @B (inode_dup_map): %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error while iterating over blocks */
-        { PR_1B_BLOCK_ITERATE,
-          N_("Error while iterating over @bs in @i %i (%s): %m\n"),
-          PROMPT_NONE, 0 },
-
-        /* Error adjusting EA refcount */
-        { PR_1B_ADJ_EA_REFCOUNT,
-          N_("Error addjusting refcount for @a @b %b (@i %i): %m\n"),
-          PROMPT_NONE, 0 },
-
-
-        /* Pass 1C: Scan directories for inodes with dup blocks. */
-        { PR_1C_PASS_HEADER,
-          N_("Pass 1C: Scan directories for @is with dup @bs.\n"),
-          PROMPT_NONE, 0 },
-
-                  
-        /* Pass 1D: Reconciling duplicate blocks */
-        { PR_1D_PASS_HEADER,
-          N_("Pass 1D: Reconciling duplicate @bs\n"),
-          PROMPT_NONE, 0 },
-                  
-        /* File has duplicate blocks */
-        { PR_1D_DUP_FILE,
-          N_("File %Q (@i #%i, mod time %IM) \n"
-          "  has %B duplicate @b(s), shared with %N file(s):\n"),
-          PROMPT_NONE, 0 },
-                  
-        /* List of files sharing duplicate blocks */    
-        { PR_1D_DUP_FILE_LIST,
-          N_("\t%Q (@i #%i, mod time %IM)\n"),
-          PROMPT_NONE, 0 },
-          
-        /* File sharing blocks with filesystem metadata  */     
-        { PR_1D_SHARE_METADATA,
-          N_("\t<@f metadata>\n"),
-          PROMPT_NONE, 0 },
-
-        /* Report of how many duplicate/bad inodes */   
-        { PR_1D_NUM_DUP_INODES,
-          N_("(There are %N @is containing duplicate/bad @bs.)\n\n"),
-          PROMPT_NONE, 0 },
-
-        /* Duplicated blocks already reassigned or cloned. */
-        { PR_1D_DUP_BLOCKS_DEALT,
-          N_("Duplicated @bs already reassigned or cloned.\n\n"),
-          PROMPT_NONE, 0 },
-
-        /* Clone duplicate/bad blocks? */
-        { PR_1D_CLONE_QUESTION,
-          "", PROMPT_CLONE, PR_NO_OK },
-                  
-        /* Delete file? */
-        { PR_1D_DELETE_QUESTION,
-          "", PROMPT_DELETE, 0 },
-
-        /* Couldn't clone file (error) */
-        { PR_1D_CLONE_ERROR,
-          N_("Couldn't clone file: %m\n"), PROMPT_NONE, 0 },
-
-        /* Pass 2 errors */
-
-        /* Pass 2: Checking directory structure */
-        { PR_2_PASS_HEADER,
-          N_("Pass 2: Checking @d structure\n"),
-          PROMPT_NONE, 0 },
-                  
-        /* Bad inode number for '.' */
-        { PR_2_BAD_INODE_DOT,
-          N_("Bad @i number for '.' in @d @i %i.\n"),
-          PROMPT_FIX, 0 },
-
-        /* Directory entry has bad inode number */
-        { PR_2_BAD_INO, 
-          N_("@E has bad @i #: %Di.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* Directory entry has deleted or unused inode */
-        { PR_2_UNUSED_INODE, 
-          N_("@E has @D/unused @i %Di.  "),
-          PROMPT_CLEAR, PR_PREEN_OK },
-
-        /* Directry entry is link to '.' */
-        { PR_2_LINK_DOT, 
-          N_("@E @L to '.'  "),
-          PROMPT_CLEAR, 0 },
-
-        /* Directory entry points to inode now located in a bad block */
-        { PR_2_BB_INODE,
-          N_("@E points to @i (%Di) located in a bad @b.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* Directory entry contains a link to a directory */
-        { PR_2_LINK_DIR, 
-          N_("@E @L to @d %P (%Di).\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* Directory entry contains a link to the root directry */
-        { PR_2_LINK_ROOT, 
-          N_("@E @L to the @r.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* Directory entry has illegal characters in its name */
-        { PR_2_BAD_NAME, 
-          N_("@E has illegal characters in its name.\n"),
-          PROMPT_FIX, 0 },
-
-        /* Missing '.' in directory inode */      
-        { PR_2_MISSING_DOT,
-          N_("Missing '.' in @d @i %i.\n"),
-          PROMPT_FIX, 0 },
-
-        /* Missing '..' in directory inode */     
-        { PR_2_MISSING_DOT_DOT,
-          N_("Missing '..' in @d @i %i.\n"),
-          PROMPT_FIX, 0 },
-
-        /* First entry in directory inode doesn't contain '.' */
-        { PR_2_1ST_NOT_DOT,
-          N_("First @e '%Dn' (inode=%Di) in @d @i %i (%p) @s '.'\n"),
-          PROMPT_FIX, 0 },
-
-        /* Second entry in directory inode doesn't contain '..' */
-        { PR_2_2ND_NOT_DOT_DOT,
-          N_("Second @e '%Dn' (inode=%Di) in @d @i %i @s '..'\n"),
-          PROMPT_FIX, 0 },
-                  
-        /* i_faddr should be zero */
-        { PR_2_FADDR_ZERO,
-          N_("i_faddr @F %IF, @s zero.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* i_file_acl should be zero */
-        { PR_2_FILE_ACL_ZERO,
-          N_("i_file_acl @F %If, @s zero.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* i_dir_acl should be zero */
-        { PR_2_DIR_ACL_ZERO,
-          N_("i_dir_acl @F %Id, @s zero.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* i_frag should be zero */
-        { PR_2_FRAG_ZERO,
-          N_("i_frag @F %N, @s zero.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* i_fsize should be zero */
-        { PR_2_FSIZE_ZERO,
-          N_("i_fsize @F %N, @s zero.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* inode has bad mode */
-        { PR_2_BAD_MODE,
-          N_("@i %i (%Q) has a bad mode (%Im).\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* directory corrupted */
-        { PR_2_DIR_CORRUPTED,     
-          N_("@d @i %i, @b %B, offset %N: @d corrupted\n"),
-          PROMPT_SALVAGE, 0 },
-                  
-        /* filename too long */
-        { PR_2_FILENAME_LONG,     
-          N_("@d @i %i, @b %B, offset %N: filename too long\n"),
-          PROMPT_TRUNCATE, 0 },
-
-        /* Directory inode has a missing block (hole) */
-        { PR_2_DIRECTORY_HOLE,    
-          N_("@d @i %i has an unallocated @b #%B.  "),
-          PROMPT_ALLOCATE, 0 },
-
-        /* '.' is not NULL terminated */
-        { PR_2_DOT_NULL_TERM,
-          N_("'.' @d @e in @d @i %i is not NULL terminated\n"),
-          PROMPT_FIX, 0 },
-
-        /* '..' is not NULL terminated */
-        { PR_2_DOT_DOT_NULL_TERM,
-          N_("'..' @d @e in @d @i %i is not NULL terminated\n"),
-          PROMPT_FIX, 0 },
-
-        /* Illegal character device inode */
-        { PR_2_BAD_CHAR_DEV,
-          N_("@i %i (%Q) is an @I character @v.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* Illegal block device inode */
-        { PR_2_BAD_BLOCK_DEV,
-          N_("@i %i (%Q) is an @I @b @v.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* Duplicate '.' entry */
-        { PR_2_DUP_DOT,
-          N_("@E is duplicate '.' @e.\n"),
-          PROMPT_FIX, 0 },        
-
-        /* Duplicate '..' entry */
-        { PR_2_DUP_DOT_DOT,
-          N_("@E is duplicate '..' @e.\n"),
-          PROMPT_FIX, 0 },
-
-        /* Internal error: couldn't find dir_info */
-        { PR_2_NO_DIRINFO,
-          N_("Internal error: couldn't find dir_info for %i.\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Final rec_len is wrong */
-        { PR_2_FINAL_RECLEN,
-          N_("@E has rec_len of %Dr, should be %N.\n"),
-          PROMPT_FIX, 0 },
-                  
-        /* Error allocating icount structure */
-        { PR_2_ALLOCATE_ICOUNT,
-          N_("@A icount structure: %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error iterating over directory blocks */
-        { PR_2_DBLIST_ITERATE,
-          N_("Error iterating over @d @bs: %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error reading directory block */
-        { PR_2_READ_DIRBLOCK,
-          N_("Error reading @d @b %b (@i %i): %m\n"),
-          PROMPT_CONTINUE, 0 },
-
-        /* Error writing directory block */
-        { PR_2_WRITE_DIRBLOCK,
-          N_("Error writing @d @b %b (@i %i): %m\n"),
-          PROMPT_CONTINUE, 0 },
-
-        /* Error allocating new directory block */
-        { PR_2_ALLOC_DIRBOCK,
-          N_("@A new @d @b for @i %i (%s): %m\n"),
-          PROMPT_NONE, 0 },
-
-        /* Error deallocating inode */
-        { PR_2_DEALLOC_INODE,
-          N_("Error deallocating @i %i: %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Directory entry for '.' is big.  Split? */
-        { PR_2_SPLIT_DOT,
-          N_("@d @e for '.' is big.  "),
-          PROMPT_SPLIT, PR_NO_OK },
-
-        /* Illegal FIFO inode */
-        { PR_2_BAD_FIFO,
-          N_("@i %i (%Q) is an @I FIFO.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* Illegal socket inode */
-        { PR_2_BAD_SOCKET,
-          N_("@i %i (%Q) is an @I socket.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* Directory filetype not set */
-        { PR_2_SET_FILETYPE,
-          N_("Setting filetype for @E to %N.\n"),
-          PROMPT_NONE, PR_PREEN_OK | PR_NO_OK | PR_NO_NOMSG },
-
-        /* Directory filetype incorrect */
-        { PR_2_BAD_FILETYPE,
-          N_("@E has an incorrect filetype (was %Dt, should be %N).\n"),
-          PROMPT_FIX, 0 },
-
-        /* Directory filetype set on filesystem */
-        { PR_2_CLEAR_FILETYPE,
-          N_("@E has filetype set.\n"),
-          PROMPT_CLEAR, PR_PREEN_OK },
-
-        /* Directory filename is null */
-        { PR_2_NULL_NAME,
-          N_("@E has a zero-length name.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* Invalid symlink */
-        { PR_2_INVALID_SYMLINK,
-          N_("Symlink %Q (@i #%i) is invalid.\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* i_file_acl (extended attribute block) is bad */
-        { PR_2_FILE_ACL_BAD,
-          N_("@a @b @F invalid (%If).\n"),
-          PROMPT_CLEAR, 0 },
-
-        /* Filesystem contains large files, but has no such flag in sb */
-        { PR_2_FEATURE_LARGE_FILES,
-          N_("@f contains large files, but lacks LARGE_FILE flag in @S.\n"),
-          PROMPT_FIX, 0 },
-          
-        /* Node in HTREE directory not referenced */
-        { PR_2_HTREE_NOTREF,
-          N_("@p @h %d: node (%B) not referenced\n"),
-          PROMPT_NONE, 0 },
-
-        /* Node in HTREE directory referenced twice */
-        { PR_2_HTREE_DUPREF,
-          N_("@p @h %d: node (%B) referenced twice\n"),
-          PROMPT_NONE, 0 },
-
-        /* Node in HTREE directory has bad min hash */
-        { PR_2_HTREE_MIN_HASH,
-          N_("@p @h %d: node (%B) has bad min hash\n"),
-          PROMPT_NONE, 0 },
-
-        /* Node in HTREE directory has bad max hash */
-        { PR_2_HTREE_MAX_HASH,
-          N_("@p @h %d: node (%B) has bad max hash\n"),
-          PROMPT_NONE, 0 },
-
-        /* Clear invalid HTREE directory */
-        { PR_2_HTREE_CLEAR,
-          N_("Invalid @h %d (%q).  "), PROMPT_CLEAR, 0 },
-                  
-        /* Bad block in htree interior node */
-        { PR_2_HTREE_BADBLK,
-          N_("@p @h %d (%q): bad @b number %b.\n"),
-          PROMPT_CLEAR_HTREE, 0 },
-
-        /* Error adjusting EA refcount */
-        { PR_2_ADJ_EA_REFCOUNT,
-          N_("Error addjusting refcount for @a @b %b (@i %i): %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Invalid HTREE root node */
-        { PR_2_HTREE_BAD_ROOT,
-          N_("@p @h %d: root node is invalid\n"),
-          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
-
-        /* Invalid HTREE limit */
-        { PR_2_HTREE_BAD_LIMIT,
-          N_("@p @h %d: node (%B) has bad limit (%N)\n"),
-          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
-
-        /* Invalid HTREE count */
-        { PR_2_HTREE_BAD_COUNT,
-          N_("@p @h %d: node (%B) has bad count (%N)\n"),
-          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
-
-        /* HTREE interior node has out-of-order hashes in table */
-        { PR_2_HTREE_HASH_ORDER,
-          N_("@p @h %d: node (%B) has an unordered hash table\n"),
-          PROMPT_CLEAR_HTREE, PR_PREEN_OK },
-
-        /* Node in HTREE directory has bad depth */
-        { PR_2_HTREE_BAD_DEPTH,
-          N_("@p @h %d: node (%B) has bad depth\n"),
-          PROMPT_NONE, 0 },
-        
-        /* Duplicate directory entry found */
-        { PR_2_DUPLICATE_DIRENT,
-          N_("Duplicate @E found.  "),
-          PROMPT_CLEAR, 0 },
-        
-        /* Non-unique filename found */
-        { PR_2_NON_UNIQUE_FILE, /* xgettext: no-c-format */
-          N_("@E has a non-unique filename.\nRename to %s"),
-          PROMPT_NULL, 0 },
-        
-        /* Duplicate directory entry found */
-        { PR_2_REPORT_DUP_DIRENT,
-          N_("Duplicate @e '%Dn' found.\n\tMarking %p (%i) to be rebuilt.\n\n"),
-          PROMPT_NONE, 0 },
-        
-        /* Pass 3 errors */
-
-        /* Pass 3: Checking directory connectivity */
-        { PR_3_PASS_HEADER,
-          N_("Pass 3: Checking @d connectivity\n"),
-          PROMPT_NONE, 0 },
-                  
-        /* Root inode not allocated */
-        { PR_3_NO_ROOT_INODE,
-          N_("@r not allocated.  "),
-          PROMPT_ALLOCATE, 0 }, 
-                  
-        /* No room in lost+found */
-        { PR_3_EXPAND_LF_DIR,
-          N_("No room in @l @d.  "),
-          PROMPT_EXPAND, 0 },
-
-        /* Unconnected directory inode */
-        { PR_3_UNCONNECTED_DIR,
-          N_("Unconnected @d @i %i (%p)\n"),
-          PROMPT_CONNECT, 0 },
-
-        /* /lost+found not found */
-        { PR_3_NO_LF_DIR,
-          N_("/@l not found.  "),
-          PROMPT_CREATE, PR_PREEN_OK },
-
-        /* .. entry is incorrect */
-        { PR_3_BAD_DOT_DOT,
-          N_("'..' in %Q (%i) is %P (%j), @s %q (%d).\n"),
-          PROMPT_FIX, 0 },
-
-        /* Bad or non-existent /lost+found.  Cannot reconnect */
-        { PR_3_NO_LPF,
-          N_("Bad or non-existent /@l.  Cannot reconnect.\n"),
-          PROMPT_NONE, 0 },
-
-        /* Could not expand /lost+found */
-        { PR_3_CANT_EXPAND_LPF,
-          N_("Could not expand /@l: %m\n"),
-          PROMPT_NONE, 0 },
-
-        /* Could not reconnect inode */
-        { PR_3_CANT_RECONNECT,
-          N_("Could not reconnect %i: %m\n"),
-          PROMPT_NONE, 0 },
-
-        /* Error while trying to find /lost+found */
-        { PR_3_ERR_FIND_LPF,
-          N_("Error while trying to find /@l: %m\n"),
-          PROMPT_NONE, 0 },
-
-        /* Error in ext2fs_new_block while creating /lost+found */
-        { PR_3_ERR_LPF_NEW_BLOCK, 
-          N_("ext2fs_new_@b: %m while trying to create /@l @d\n"),
-          PROMPT_NONE, 0 },
-                  
-        /* Error in ext2fs_new_inode while creating /lost+found */
-        { PR_3_ERR_LPF_NEW_INODE,
-          N_("ext2fs_new_@i: %m while trying to create /@l @d\n"),
-          PROMPT_NONE, 0 },
-
-        /* Error in ext2fs_new_dir_block while creating /lost+found */    
-        { PR_3_ERR_LPF_NEW_DIR_BLOCK,
-          N_("ext2fs_new_dir_@b: %m while creating new @d @b\n"),
-          PROMPT_NONE, 0 },
-                  
-        /* Error while writing directory block for /lost+found */
-        { PR_3_ERR_LPF_WRITE_BLOCK,
-          N_("ext2fs_write_dir_@b: %m while writing the @d @b for /@l\n"),
-          PROMPT_NONE, 0 },
-
-        /* Error while adjusting inode count */
-        { PR_3_ADJUST_INODE,
-          N_("Error while adjusting @i count on @i %i\n"),
-          PROMPT_NONE, 0 },
-
-        /* Couldn't fix parent directory -- error */
-        { PR_3_FIX_PARENT_ERR,
-          N_("Couldn't fix parent of @i %i: %m\n\n"),
-          PROMPT_NONE, 0 },
-
-        /* Couldn't fix parent directory -- couldn't find it */   
-        { PR_3_FIX_PARENT_NOFIND,
-          N_("Couldn't fix parent of @i %i: Couldn't find parent @d entry\n\n"),
-          PROMPT_NONE, 0 },
-
-        /* Error allocating inode bitmap */
-        { PR_3_ALLOCATE_IBITMAP_ERROR,
-          N_("@A @i @B (%N): %m\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error creating root directory */
-        { PR_3_CREATE_ROOT_ERROR,
-          N_("Error creating root @d (%s): %m\n"),
-          PROMPT_NONE, PR_FATAL },        
-
-        /* Error creating lost and found directory */
-        { PR_3_CREATE_LPF_ERROR,
-          N_("Error creating /@l @d (%s): %m\n"),
-          PROMPT_NONE, PR_FATAL },  
-
-        /* Root inode is not directory; aborting */
-        { PR_3_ROOT_NOT_DIR_ABORT,
-          N_("@r is not a @d; aborting.\n"),
-          PROMPT_NONE, PR_FATAL },  
-
-        /* Cannot proceed without a root inode. */
-        { PR_3_NO_ROOT_INODE_ABORT,
-          N_("Cannot proceed without a @r.\n"),
-          PROMPT_NONE, PR_FATAL },  
-
-        /* Internal error: couldn't find dir_info */
-        { PR_3_NO_DIRINFO,
-          N_("Internal error: couldn't find dir_info for %i.\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Lost+found not a directory */
-        { PR_3_LPF_NOTDIR,
-          N_("/@l is not a @d (ino=%i)\n"),
-          PROMPT_UNLINK, 0 },
-
-        /* Pass 3A Directory Optimization       */
-
-        /* Pass 3A: Optimizing directories */
-        { PR_3A_PASS_HEADER,
-          N_("Pass 3A: Optimizing directories\n"),
-          PROMPT_NONE, PR_PREEN_NOMSG },
-
-        /* Error iterating over directories */
-        { PR_3A_OPTIMIZE_ITER,
-          N_("Failed to create dirs_to_hash iterator: %m"),
-          PROMPT_NONE, 0 },
-
-        /* Error rehash directory */
-        { PR_3A_OPTIMIZE_DIR_ERR,
-          N_("Failed to optimize directory %q (%d): %m"),
-          PROMPT_NONE, 0 },
-
-        /* Rehashing dir header */
-        { PR_3A_OPTIMIZE_DIR_HEADER,
-          N_("Optimizing directories: "),
-          PROMPT_NONE, PR_MSG_ONLY },
-
-        /* Rehashing directory %d */
-        { PR_3A_OPTIMIZE_DIR,
-          " %d",
-          PROMPT_NONE, PR_LATCH_OPTIMIZE_DIR | PR_PREEN_NOHDR},
-                  
-        /* Rehashing dir end */   
-        { PR_3A_OPTIMIZE_DIR_END,
-          "\n",
-          PROMPT_NONE, PR_PREEN_NOHDR },
-
-        /* Pass 4 errors */
-        
-        /* Pass 4: Checking reference counts */
-        { PR_4_PASS_HEADER,
-          N_("Pass 4: Checking reference counts\n"),
-          PROMPT_NONE, 0 },
-                  
-        /* Unattached zero-length inode */
-        { PR_4_ZERO_LEN_INODE,
-          "@u @z @i %i.  ",
-          PROMPT_CLEAR, PR_PREEN_OK|PR_NO_OK },
-
-        /* Unattached inode */
-        { PR_4_UNATTACHED_INODE,
-          "@u @i %i\n",
-          PROMPT_CONNECT, 0 },
-
-        /* Inode ref count wrong */
-        { PR_4_BAD_REF_COUNT,
-          N_("@i %i ref count is %Il, @s %N.  "),
-          PROMPT_FIX, PR_PREEN_OK },
-
-        { PR_4_INCONSISTENT_COUNT,
-          N_("WARNING: PROGRAMMING BUG IN E2FSCK!\n"
-          "\tOR SOME BONEHEAD (YOU) IS CHECKING A MOUNTED (LIVE) FILESYSTEM.\n"
-          "@i_link_info[%i] is %N, @i.i_links_count is %Il.  "
-          "They should be the same!\n"),
-          PROMPT_NONE, 0 },
-
-        /* Pass 5 errors */
-                  
-        /* Pass 5: Checking group summary information */
-        { PR_5_PASS_HEADER,
-          N_("Pass 5: Checking @g summary information\n"),
-          PROMPT_NONE, 0 },
-                  
-        /* Padding at end of inode bitmap is not set. */
-        { PR_5_INODE_BMAP_PADDING,
-          N_("Padding at end of @i @B is not set. "),
-          PROMPT_FIX, PR_PREEN_OK },
-                  
-        /* Padding at end of block bitmap is not set. */
-        { PR_5_BLOCK_BMAP_PADDING,
-          N_("Padding at end of @b @B is not set. "),
-          PROMPT_FIX, PR_PREEN_OK },
-                
-        /* Block bitmap differences header */
-        { PR_5_BLOCK_BITMAP_HEADER,
-          N_("@b @B differences: "),
-          PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG},
-
-        /* Block not used, but marked in bitmap */
-        { PR_5_BLOCK_UNUSED,
-          " -%b",
-          PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
-                  
-        /* Block used, but not marked used in bitmap */
-        { PR_5_BLOCK_USED,
-          " +%b",
-          PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
-
-        /* Block bitmap differences end */        
-        { PR_5_BLOCK_BITMAP_END,
-          "\n",
-          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
-
-        /* Inode bitmap differences header */
-        { PR_5_INODE_BITMAP_HEADER,
-          N_("@i @B differences: "),
-          PROMPT_NONE, PR_PREEN_OK | PR_PREEN_NOMSG },
-
-        /* Inode not used, but marked in bitmap */
-        { PR_5_INODE_UNUSED,
-          " -%i",
-          PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
-                  
-        /* Inode used, but not marked used in bitmap */
-        { PR_5_INODE_USED,
-          " +%i",
-          PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
-
-        /* Inode bitmap differences end */        
-        { PR_5_INODE_BITMAP_END,
-          "\n",
-          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
-
-        /* Free inodes count for group wrong */
-        { PR_5_FREE_INODE_COUNT_GROUP,
-          N_("Free @is count wrong for @g #%g (%i, counted=%j).\n"),
-          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
-
-        /* Directories count for group wrong */
-        { PR_5_FREE_DIR_COUNT_GROUP,
-          N_("Directories count wrong for @g #%g (%i, counted=%j).\n"),
-          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
-
-        /* Free inodes count wrong */
-        { PR_5_FREE_INODE_COUNT,
-          N_("Free @is count wrong (%i, counted=%j).\n"),
-          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
-
-        /* Free blocks count for group wrong */
-        { PR_5_FREE_BLOCK_COUNT_GROUP,
-          N_("Free @bs count wrong for @g #%g (%b, counted=%c).\n"),
-          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
-
-        /* Free blocks count wrong */
-        { PR_5_FREE_BLOCK_COUNT,
-          N_("Free @bs count wrong (%b, counted=%c).\n"),
-          PROMPT_FIX, PR_PREEN_OK | PR_PREEN_NOMSG },
-
-        /* Programming error: bitmap endpoints don't match */
-        { PR_5_BMAP_ENDPOINTS,
-          N_("PROGRAMMING ERROR: @f (#%N) @B endpoints (%b, %c) don't "
-          "match calculated @B endpoints (%i, %j)\n"),
-          PROMPT_NONE, PR_FATAL },
-
-        /* Internal error: fudging end of bitmap */
-        { PR_5_FUDGE_BITMAP_ERROR,
-          N_("Internal error: fudging end of bitmap (%N)\n"),
-          PROMPT_NONE, PR_FATAL },        
-
-        /* Error copying in replacement inode bitmap */
-        { PR_5_COPY_IBITMAP_ERROR,
-          "Error copying in replacement @i @B: %m\n",
-          PROMPT_NONE, PR_FATAL },
-
-        /* Error copying in replacement block bitmap */
-        { PR_5_COPY_BBITMAP_ERROR,
-          "Error copying in replacement @b @B: %m\n",
-          PROMPT_NONE, PR_FATAL },
-                  
-        /* Block range not used, but marked in bitmap */
-        { PR_5_BLOCK_RANGE_UNUSED,
-          " -(%b--%c)",
-          PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
-                  
-        /* Block range used, but not marked used in bitmap */
-        { PR_5_BLOCK_RANGE_USED,
-          " +(%b--%c)",
-          PROMPT_NONE, PR_LATCH_BBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
-
-        /* Inode range not used, but marked in bitmap */
-        { PR_5_INODE_RANGE_UNUSED,
-          " -(%i--%j)",
-          PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
-                  
-        /* Inode range used, but not marked used in bitmap */
-        { PR_5_INODE_RANGE_USED,
-          " +(%i--%j)",
-          PROMPT_NONE, PR_LATCH_IBITMAP | PR_PREEN_OK | PR_PREEN_NOMSG },
-
-        { 0 }
-};
-
-/*
- * This is the latch flags register.  It allows several problems to be
- * "latched" together.  This means that the user has to answer but one
- * question for the set of problems, and all of the associated
- * problems will be either fixed or not fixed.
- */
-static struct latch_descr pr_latch_info[] = {
-        { PR_LATCH_BLOCK, PR_1_INODE_BLOCK_LATCH, 0 },
-        { PR_LATCH_BBLOCK, PR_1_INODE_BBLOCK_LATCH, 0 },
-        { PR_LATCH_IBITMAP, PR_5_INODE_BITMAP_HEADER, PR_5_INODE_BITMAP_END },
-        { PR_LATCH_BBITMAP, PR_5_BLOCK_BITMAP_HEADER, PR_5_BLOCK_BITMAP_END },
-        { PR_LATCH_RELOC, PR_0_RELOCATE_HINT, 0 },
-        { PR_LATCH_DBLOCK, PR_1B_DUP_BLOCK_HEADER, PR_1B_DUP_BLOCK_END },
-        { PR_LATCH_LOW_DTIME, PR_1_ORPHAN_LIST_REFUGEES, 0 },
-        { PR_LATCH_TOOBIG, PR_1_INODE_TOOBIG, 0 },
-        { PR_LATCH_OPTIMIZE_DIR, PR_3A_OPTIMIZE_DIR_HEADER, PR_3A_OPTIMIZE_DIR_END },
-        { -1, 0, 0 },
-};
-
-static const struct e2fsck_problem *find_problem(problem_t code)
-{
-        int     i;
-
-        for (i=0; problem_table[i].e2p_code; i++) {
-                if (problem_table[i].e2p_code == code)
-                        return &problem_table[i];
-        }
-        return 0;
-}
-
-static struct latch_descr *find_latch(int code)
-{
-        int     i;
-
-        for (i=0; pr_latch_info[i].latch_code >= 0; i++) {
-                if (pr_latch_info[i].latch_code == code)
-                        return &pr_latch_info[i];
-        }
-        return 0;
-}
-
-int end_problem_latch(e2fsck_t ctx, int mask)
-{
-        struct latch_descr *ldesc;
-        struct problem_context pctx;
-        int answer = -1;
-        
-        ldesc = find_latch(mask);
-        if (ldesc->end_message && (ldesc->flags & PRL_LATCHED)) {
-                clear_problem_context(&pctx);
-                answer = fix_problem(ctx, ldesc->end_message, &pctx);
-        }
-        ldesc->flags &= ~(PRL_VARIABLE);
-        return answer;
-}
-
-int set_latch_flags(int mask, int setflags, int clearflags)
-{
-        struct latch_descr *ldesc;
-
-        ldesc = find_latch(mask);
-        if (!ldesc)
-                return -1;
-        ldesc->flags |= setflags;
-        ldesc->flags &= ~clearflags;
-        return 0;
-}
-
-int get_latch_flags(int mask, int *value)
-{
-        struct latch_descr *ldesc;
-
-        ldesc = find_latch(mask);
-        if (!ldesc)
-                return -1;
-        *value = ldesc->flags;
-        return 0;
-}
-
-void clear_problem_context(struct problem_context *ctx)
-{
-        memset(ctx, 0, sizeof(struct problem_context));
-        ctx->blkcount = -1;
-        ctx->group = -1;
-}
-
-int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx)
-{
-        ext2_filsys fs = ctx->fs;
-        const struct e2fsck_problem *ptr;
-        struct latch_descr *ldesc = 0;
-        const char *message;
-        int             def_yn, answer, ans;
-        int             print_answer = 0;
-        int             suppress = 0;
-
-        ptr = find_problem(code);
-        if (!ptr) {
-                printf(_("Unhandled error code (0x%x)!\n"), code);
-                return 0;
-        }
-        def_yn = 1;
-        if ((ptr->flags & PR_NO_DEFAULT) ||
-            ((ptr->flags & PR_PREEN_NO) && (ctx->options & E2F_OPT_PREEN)) ||
-            (ctx->options & E2F_OPT_NO))
-                def_yn= 0;
-
-        /*
-         * Do special latch processing.  This is where we ask the
-         * latch question, if it exists
-         */
-        if (ptr->flags & PR_LATCH_MASK) {
-                ldesc = find_latch(ptr->flags & PR_LATCH_MASK);
-                if (ldesc->question && !(ldesc->flags & PRL_LATCHED)) {
-                        ans = fix_problem(ctx, ldesc->question, pctx);
-                        if (ans == 1)
-                                ldesc->flags |= PRL_YES;
-                        if (ans == 0)
-                                ldesc->flags |= PRL_NO;
-                        ldesc->flags |= PRL_LATCHED;
-                }
-                if (ldesc->flags & PRL_SUPPRESS)
-                        suppress++;
-        }
-        if ((ptr->flags & PR_PREEN_NOMSG) &&
-            (ctx->options & E2F_OPT_PREEN))
-                suppress++;
-        if ((ptr->flags & PR_NO_NOMSG) &&
-            (ctx->options & E2F_OPT_NO))
-                suppress++;
-        if (!suppress) {
-                message = ptr->e2p_description;
-                if ((ctx->options & E2F_OPT_PREEN) &&
-                    !(ptr->flags & PR_PREEN_NOHDR)) {
-                        printf("%s: ", ctx->device_name ?
-                               ctx->device_name : ctx->filesystem_name);
-                }
-                if (*message)
-                        print_e2fsck_message(ctx, _(message), pctx, 1);
-        }
-        if (!(ptr->flags & PR_PREEN_OK) && (ptr->prompt != PROMPT_NONE))
-                preenhalt(ctx);
-
-        if (ptr->flags & PR_FATAL)
-                fatal_error(ctx, 0);
-
-        if (ptr->prompt == PROMPT_NONE) {
-                if (ptr->flags & PR_NOCOLLATE)
-                        answer = -1;
-                else
-                        answer = def_yn;
-        } else {
-                if (ctx->options & E2F_OPT_PREEN) {
-                        answer = def_yn;
-                        if (!(ptr->flags & PR_PREEN_NOMSG))
-                                print_answer = 1;
-                } else if ((ptr->flags & PR_LATCH_MASK) &&
-                           (ldesc->flags & (PRL_YES | PRL_NO))) {
-                        if (!suppress)
-                                print_answer = 1;
-                        if (ldesc->flags & PRL_YES)
-                                answer = 1;
-                        else
-                                answer = 0;
-                } else
-                        answer = ask(ctx, _(prompt[(int) ptr->prompt]), def_yn);
-                if (!answer && !(ptr->flags & PR_NO_OK))
-                        ext2fs_unmark_valid(fs);
-        
-                if (print_answer)
-                        printf("%s.\n", answer ?
-                               _(preen_msg[(int) ptr->prompt]) : _("IGNORED"));
-        
-        }
-
-        if ((ptr->prompt == PROMPT_ABORT) && answer)
-                fatal_error(ctx, 0);
-
-        if (ptr->flags & PR_AFTER_CODE)
-                answer = fix_problem(ctx, ptr->second_code, pctx);
-
-        return answer;
-}
diff --git a/e2fsprogs/e2fsck/problem.h b/e2fsprogs/e2fsck/problem.h
deleted file mode 100644
index 0e39a2935..000000000
--- a/e2fsprogs/e2fsck/problem.h
+++ /dev/null
@@ -1,897 +0,0 @@
-/*
- * problem.h --- e2fsck problem error codes
- *
- * Copyright 1996 by Theodore Ts'o
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- */
-
-typedef __u32 problem_t;
-
-struct problem_context {
-        errcode_t       errcode;
-        ext2_ino_t ino, ino2, dir;
-        struct ext2_inode *inode;
-        struct ext2_dir_entry *dirent;
-        blk_t   blk, blk2;
-        e2_blkcnt_t     blkcount;
-        int             group;
-        __u64   num;
-        const char *str;
-};
-
-/*
- * We define a set of "latch groups"; these are problems which are
- * handled as a set.  The user answers once for a particular latch
- * group.
- */
-#define PR_LATCH_MASK   0x0ff0  /* Latch mask */
-#define PR_LATCH_BLOCK  0x0010  /* Latch for illegal blocks (pass 1) */
-#define PR_LATCH_BBLOCK 0x0020  /* Latch for bad block inode blocks (pass 1) */
-#define PR_LATCH_IBITMAP 0x0030 /* Latch for pass 5 inode bitmap proc. */
-#define PR_LATCH_BBITMAP 0x0040 /* Latch for pass 5 inode bitmap proc. */
-#define PR_LATCH_RELOC  0x0050  /* Latch for superblock relocate hint */
-#define PR_LATCH_DBLOCK 0x0060  /* Latch for pass 1b dup block headers */
-#define PR_LATCH_LOW_DTIME 0x0070 /* Latch for pass1 orphaned list refugees */
-#define PR_LATCH_TOOBIG 0x0080  /* Latch for file to big errors */
-#define PR_LATCH_OPTIMIZE_DIR 0x0090 /* Latch for optimize directories */
-
-#define PR_LATCH(x)     ((((x) & PR_LATCH_MASK) >> 4) - 1)
-
-/*
- * Latch group descriptor flags
- */
-#define PRL_YES         0x0001  /* Answer yes */
-#define PRL_NO          0x0002  /* Answer no */
-#define PRL_LATCHED     0x0004  /* The latch group is latched */
-#define PRL_SUPPRESS    0x0008  /* Suppress all latch group questions */
-
-#define PRL_VARIABLE    0x000f  /* All the flags that need to be reset */
-
-/*
- * Pre-Pass 1 errors
- */
-
-/* Block bitmap not in group */
-#define PR_0_BB_NOT_GROUP       0x000001
-
-/* Inode bitmap not in group */
-#define PR_0_IB_NOT_GROUP       0x000002
-
-/* Inode table not in group */
-#define PR_0_ITABLE_NOT_GROUP   0x000003
-
-/* Superblock corrupt */
-#define PR_0_SB_CORRUPT         0x000004
-
-/* Filesystem size is wrong */
-#define PR_0_FS_SIZE_WRONG      0x000005
-
-/* Fragments not supported */
-#define PR_0_NO_FRAGMENTS       0x000006
-
-/* Bad blocks_per_group */
-#define PR_0_BLOCKS_PER_GROUP   0x000007
-
-/* Bad first_data_block */
-#define PR_0_FIRST_DATA_BLOCK   0x000008
-
-/* Adding UUID to filesystem */
-#define PR_0_ADD_UUID           0x000009
-
-/* Relocate hint */     
-#define PR_0_RELOCATE_HINT      0x00000A
-
-/* Miscellaneous superblock corruption */
-#define PR_0_MISC_CORRUPT_SUPER 0x00000B
-        
-/* Error determing physical device size of filesystem */
-#define PR_0_GETSIZE_ERROR      0x00000C
-
-/* Inode count in the superblock incorrect */
-#define PR_0_INODE_COUNT_WRONG  0x00000D
-
-/* The Hurd does not support the filetype feature */
-#define PR_0_HURD_CLEAR_FILETYPE 0x00000E
-
-/* Journal inode is invalid */
-#define PR_0_JOURNAL_BAD_INODE  0x00000F
-
-/* The external journal has multiple filesystems (which we can't handle yet) */
-#define PR_0_JOURNAL_UNSUPP_MULTIFS 0x000010
-
-/* Can't find external journal */
-#define PR_0_CANT_FIND_JOURNAL  0x000011
-
-/* External journal has bad superblock */
-#define PR_0_EXT_JOURNAL_BAD_SUPER 0x000012
-
-/* Superblock has a bad journal UUID */
-#define PR_0_JOURNAL_BAD_UUID   0x000013
-
-/* Journal has an unknown superblock type */
-#define PR_0_JOURNAL_UNSUPP_SUPER 0x000014
-
-/* Journal superblock is corrupt */
-#define PR_0_JOURNAL_BAD_SUPER  0x000015
-
-/* Journal superblock is corrupt */
-#define PR_0_JOURNAL_HAS_JOURNAL 0x000016
-
-/* Superblock has recovery flag set but no journal */
-#define PR_0_JOURNAL_RECOVER_SET 0x000017
-
-/* Journal has data, but recovery flag is clear */
-#define PR_0_JOURNAL_RECOVERY_CLEAR 0x000018
-
-/* Ask if we should clear the journal */
-#define PR_0_JOURNAL_RESET_JOURNAL 0x000019
-
-/* Filesystem revision is 0, but feature flags are set */
-#define PR_0_FS_REV_LEVEL       0x00001A
-
-/* Clearing orphan inode */
-#define PR_0_ORPHAN_CLEAR_INODE                 0x000020
-        
-/* Illegal block found in orphaned inode */
-#define PR_0_ORPHAN_ILLEGAL_BLOCK_NUM           0x000021
-
-/* Already cleared block found in orphaned inode */
-#define PR_0_ORPHAN_ALREADY_CLEARED_BLOCK       0x000022
-        
-/* Illegal orphan inode in superblock */
-#define PR_0_ORPHAN_ILLEGAL_HEAD_INODE          0x000023
-
-/* Illegal inode in orphaned inode list */
-#define PR_0_ORPHAN_ILLEGAL_INODE               0x000024
-
-/* Journal has unsupported read-only feature - abort */
-#define PR_0_JOURNAL_UNSUPP_ROCOMPAT            0x000025
-
-/* Journal has unsupported incompatible feature - abort */
-#define PR_0_JOURNAL_UNSUPP_INCOMPAT            0x000026
-
-/* Journal has unsupported version number */
-#define PR_0_JOURNAL_UNSUPP_VERSION             0x000027
-
-/* Moving journal to hidden file */
-#define PR_0_MOVE_JOURNAL                       0x000028
-
-/* Error moving journal */
-#define PR_0_ERR_MOVE_JOURNAL                   0x000029
-
-/* Clearing V2 journal superblock */
-#define PR_0_CLEAR_V2_JOURNAL                   0x00002A
-
-/* Run journal anyway */
-#define PR_0_JOURNAL_RUN                        0x00002B
-
-/* Run journal anyway by default */
-#define PR_0_JOURNAL_RUN_DEFAULT                0x00002C
-
-/* Backup journal inode blocks */
-#define PR_0_BACKUP_JNL                         0x00002D
-
-/* Reserved blocks w/o resize_inode */
-#define PR_0_NONZERO_RESERVED_GDT_BLOCKS        0x00002E
-
-/* Resize_inode not enabled, but resize inode is non-zero */
-#define PR_0_CLEAR_RESIZE_INODE                 0x00002F
-
-/* Resize inode invalid */
-#define PR_0_RESIZE_INODE_INVALID               0x000030
-
-/*
- * Pass 1 errors
- */
-
-/* Pass 1: Checking inodes, blocks, and sizes */
-#define PR_1_PASS_HEADER                0x010000
-
-/* Root directory is not an inode */
-#define PR_1_ROOT_NO_DIR                0x010001
-
-/* Root directory has dtime set */
-#define PR_1_ROOT_DTIME                 0x010002
-
-/* Reserved inode has bad mode */
-#define PR_1_RESERVED_BAD_MODE          0x010003
-
-/* Deleted inode has zero dtime */
-#define PR_1_ZERO_DTIME                 0x010004
-
-/* Inode in use, but dtime set */
-#define PR_1_SET_DTIME                  0x010005
-
-/* Zero-length directory */
-#define PR_1_ZERO_LENGTH_DIR            0x010006
-
-/* Block bitmap conflicts with some other fs block */
-#define PR_1_BB_CONFLICT                0x010007
-
-/* Inode bitmap conflicts with some other fs block */
-#define PR_1_IB_CONFLICT                0x010008
-
-/* Inode table conflicts with some other fs block */
-#define PR_1_ITABLE_CONFLICT            0x010009
-
-/* Block bitmap is on a bad block */
-#define PR_1_BB_BAD_BLOCK               0x01000A
-
-/* Inode bitmap is on a bad block */
-#define PR_1_IB_BAD_BLOCK               0x01000B
-
-/* Inode has incorrect i_size */
-#define PR_1_BAD_I_SIZE                 0x01000C
-
-/* Inode has incorrect i_blocks */
-#define PR_1_BAD_I_BLOCKS               0x01000D
-
-/* Illegal block number in inode */
-#define PR_1_ILLEGAL_BLOCK_NUM          0x01000E
-
-/* Block number overlaps fs metadata */
-#define PR_1_BLOCK_OVERLAPS_METADATA    0x01000F
-
-/* Inode has illegal blocks (latch question) */
-#define PR_1_INODE_BLOCK_LATCH          0x010010
-
-/* Too many bad blocks in inode */
-#define PR_1_TOO_MANY_BAD_BLOCKS        0x010011
-        
-/* Illegal block number in bad block inode */
-#define PR_1_BB_ILLEGAL_BLOCK_NUM       0x010012
-
-/* Bad block inode has illegal blocks (latch question) */
-#define PR_1_INODE_BBLOCK_LATCH         0x010013
-
-/* Duplicate or bad blocks in use! */
-#define PR_1_DUP_BLOCKS_PREENSTOP       0x010014
-        
-/* Bad block used as bad block indirect block */          
-#define PR_1_BBINODE_BAD_METABLOCK      0x010015
-
-/* Inconsistency can't be fixed prompt */
-#define PR_1_BBINODE_BAD_METABLOCK_PROMPT 0x010016
-        
-/* Bad primary block */
-#define PR_1_BAD_PRIMARY_BLOCK          0x010017
-                  
-/* Bad primary block prompt */
-#define PR_1_BAD_PRIMARY_BLOCK_PROMPT   0x010018
-
-/* Bad primary superblock */
-#define PR_1_BAD_PRIMARY_SUPERBLOCK     0x010019
-
-/* Bad primary block group descriptors */
-#define PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR 0x01001A
-
-/* Bad superblock in group */
-#define PR_1_BAD_SUPERBLOCK             0x01001B
-
-/* Bad block group descriptors in group */
-#define PR_1_BAD_GROUP_DESCRIPTORS      0x01001C
-
-/* Block claimed for no reason */         
-#define PR_1_PROGERR_CLAIMED_BLOCK      0x01001D
-
-/* Error allocating blocks for relocating metadata */
-#define PR_1_RELOC_BLOCK_ALLOCATE       0x01001E
-                
-/* Error allocating block buffer during relocation process */
-#define PR_1_RELOC_MEMORY_ALLOCATE      0x01001F
-                
-/* Relocating metadata group information from X to Y */ 
-#define PR_1_RELOC_FROM_TO              0x010020
-                
-/* Relocating metatdata group information to X */
-#define PR_1_RELOC_TO                   0x010021
-                
-/* Block read error during relocation process */
-#define PR_1_RELOC_READ_ERR             0x010022
-                
-/* Block write error during relocation process */
-#define PR_1_RELOC_WRITE_ERR            0x010023
-
-/* Error allocating inode bitmap */
-#define PR_1_ALLOCATE_IBITMAP_ERROR     0x010024
-
-/* Error allocating block bitmap */
-#define PR_1_ALLOCATE_BBITMAP_ERROR     0x010025
-
-/* Error allocating icount structure */
-#define PR_1_ALLOCATE_ICOUNT            0x010026
-        
-/* Error allocating dbcount */
-#define PR_1_ALLOCATE_DBCOUNT           0x010027
-
-/* Error while scanning inodes */
-#define PR_1_ISCAN_ERROR                0x010028
-
-/* Error while iterating over blocks */
-#define PR_1_BLOCK_ITERATE              0x010029
-
-/* Error while storing inode count information */         
-#define PR_1_ICOUNT_STORE               0x01002A
-
-/* Error while storing directory block information */     
-#define PR_1_ADD_DBLOCK                 0x01002B
-
-/* Error while reading inode (for clearing) */
-#define PR_1_READ_INODE                 0x01002C
-
-/* Suppress messages prompt */
-#define PR_1_SUPPRESS_MESSAGES          0x01002D
-
-/* Imagic flag set on an inode when filesystem doesn't support it */
-#define PR_1_SET_IMAGIC                 0x01002F
-
-/* Immutable flag set on a device or socket inode */
-#define PR_1_SET_IMMUTABLE              0x010030
-
-/* Compression flag set on a non-compressed filesystem */
-#define PR_1_COMPR_SET                  0x010031
-
-/* Non-zero size on on device, fifo or socket inode */
-#define PR_1_SET_NONZSIZE               0x010032
-
-/* Filesystem revision is 0, but feature flags are set */
-#define PR_1_FS_REV_LEVEL               0x010033
-
-/* Journal inode not in use, needs clearing */
-#define PR_1_JOURNAL_INODE_NOT_CLEAR    0x010034
-
-/* Journal inode has wrong mode */
-#define PR_1_JOURNAL_BAD_MODE           0x010035
-
-/* Inode that was part of orphan linked list */
-#define PR_1_LOW_DTIME                  0x010036
-
-/* Latch question which asks how to deal with low dtime inodes */
-#define PR_1_ORPHAN_LIST_REFUGEES       0x010037
-
-/* Error allocating refcount structure */
-#define PR_1_ALLOCATE_REFCOUNT          0x010038
-        
-/* Error reading Extended Attribute block */
-#define PR_1_READ_EA_BLOCK              0x010039
-
-/* Invalid Extended Attribute block */
-#define PR_1_BAD_EA_BLOCK               0x01003A
-
-/* Error reading Extended Attribute block while fixing refcount -- abort */
-#define PR_1_EXTATTR_READ_ABORT         0x01003B
-
-/* Extended attribute reference count incorrect */
-#define PR_1_EXTATTR_REFCOUNT           0x01003C
-
-/* Error writing Extended Attribute block while fixing refcount */ 
-#define PR_1_EXTATTR_WRITE              0x01003D
-
-/* Multiple EA blocks not supported */
-#define PR_1_EA_MULTI_BLOCK             0x01003E
-
-/* Error allocating EA region allocation structure */
-#define PR_1_EA_ALLOC_REGION            0x01003F
-
-/* Error EA allocation collision */
-#define PR_1_EA_ALLOC_COLLISION         0x010040
-
-/* Bad extended attribute name */
-#define PR_1_EA_BAD_NAME                0x010041
-
-/* Bad extended attribute value */
-#define PR_1_EA_BAD_VALUE               0x010042
-
-/* Inode too big (latch question) */
-#define PR_1_INODE_TOOBIG               0x010043
-
-/* Directory too big */
-#define PR_1_TOOBIG_DIR                 0x010044
-
-/* Regular file too big */
-#define PR_1_TOOBIG_REG                 0x010045
-
-/* Symlink too big */
-#define PR_1_TOOBIG_SYMLINK             0x010046
-
-/* INDEX_FL flag set on a non-HTREE filesystem */
-#define PR_1_HTREE_SET                  0x010047
-
-/* INDEX_FL flag set on a non-directory */      
-#define PR_1_HTREE_NODIR                0x010048
-
-/* Invalid root node in HTREE directory */      
-#define PR_1_HTREE_BADROOT              0x010049
-
-/* Unsupported hash version in HTREE directory */       
-#define PR_1_HTREE_HASHV                0x01004A
-
-/* Incompatible flag in HTREE root node */      
-#define PR_1_HTREE_INCOMPAT             0x01004B
-
-/* HTREE too deep */    
-#define PR_1_HTREE_DEPTH                0x01004C
-
-/* Bad block has indirect block that conflicts with filesystem block */
-#define PR_1_BB_FS_BLOCK                0x01004D
-
-/* Resize inode failed */
-#define PR_1_RESIZE_INODE_CREATE        0x01004E
-
-/* inode->i_size is too long */ 
-#define PR_1_EXTRA_ISIZE                0x01004F
-
-/* attribute name is too long */
-#define PR_1_ATTR_NAME_LEN              0x010050
-
-/* wrong EA value offset */
-#define PR_1_ATTR_VALUE_OFFSET          0x010051
-
-/* wrong EA blocknumber */
-#define PR_1_ATTR_VALUE_BLOCK           0x010052
-
-/* wrong EA value size */
-#define PR_1_ATTR_VALUE_SIZE            0x010053
-
-/* wrong EA hash value */
-#define PR_1_ATTR_HASH                  0x010054
-
-/*
- * Pass 1b errors
- */
-
-/* Pass 1B: Rescan for duplicate/bad blocks */
-#define PR_1B_PASS_HEADER       0x011000
-
-/* Duplicate/bad block(s) header */
-#define PR_1B_DUP_BLOCK_HEADER  0x011001
-
-/* Duplicate/bad block(s) in inode */
-#define PR_1B_DUP_BLOCK         0x011002
-
-/* Duplicate/bad block(s) end */
-#define PR_1B_DUP_BLOCK_END     0x011003
-        
-/* Error while scanning inodes */
-#define PR_1B_ISCAN_ERROR       0x011004
-
-/* Error allocating inode bitmap */
-#define PR_1B_ALLOCATE_IBITMAP_ERROR 0x011005
-
-/* Error while iterating over blocks */
-#define PR_1B_BLOCK_ITERATE     0x0110006
-
-/* Error adjusting EA refcount */
-#define PR_1B_ADJ_EA_REFCOUNT   0x0110007
-
-
-/* Pass 1C: Scan directories for inodes with dup blocks. */
-#define PR_1C_PASS_HEADER       0x012000
-
-
-/* Pass 1D: Reconciling duplicate blocks */
-#define PR_1D_PASS_HEADER       0x013000
-
-/* File has duplicate blocks */
-#define PR_1D_DUP_FILE          0x013001
-
-/* List of files sharing duplicate blocks */    
-#define PR_1D_DUP_FILE_LIST     0x013002
-
-/* File sharing blocks with filesystem metadata  */     
-#define PR_1D_SHARE_METADATA    0x013003
-
-/* Report of how many duplicate/bad inodes */   
-#define PR_1D_NUM_DUP_INODES    0x013004
-
-/* Duplicated blocks already reassigned or cloned. */
-#define PR_1D_DUP_BLOCKS_DEALT  0x013005
-
-/* Clone duplicate/bad blocks? */
-#define PR_1D_CLONE_QUESTION    0x013006
-
-/* Delete file? */
-#define PR_1D_DELETE_QUESTION   0x013007
-
-/* Couldn't clone file (error) */
-#define PR_1D_CLONE_ERROR       0x013008
-                
-/*
- * Pass 2 errors
- */
-
-/* Pass 2: Checking directory structure */
-#define PR_2_PASS_HEADER        0x020000
-
-/* Bad inode number for '.' */
-#define PR_2_BAD_INODE_DOT      0x020001
-
-/* Directory entry has bad inode number */
-#define PR_2_BAD_INO            0x020002
-
-/* Directory entry has deleted or unused inode */
-#define PR_2_UNUSED_INODE       0x020003
-
-/* Directry entry is link to '.' */
-#define PR_2_LINK_DOT           0x020004
-
-/* Directory entry points to inode now located in a bad block */
-#define PR_2_BB_INODE           0x020005
-
-/* Directory entry contains a link to a directory */
-#define PR_2_LINK_DIR           0x020006
-
-/* Directory entry contains a link to the root directry */
-#define PR_2_LINK_ROOT          0x020007
-
-/* Directory entry has illegal characters in its name */
-#define PR_2_BAD_NAME           0x020008
-
-/* Missing '.' in directory inode */      
-#define PR_2_MISSING_DOT        0x020009
-
-/* Missing '..' in directory inode */     
-#define PR_2_MISSING_DOT_DOT    0x02000A
-
-/* First entry in directory inode doesn't contain '.' */
-#define PR_2_1ST_NOT_DOT        0x02000B
-
-/* Second entry in directory inode doesn't contain '..' */
-#define PR_2_2ND_NOT_DOT_DOT    0x02000C
-
-/* i_faddr should be zero */
-#define PR_2_FADDR_ZERO         0x02000D
-
-/* i_file_acl should be zero */
-#define PR_2_FILE_ACL_ZERO      0x02000E
-
-/* i_dir_acl should be zero */
-#define PR_2_DIR_ACL_ZERO       0x02000F
-
-/* i_frag should be zero */
-#define PR_2_FRAG_ZERO          0x020010
-
-/* i_fsize should be zero */
-#define PR_2_FSIZE_ZERO         0x020011
-                  
-/* inode has bad mode */
-#define PR_2_BAD_MODE           0x020012
-
-/* directory corrupted */
-#define PR_2_DIR_CORRUPTED      0x020013
-                  
-/* filename too long */
-#define PR_2_FILENAME_LONG      0x020014
-                  
-/* Directory inode has a missing block (hole) */
-#define PR_2_DIRECTORY_HOLE     0x020015
-
-/* '.' is not NULL terminated */
-#define PR_2_DOT_NULL_TERM      0x020016
-
-/* '..' is not NULL terminated */
-#define PR_2_DOT_DOT_NULL_TERM  0x020017
-
-/* Illegal character device in inode */
-#define PR_2_BAD_CHAR_DEV       0x020018
-
-/* Illegal block device in inode */
-#define PR_2_BAD_BLOCK_DEV      0x020019
-
-/* Duplicate '.' entry */
-#define PR_2_DUP_DOT            0x02001A
-
-/* Duplicate '..' entry */
-#define PR_2_DUP_DOT_DOT        0x02001B
-        
-/* Internal error: couldn't find dir_info */
-#define PR_2_NO_DIRINFO         0x02001C
-
-/* Final rec_len is wrong */
-#define PR_2_FINAL_RECLEN       0x02001D
-
-/* Error allocating icount structure */
-#define PR_2_ALLOCATE_ICOUNT    0x02001E
-
-/* Error iterating over directory blocks */
-#define PR_2_DBLIST_ITERATE     0x02001F
-
-/* Error reading directory block */
-#define PR_2_READ_DIRBLOCK      0x020020
-
-/* Error writing directory block */
-#define PR_2_WRITE_DIRBLOCK     0x020021
-
-/* Error allocating new directory block */
-#define PR_2_ALLOC_DIRBOCK      0x020022
-
-/* Error deallocating inode */
-#define PR_2_DEALLOC_INODE      0x020023
-
-/* Directory entry for '.' is big.  Split? */
-#define PR_2_SPLIT_DOT          0x020024
-
-/* Illegal FIFO */
-#define PR_2_BAD_FIFO           0x020025
-
-/* Illegal socket */
-#define PR_2_BAD_SOCKET         0x020026
-
-/* Directory filetype not set */
-#define PR_2_SET_FILETYPE       0x020027
-
-/* Directory filetype incorrect */
-#define PR_2_BAD_FILETYPE       0x020028
-
-/* Directory filetype set when it shouldn't be */
-#define PR_2_CLEAR_FILETYPE     0x020029
-
-/* Directory filename can't be zero-length  */
-#define PR_2_NULL_NAME          0x020030
-
-/* Invalid symlink */
-#define PR_2_INVALID_SYMLINK    0x020031
-
-/* i_file_acl (extended attribute) is bad */
-#define PR_2_FILE_ACL_BAD       0x020032
-
-/* Filesystem contains large files, but has no such flag in sb */
-#define PR_2_FEATURE_LARGE_FILES 0x020033
-
-/* Node in HTREE directory not referenced */
-#define PR_2_HTREE_NOTREF       0x020034
-
-/* Node in HTREE directory referenced twice */
-#define PR_2_HTREE_DUPREF       0x020035
-
-/* Node in HTREE directory has bad min hash */
-#define PR_2_HTREE_MIN_HASH     0x020036
-
-/* Node in HTREE directory has bad max hash */
-#define PR_2_HTREE_MAX_HASH     0x020037
-
-/* Clear invalid HTREE directory */
-#define PR_2_HTREE_CLEAR        0x020038
-
-/* Clear the htree flag forcibly */
-/* #define PR_2_HTREE_FCLR      0x020039 */
-
-/* Bad block in htree interior node */
-#define PR_2_HTREE_BADBLK       0x02003A
-
-/* Error adjusting EA refcount */
-#define PR_2_ADJ_EA_REFCOUNT    0x02003B
-
-/* Invalid HTREE root node */
-#define PR_2_HTREE_BAD_ROOT     0x02003C
-
-/* Invalid HTREE limit */
-#define PR_2_HTREE_BAD_LIMIT    0x02003D
-
-/* Invalid HTREE count */
-#define PR_2_HTREE_BAD_COUNT    0x02003E
-
-/* HTREE interior node has out-of-order hashes in table */
-#define PR_2_HTREE_HASH_ORDER   0x02003F
-
-/* Node in HTREE directory has bad depth */
-#define PR_2_HTREE_BAD_DEPTH    0x020040
-
-/* Duplicate directory entry found */
-#define PR_2_DUPLICATE_DIRENT   0x020041
-
-/* Non-unique filename found */
-#define PR_2_NON_UNIQUE_FILE    0x020042
-
-/* Duplicate directory entry found */
-#define PR_2_REPORT_DUP_DIRENT  0x020043
-
-/*
- * Pass 3 errors
- */
-
-/* Pass 3: Checking directory connectivity */
-#define PR_3_PASS_HEADER                0x030000
-
-/* Root inode not allocated */
-#define PR_3_NO_ROOT_INODE              0x030001
-
-/* No room in lost+found */
-#define PR_3_EXPAND_LF_DIR              0x030002
-
-/* Unconnected directory inode */
-#define PR_3_UNCONNECTED_DIR            0x030003
-
-/* /lost+found not found */
-#define PR_3_NO_LF_DIR                  0x030004
-
-/* .. entry is incorrect */
-#define PR_3_BAD_DOT_DOT                0x030005
-
-/* Bad or non-existent /lost+found.  Cannot reconnect */
-#define PR_3_NO_LPF                     0x030006
-
-/* Could not expand /lost+found */
-#define PR_3_CANT_EXPAND_LPF            0x030007
-
-/* Could not reconnect inode */
-#define PR_3_CANT_RECONNECT             0x030008
-
-/* Error while trying to find /lost+found */
-#define PR_3_ERR_FIND_LPF               0x030009
-
-/* Error in ext2fs_new_block while creating /lost+found */
-#define PR_3_ERR_LPF_NEW_BLOCK          0x03000A
-
-/* Error in ext2fs_new_inode while creating /lost+found */
-#define PR_3_ERR_LPF_NEW_INODE          0x03000B
-
-/* Error in ext2fs_new_dir_block while creating /lost+found */    
-#define PR_3_ERR_LPF_NEW_DIR_BLOCK      0x03000C
-                  
-/* Error while writing directory block for /lost+found */
-#define PR_3_ERR_LPF_WRITE_BLOCK        0x03000D
-
-/* Error while adjusting inode count */
-#define PR_3_ADJUST_INODE               0x03000E
-
-/* Couldn't fix parent directory -- error */
-#define PR_3_FIX_PARENT_ERR             0x03000F
-
-/* Couldn't fix parent directory -- couldn't find it */   
-#define PR_3_FIX_PARENT_NOFIND          0x030010
-        
-/* Error allocating inode bitmap */
-#define PR_3_ALLOCATE_IBITMAP_ERROR     0x030011
-                  
-/* Error creating root directory */
-#define PR_3_CREATE_ROOT_ERROR          0x030012
-
-/* Error creating lost and found directory */
-#define PR_3_CREATE_LPF_ERROR           0x030013
-
-/* Root inode is not directory; aborting */
-#define PR_3_ROOT_NOT_DIR_ABORT         0x030014
-
-/* Cannot proceed without a root inode. */
-#define PR_3_NO_ROOT_INODE_ABORT        0x030015
-
-/* Internal error: couldn't find dir_info */
-#define PR_3_NO_DIRINFO                 0x030016
-
-/* Lost+found is not a directory */
-#define PR_3_LPF_NOTDIR                 0x030017
-
-/*
- * Pass 3a --- rehashing diretories
- */
-/* Pass 3a: Reindexing directories */
-#define PR_3A_PASS_HEADER               0x031000
-
-/* Error iterating over directories */
-#define PR_3A_OPTIMIZE_ITER             0x031001
-
-/* Error rehash directory */
-#define PR_3A_OPTIMIZE_DIR_ERR          0x031002                
-
-/* Rehashing dir header */
-#define PR_3A_OPTIMIZE_DIR_HEADER               0x031003
-
-/* Rehashing directory %d */
-#define PR_3A_OPTIMIZE_DIR              0x031004
-                  
-/* Rehashing dir end */   
-#define PR_3A_OPTIMIZE_DIR_END          0x031005
-
-/*
- * Pass 4 errors
- */
-
-/* Pass 4: Checking reference counts */
-#define PR_4_PASS_HEADER        0x040000
-
-/* Unattached zero-length inode */
-#define PR_4_ZERO_LEN_INODE     0x040001
-
-/* Unattached inode */
-#define PR_4_UNATTACHED_INODE   0x040002
-
-/* Inode ref count wrong */
-#define PR_4_BAD_REF_COUNT      0x040003
-
-/* Inconsistent inode count information cached */
-#define PR_4_INCONSISTENT_COUNT 0x040004
-
-/*
- * Pass 5 errors
- */
-
-/* Pass 5: Checking group summary information */
-#define PR_5_PASS_HEADER                0x050000
-        
-/* Padding at end of inode bitmap is not set. */
-#define PR_5_INODE_BMAP_PADDING         0x050001
-
-/* Padding at end of block bitmap is not set. */
-#define PR_5_BLOCK_BMAP_PADDING         0x050002
-
-/* Block bitmap differences header */
-#define PR_5_BLOCK_BITMAP_HEADER        0x050003
-
-/* Block not used, but marked in bitmap */
-#define PR_5_BLOCK_UNUSED               0x050004
-          
-/* Block used, but not marked used in bitmap */
-#define PR_5_BLOCK_USED                 0x050005
-
-/* Block bitmap differences end */        
-#define PR_5_BLOCK_BITMAP_END           0x050006
-
-/* Inode bitmap differences header */
-#define PR_5_INODE_BITMAP_HEADER        0x050007
-
-/* Inode not used, but marked in bitmap */
-#define PR_5_INODE_UNUSED               0x050008
-          
-/* Inode used, but not marked used in bitmap */
-#define PR_5_INODE_USED                 0x050009
-
-/* Inode bitmap differences end */        
-#define PR_5_INODE_BITMAP_END           0x05000A
-
-/* Free inodes count for group wrong */
-#define PR_5_FREE_INODE_COUNT_GROUP     0x05000B
-
-/* Directories count for group wrong */
-#define PR_5_FREE_DIR_COUNT_GROUP       0x05000C
-
-/* Free inodes count wrong */
-#define PR_5_FREE_INODE_COUNT   0x05000D
-
-/* Free blocks count for group wrong */
-#define PR_5_FREE_BLOCK_COUNT_GROUP     0x05000E
-
-/* Free blocks count wrong */
-#define PR_5_FREE_BLOCK_COUNT           0x05000F
-
-/* Programming error: bitmap endpoints don't match */
-#define PR_5_BMAP_ENDPOINTS             0x050010
-
-/* Internal error: fudging end of bitmap */
-#define PR_5_FUDGE_BITMAP_ERROR         0x050011
-
-/* Error copying in replacement inode bitmap */
-#define PR_5_COPY_IBITMAP_ERROR         0x050012
-
-/* Error copying in replacement block bitmap */
-#define PR_5_COPY_BBITMAP_ERROR         0x050013
-
-/* Block range not used, but marked in bitmap */
-#define PR_5_BLOCK_RANGE_UNUSED         0x050014
-          
-/* Block range used, but not marked used in bitmap */
-#define PR_5_BLOCK_RANGE_USED           0x050015
-
-/* Inode range not used, but marked in bitmap */
-#define PR_5_INODE_RANGE_UNUSED         0x050016
-          
-/* Inode rangeused, but not marked used in bitmap */
-#define PR_5_INODE_RANGE_USED           0x050017
-
-/*
- * Function declarations
- */
-int fix_problem(e2fsck_t ctx, problem_t code, struct problem_context *pctx);
-int end_problem_latch(e2fsck_t ctx, int mask);
-int set_latch_flags(int mask, int setflags, int clearflags);
-int get_latch_flags(int mask, int *value);
-void clear_problem_context(struct problem_context *ctx);
-
-/* message.c */
-void print_e2fsck_message(e2fsck_t ctx, const char *msg,
-                          struct problem_context *pctx, int first);
-
diff --git a/e2fsprogs/e2fsck/problemP.h b/e2fsprogs/e2fsck/problemP.h
deleted file mode 100644
index 329056b95..000000000
--- a/e2fsprogs/e2fsck/problemP.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * problemP.h --- Private header file for fix_problem()
- *
- * Copyright 1997 by Theodore Ts'o
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- */
-
-struct e2fsck_problem {
-        problem_t       e2p_code;
-        const char *    e2p_description;
-        char            prompt;
-        int             flags;
-        problem_t       second_code;
-};
-
-struct latch_descr {
-        int             latch_code;
-        problem_t       question;
-        problem_t       end_message;
-        int             flags;
-};
-
-#define PR_PREEN_OK     0x000001 /* Don't need to do preenhalt */
-#define PR_NO_OK        0x000002 /* If user answers no, don't make fs invalid */
-#define PR_NO_DEFAULT   0x000004 /* Default to no */
-#define PR_MSG_ONLY     0x000008 /* Print message only */
-
-/* Bit positions 0x000ff0 are reserved for the PR_LATCH flags */
-
-#define PR_FATAL        0x001000 /* Fatal error */
-#define PR_AFTER_CODE   0x002000 /* After asking the first question, */
-                                 /* ask another */
-#define PR_PREEN_NOMSG  0x004000 /* Don't print a message if we're preening */
-#define PR_NOCOLLATE    0x008000 /* Don't collate answers for this latch */
-#define PR_NO_NOMSG     0x010000 /* Don't print a message if e2fsck -n */
-#define PR_PREEN_NO     0x020000 /* Use No as an answer if preening */
-#define PR_PREEN_NOHDR  0x040000 /* Don't print the preen header */
-
diff --git a/e2fsprogs/e2fsck/recovery.c b/e2fsprogs/e2fsck/recovery.c
deleted file mode 100644
index edfa9bc83..000000000
--- a/e2fsprogs/e2fsck/recovery.c
+++ /dev/null
@@ -1,586 +0,0 @@
-/*
- * linux/fs/recovery.c
- * 
- * Written by Stephen C. Tweedie <sct@redhat.com>, 1999
- *
- * Copyright 1999-2000 Red Hat Software --- All Rights Reserved
- *
- * This file is part of the Linux kernel and is made available under
- * the terms of the GNU General Public License, version 2, or at your
- * option, any later version, incorporated herein by reference.
- *
- * Journal recovery routines for the generic filesystem journaling code;
- * part of the ext2fs journaling system.  
- */
-
-#ifndef __KERNEL__
-#include "jfs_user.h"
-#else
-#include <linux/time.h>
-#include <linux/fs.h>
-#include <linux/jbd.h>
-#include <linux/errno.h>
-#include <linux/slab.h>
-#endif
-
-/*
- * Maintain information about the progress of the recovery job, so that
- * the different passes can carry information between them. 
- */
-struct recovery_info 
-{
-        tid_t           start_transaction;      
-        tid_t           end_transaction;
-        
-        int             nr_replays;
-        int             nr_revokes;
-        int             nr_revoke_hits;
-};
-
-enum passtype {PASS_SCAN, PASS_REVOKE, PASS_REPLAY};
-static int do_one_pass(journal_t *journal,
-                                struct recovery_info *info, enum passtype pass);
-static int scan_revoke_records(journal_t *, struct buffer_head *,
-                                tid_t, struct recovery_info *);
-
-#ifdef __KERNEL__
-
-/* Release readahead buffers after use */
-void journal_brelse_array(struct buffer_head *b[], int n)
-{
-        while (--n >= 0)
-                brelse (b[n]);
-}
-
-
-/*
- * When reading from the journal, we are going through the block device
- * layer directly and so there is no readahead being done for us.  We
- * need to implement any readahead ourselves if we want it to happen at
- * all.  Recovery is basically one long sequential read, so make sure we
- * do the IO in reasonably large chunks.
- *
- * This is not so critical that we need to be enormously clever about
- * the readahead size, though.  128K is a purely arbitrary, good-enough
- * fixed value.
- */
-
-#define MAXBUF 8
-static int do_readahead(journal_t *journal, unsigned int start)
-{
-        int err;
-        unsigned int max, nbufs, next;
-        unsigned long blocknr;
-        struct buffer_head *bh;
-        
-        struct buffer_head * bufs[MAXBUF];
-        
-        /* Do up to 128K of readahead */
-        max = start + (128 * 1024 / journal->j_blocksize);
-        if (max > journal->j_maxlen)
-                max = journal->j_maxlen;
-
-        /* Do the readahead itself.  We'll submit MAXBUF buffer_heads at
-         * a time to the block device IO layer. */
-        
-        nbufs = 0;
-        
-        for (next = start; next < max; next++) {
-                err = journal_bmap(journal, next, &blocknr);
-
-                if (err) {
-                        printk (KERN_ERR "JBD: bad block at offset %u\n",
-                                next);
-                        goto failed;
-                }
-
-                bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
-                if (!bh) {
-                        err = -ENOMEM;
-                        goto failed;
-                }
-
-                if (!buffer_uptodate(bh) && !buffer_locked(bh)) {
-                        bufs[nbufs++] = bh;
-                        if (nbufs == MAXBUF) {
-                                ll_rw_block(READ, nbufs, bufs);
-                                journal_brelse_array(bufs, nbufs);
-                                nbufs = 0;
-                        }
-                } else
-                        brelse(bh);
-        }
-
-        if (nbufs)
-                ll_rw_block(READ, nbufs, bufs);
-        err = 0;
-
-failed: 
-        if (nbufs) 
-                journal_brelse_array(bufs, nbufs);
-        return err;
-}
-
-#endif /* __KERNEL__ */
-
-
-/*
- * Read a block from the journal
- */
-
-static int jread(struct buffer_head **bhp, journal_t *journal, 
-                 unsigned int offset)
-{
-        int err;
-        unsigned long blocknr;
-        struct buffer_head *bh;
-
-        *bhp = NULL;
-
-        J_ASSERT (offset < journal->j_maxlen);
-        
-        err = journal_bmap(journal, offset, &blocknr);
-
-        if (err) {
-                printk (KERN_ERR "JBD: bad block at offset %u\n",
-                        offset);
-                return err;
-        }
-
-        bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
-        if (!bh)
-                return -ENOMEM;
-
-        if (!buffer_uptodate(bh)) {
-                /* If this is a brand new buffer, start readahead.
-                   Otherwise, we assume we are already reading it.  */
-                if (!buffer_req(bh))
-                        do_readahead(journal, offset);
-                wait_on_buffer(bh);
-        }
-
-        if (!buffer_uptodate(bh)) {
-                printk (KERN_ERR "JBD: Failed to read block at offset %u\n",
-                        offset);
-                brelse(bh);
-                return -EIO;
-        }
-
-        *bhp = bh;
-        return 0;
-}
-
-
-/*
- * Count the number of in-use tags in a journal descriptor block.
- */
-
-static int count_tags(struct buffer_head *bh, int size)
-{
-        char *                  tagp;
-        journal_block_tag_t *   tag;
-        int                     nr = 0;
-
-        tagp = &bh->b_data[sizeof(journal_header_t)];
-
-        while ((tagp - bh->b_data + sizeof(journal_block_tag_t)) <= size) {
-                tag = (journal_block_tag_t *) tagp;
-
-                nr++;
-                tagp += sizeof(journal_block_tag_t);
-                if (!(tag->t_flags & htonl(JFS_FLAG_SAME_UUID)))
-                        tagp += 16;
-
-                if (tag->t_flags & htonl(JFS_FLAG_LAST_TAG))
-                        break;
-        }
-
-        return nr;
-}
-
-
-/* Make sure we wrap around the log correctly! */
-#define wrap(journal, var)                                              \
-do {                                                                    \
-        if (var >= (journal)->j_last)                                   \
-                var -= ((journal)->j_last - (journal)->j_first);        \
-} while (0)
-
-/**
- * int journal_recover(journal_t *journal) - recovers a on-disk journal
- * @journal: the journal to recover
- *
- * The primary function for recovering the log contents when mounting a
- * journaled device.  
- * 
- * Recovery is done in three passes.  In the first pass, we look for the
- * end of the log.  In the second, we assemble the list of revoke
- * blocks.  In the third and final pass, we replay any un-revoked blocks
- * in the log.  
- */
-int journal_recover(journal_t *journal)
-{
-        int                     err;
-        journal_superblock_t *  sb;
-
-        struct recovery_info    info;
-        
-        memset(&info, 0, sizeof(info));
-        sb = journal->j_superblock;
-        
-        /* 
-         * The journal superblock's s_start field (the current log head)
-         * is always zero if, and only if, the journal was cleanly
-         * unmounted.  
-         */
-
-        if (!sb->s_start) {
-                jbd_debug(1, "No recovery required, last transaction %d\n",
-                          ntohl(sb->s_sequence));
-                journal->j_transaction_sequence = ntohl(sb->s_sequence) + 1;
-                return 0;
-        }
-        
-        err = do_one_pass(journal, &info, PASS_SCAN);
-        if (!err)
-                err = do_one_pass(journal, &info, PASS_REVOKE);
-        if (!err)
-                err = do_one_pass(journal, &info, PASS_REPLAY);
-
-        jbd_debug(0, "JBD: recovery, exit status %d, "
-                  "recovered transactions %u to %u\n",
-                  err, info.start_transaction, info.end_transaction);
-        jbd_debug(0, "JBD: Replayed %d and revoked %d/%d blocks\n", 
-                  info.nr_replays, info.nr_revoke_hits, info.nr_revokes);
-
-        /* Restart the log at the next transaction ID, thus invalidating
-         * any existing commit records in the log. */
-        journal->j_transaction_sequence = ++info.end_transaction;
-                
-        journal_clear_revoke(journal);
-        sync_blockdev(journal->j_fs_dev);
-        return err;
-}
-
-/**
- * int journal_skip_recovery() - Start journal and wipe exiting records
- * @journal: journal to startup
- *
- * Locate any valid recovery information from the journal and set up the
- * journal structures in memory to ignore it (presumably because the
- * caller has evidence that it is out of date).  
- * This function does'nt appear to be exorted..
- *
- * We perform one pass over the journal to allow us to tell the user how
- * much recovery information is being erased, and to let us initialise
- * the journal transaction sequence numbers to the next unused ID. 
- */
-int journal_skip_recovery(journal_t *journal)
-{
-        int                     err;
-        journal_superblock_t *  sb;
-
-        struct recovery_info    info;
-        
-        memset (&info, 0, sizeof(info));
-        sb = journal->j_superblock;
-        
-        err = do_one_pass(journal, &info, PASS_SCAN);
-
-        if (err) {
-                printk(KERN_ERR "JBD: error %d scanning journal\n", err);
-                ++journal->j_transaction_sequence;
-        } else {
-#ifdef __CONFIG_JBD_DEBUG__E2FS
-                int dropped = info.end_transaction - ntohl(sb->s_sequence);
-#endif
-                jbd_debug(0, 
-                          "JBD: ignoring %d transaction%s from the journal.\n",
-                          dropped, (dropped == 1) ? "" : "s");
-                journal->j_transaction_sequence = ++info.end_transaction;
-        }
-
-        journal->j_tail = 0;
-        return err;
-}
-
-static int do_one_pass(journal_t *journal,
-                        struct recovery_info *info, enum passtype pass)
-{
-        unsigned int            first_commit_ID, next_commit_ID;
-        unsigned long           next_log_block;
-        int                     err, success = 0;
-        journal_superblock_t *  sb;
-        journal_header_t *      tmp;
-        struct buffer_head *    bh;
-        unsigned int            sequence;
-        int                     blocktype;
-        
-        /* Precompute the maximum metadata descriptors in a descriptor block */
-        int                     MAX_BLOCKS_PER_DESC;
-        MAX_BLOCKS_PER_DESC = ((journal->j_blocksize-sizeof(journal_header_t))
-                               / sizeof(journal_block_tag_t));
-
-        /* 
-         * First thing is to establish what we expect to find in the log
-         * (in terms of transaction IDs), and where (in terms of log
-         * block offsets): query the superblock.  
-         */
-
-        sb = journal->j_superblock;
-        next_commit_ID = ntohl(sb->s_sequence);
-        next_log_block = ntohl(sb->s_start);
-
-        first_commit_ID = next_commit_ID;
-        if (pass == PASS_SCAN)
-                info->start_transaction = first_commit_ID;
-
-        jbd_debug(1, "Starting recovery pass %d\n", pass);
-
-        /*
-         * Now we walk through the log, transaction by transaction,
-         * making sure that each transaction has a commit block in the
-         * expected place.  Each complete transaction gets replayed back
-         * into the main filesystem. 
-         */
-
-        while (1) {
-                int                     flags;
-                char *                  tagp;
-                journal_block_tag_t *   tag;
-                struct buffer_head *    obh;
-                struct buffer_head *    nbh;
-                
-                /* If we already know where to stop the log traversal,
-                 * check right now that we haven't gone past the end of
-                 * the log. */
-                
-                if (pass != PASS_SCAN)
-                        if (tid_geq(next_commit_ID, info->end_transaction))
-                                break;
-
-                jbd_debug(2, "Scanning for sequence ID %u at %lu/%lu\n",
-                          next_commit_ID, next_log_block, journal->j_last);
-
-                /* Skip over each chunk of the transaction looking
-                 * either the next descriptor block or the final commit
-                 * record. */
-                
-                jbd_debug(3, "JBD: checking block %ld\n", next_log_block);
-                err = jread(&bh, journal, next_log_block);
-                if (err)
-                        goto failed;
-
-                next_log_block++;
-                wrap(journal, next_log_block);
-                
-                /* What kind of buffer is it? 
-                 * 
-                 * If it is a descriptor block, check that it has the
-                 * expected sequence number.  Otherwise, we're all done
-                 * here. */
-
-                tmp = (journal_header_t *)bh->b_data;
-                
-                if (tmp->h_magic != htonl(JFS_MAGIC_NUMBER)) {
-                        brelse(bh);
-                        break;
-                }
-
-                blocktype = ntohl(tmp->h_blocktype);
-                sequence = ntohl(tmp->h_sequence);
-                jbd_debug(3, "Found magic %d, sequence %d\n", 
-                          blocktype, sequence);
-                
-                if (sequence != next_commit_ID) {
-                        brelse(bh);
-                        break;
-                }
-                
-                /* OK, we have a valid descriptor block which matches
-                 * all of the sequence number checks.  What are we going
-                 * to do with it?  That depends on the pass... */
-
-                switch(blocktype) {
-                case JFS_DESCRIPTOR_BLOCK:
-                        /* If it is a valid descriptor block, replay it
-                         * in pass REPLAY; otherwise, just skip over the
-                         * blocks it describes. */
-                        if (pass != PASS_REPLAY) {
-                                next_log_block +=
-                                        count_tags(bh, journal->j_blocksize);
-                                wrap(journal, next_log_block);
-                                brelse(bh);
-                                continue;
-                        }
-
-                        /* A descriptor block: we can now write all of
-                         * the data blocks.  Yay, useful work is finally
-                         * getting done here! */
-
-                        tagp = &bh->b_data[sizeof(journal_header_t)];
-                        while ((tagp - bh->b_data +sizeof(journal_block_tag_t))
-                               <= journal->j_blocksize) {
-                                unsigned long io_block;
-
-                                tag = (journal_block_tag_t *) tagp;
-                                flags = ntohl(tag->t_flags);
-                                
-                                io_block = next_log_block++;
-                                wrap(journal, next_log_block);
-                                err = jread(&obh, journal, io_block);
-                                if (err) {
-                                        /* Recover what we can, but
-                                         * report failure at the end. */
-                                        success = err;
-                                        printk (KERN_ERR 
-                                                "JBD: IO error %d recovering "
-                                                "block %ld in log\n",
-                                                err, io_block);
-                                } else {
-                                        unsigned long blocknr;
-                                        
-                                        J_ASSERT(obh != NULL);
-                                        blocknr = ntohl(tag->t_blocknr);
-
-                                        /* If the block has been
-                                         * revoked, then we're all done
-                                         * here. */
-                                        if (journal_test_revoke
-                                            (journal, blocknr, 
-                                             next_commit_ID)) {
-                                                brelse(obh);
-                                                ++info->nr_revoke_hits;
-                                                goto skip_write;
-                                        }
-                                                                
-                                        /* Find a buffer for the new
-                                         * data being restored */
-                                        nbh = __getblk(journal->j_fs_dev, 
-                                                       blocknr,
-                                                     journal->j_blocksize);
-                                        if (nbh == NULL) {
-                                                printk(KERN_ERR 
-                                                       "JBD: Out of memory "
-                                                       "during recovery.\n");
-                                                err = -ENOMEM;
-                                                brelse(bh);
-                                                brelse(obh);
-                                                goto failed;
-                                        }
-
-                                        lock_buffer(nbh);
-                                        memcpy(nbh->b_data, obh->b_data,
-                                                        journal->j_blocksize);
-                                        if (flags & JFS_FLAG_ESCAPE) {
-                                                *((unsigned int *)bh->b_data) =
-                                                        htonl(JFS_MAGIC_NUMBER);
-                                        }
-
-                                        BUFFER_TRACE(nbh, "marking dirty");
-                                        set_buffer_uptodate(nbh);
-                                        mark_buffer_dirty(nbh);
-                                        BUFFER_TRACE(nbh, "marking uptodate");
-                                        ++info->nr_replays;
-                                        /* ll_rw_block(WRITE, 1, &nbh); */
-                                        unlock_buffer(nbh);
-                                        brelse(obh);
-                                        brelse(nbh);
-                                }
-                                
-                        skip_write:
-                                tagp += sizeof(journal_block_tag_t);
-                                if (!(flags & JFS_FLAG_SAME_UUID))
-                                        tagp += 16;
-
-                                if (flags & JFS_FLAG_LAST_TAG)
-                                        break;
-                        }
-                        
-                        brelse(bh);
-                        continue;
-
-                case JFS_COMMIT_BLOCK:
-                        /* Found an expected commit block: not much to
-                         * do other than move on to the next sequence
-                         * number. */
-                        brelse(bh);
-                        next_commit_ID++;
-                        continue;
-
-                case JFS_REVOKE_BLOCK:
-                        /* If we aren't in the REVOKE pass, then we can
-                         * just skip over this block. */
-                        if (pass != PASS_REVOKE) {
-                                brelse(bh);
-                                continue;
-                        }
-
-                        err = scan_revoke_records(journal, bh,
-                                                  next_commit_ID, info);
-                        brelse(bh);
-                        if (err)
-                                goto failed;
-                        continue;
-
-                default:
-                        jbd_debug(3, "Unrecognised magic %d, end of scan.\n",
-                                  blocktype);
-                        goto done;
-                }
-        }
-
- done:
-        /* 
-         * We broke out of the log scan loop: either we came to the
-         * known end of the log or we found an unexpected block in the
-         * log.  If the latter happened, then we know that the "current"
-         * transaction marks the end of the valid log.
-         */
-        
-        if (pass == PASS_SCAN)
-                info->end_transaction = next_commit_ID;
-        else {
-                /* It's really bad news if different passes end up at
-                 * different places (but possible due to IO errors). */
-                if (info->end_transaction != next_commit_ID) {
-                        printk (KERN_ERR "JBD: recovery pass %d ended at "
-                                "transaction %u, expected %u\n",
-                                pass, next_commit_ID, info->end_transaction);
-                        if (!success)
-                                success = -EIO;
-                }
-        }
-
-        return success;
-
- failed:
-        return err;
-}
-
-
-/* Scan a revoke record, marking all blocks mentioned as revoked. */
-
-static int scan_revoke_records(journal_t *journal, struct buffer_head *bh, 
-                               tid_t sequence, struct recovery_info *info)
-{
-        journal_revoke_header_t *header;
-        int offset, max;
-
-        header = (journal_revoke_header_t *) bh->b_data;
-        offset = sizeof(journal_revoke_header_t);
-        max = ntohl(header->r_count);
-        
-        while (offset < max) {
-                unsigned long blocknr;
-                int err;
-                
-                blocknr = ntohl(* ((unsigned int *) (bh->b_data+offset)));
-                offset += 4;
-                err = journal_set_revoke(journal, blocknr, sequence);
-                if (err)
-                        return err;
-                ++info->nr_revokes;
-        }
-        return 0;
-}
diff --git a/e2fsprogs/e2fsck/region.c b/e2fsprogs/e2fsck/region.c
deleted file mode 100644
index 9ccb684a3..000000000
--- a/e2fsprogs/e2fsck/region.c
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * region.c --- code which manages allocations within a region.
- * 
- * Copyright (C) 2001 Theodore Ts'o.
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- */
-
-#if HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <string.h>
-
-#include "e2fsck.h"
-
-struct region_el {
-        region_addr_t   start;
-        region_addr_t   end;
-        struct region_el *next;
-};
-
-struct region_struct {
-        region_addr_t   min;
-        region_addr_t   max;
-        struct region_el *allocated;
-};
-
-region_t region_create(region_addr_t min, region_addr_t max)
-{
-        region_t        region;
-
-        region = malloc(sizeof(struct region_struct));
-        if (!region)
-                return NULL;
-        memset(region, 0, sizeof(struct region_struct));
-        region->min = min;
-        region->max = max;
-        return region;
-}
-
-void region_free(region_t region)
-{
-        struct region_el        *r, *next;
-
-        for (r = region->allocated; r; r = next) {
-                next = r->next;
-                free(r);
-        }
-        memset(region, 0, sizeof(struct region_struct));
-        free(region);
-}
-
-int region_allocate(region_t region, region_addr_t start, int n)
-{
-        struct region_el        *r, *new_region, *prev, *next;
-        region_addr_t end;
-
-        end = start+n;
-        if ((start < region->min) || (end > region->max))
-                return -1;
-        if (n == 0)
-                return 1;
-
-        /*
-         * Search through the linked list.  If we find that it
-         * conflicts witih something that's already allocated, return
-         * 1; if we can find an existing region which we can grow, do
-         * so.  Otherwise, stop when we find the appropriate place
-         * insert a new region element into the linked list.
-         */
-        for (r = region->allocated, prev=NULL; r; prev = r, r = r->next) {
-                if (((start >= r->start) && (start < r->end)) ||
-                    ((end > r->start) && (end <= r->end)) ||
-                    ((start <= r->start) && (end >= r->end)))
-                        return 1;
-                if (end == r->start) {
-                        r->start = start;
-                        return 0;
-                }
-                if (start == r->end) {
-                        if ((next = r->next)) {
-                                if (end > next->start)
-                                        return 1;
-                                if (end == next->start) {
-                                        r->end = next->end;
-                                        r->next = next->next;
-                                        free(next);
-                                        return 0;
-                                }
-                        }
-                        r->end = end;
-                        return 0;
-                }
-                if (start < r->start)
-                        break;
-        }
-        /*
-         * Insert a new region element structure into the linked list
-         */
-        new_region = malloc(sizeof(struct region_el));
-        if (!new_region)
-                return -1;
-        new_region->start = start;
-        new_region->end = start + n;
-        new_region->next = r;
-        if (prev)
-                prev->next = new_region;
-        else
-                region->allocated = new_region;
-        return 0;
-}
-
-#ifdef TEST_PROGRAM
-#include <stdio.h>
-
-#define BCODE_END       0
-#define BCODE_CREATE    1
-#define BCODE_FREE      2
-#define BCODE_ALLOCATE  3
-#define BCODE_PRINT     4
-
-int bcode_program[] = {
-        BCODE_CREATE, 1, 1001,
-        BCODE_PRINT,
-        BCODE_ALLOCATE, 10, 10,
-        BCODE_ALLOCATE, 30, 10,
-        BCODE_PRINT,
-        BCODE_ALLOCATE, 1, 15,
-        BCODE_ALLOCATE, 15, 8,
-        BCODE_ALLOCATE, 1, 20,
-        BCODE_ALLOCATE, 1, 8,
-        BCODE_PRINT,
-        BCODE_ALLOCATE, 40, 10,
-        BCODE_PRINT,
-        BCODE_ALLOCATE, 22, 5,
-        BCODE_PRINT,
-        BCODE_ALLOCATE, 27, 3,
-        BCODE_PRINT,
-        BCODE_ALLOCATE, 20, 2,
-        BCODE_PRINT,
-        BCODE_ALLOCATE, 49, 1,
-        BCODE_ALLOCATE, 50, 5,
-        BCODE_ALLOCATE, 9, 2,
-        BCODE_ALLOCATE, 9, 1,
-        BCODE_PRINT,
-        BCODE_FREE,
-        BCODE_END
-};
-
-void region_print(region_t region, FILE *f)
-{
-        struct region_el        *r;
-        int     i = 0;
-        
-        fprintf(f, "Printing region (min=%d. max=%d)\n\t", region->min,
-                region->max);
-        for (r = region->allocated; r; r = r->next) {
-                fprintf(f, "(%d, %d)  ", r->start, r->end);
-                if (++i >= 8)
-                        fprintf(f, "\n\t");
-        }
-        fprintf(f, "\n");
-}
-
-int main(int argc, char **argv)
-{
-        region_t        r;
-        int             pc = 0, ret;
-        region_addr_t   start, end, len;
-
-        
-        while (1) {
-                switch (bcode_program[pc++]) {
-                case BCODE_END:
-                        exit(0);
-                case BCODE_CREATE:
-                        start = bcode_program[pc++];
-                        end = bcode_program[pc++];
-                        printf("Creating region with args(%d, %d)\n",
-                               start, end);
-                        r = region_create(start, end);
-                        if (!r) {
-                                fprintf(stderr, "Couldn't create region.\n");
-                                exit(1);
-                        }
-                        break;
-                case BCODE_ALLOCATE:
-                        start = bcode_program[pc++];
-                        end = bcode_program[pc++];
-                        ret = region_allocate(r, start, end);
-                        printf("Region_allocate(%d, %d) returns %d\n",
-                               start, end, ret);
-                        break;
-                case BCODE_PRINT:
-                        region_print(r, stdout);
-                        break;
-                }
-        }
-}
-
-#endif /* TEST_PROGRAM */
diff --git a/e2fsprogs/e2fsck/rehash.c b/e2fsprogs/e2fsck/rehash.c
deleted file mode 100644
index 727e08c2b..000000000
--- a/e2fsprogs/e2fsck/rehash.c
+++ /dev/null
@@ -1,840 +0,0 @@
-/*
- * rehash.c --- rebuild hash tree directories
- * 
- * Copyright (C) 2002 Theodore Ts'o
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- * 
- * This algorithm is designed for simplicity of implementation and to
- * pack the directory as much as possible.  It however requires twice
- * as much memory as the size of the directory.  The maximum size
- * directory supported using a 4k blocksize is roughly a gigabyte, and
- * so there may very well be problems with machines that don't have
- * virtual memory, and obscenely large directories.
- *
- * An alternate algorithm which is much more disk intensive could be
- * written, and probably will need to be written in the future.  The
- * design goals of such an algorithm are: (a) use (roughly) constant
- * amounts of memory, no matter how large the directory, (b) the
- * directory must be safe at all times, even if e2fsck is interrupted
- * in the middle, (c) we must use minimal amounts of extra disk
- * blocks.  This pretty much requires an incremental approach, where
- * we are reading from one part of the directory, and inserting into
- * the front half.  So the algorithm will have to keep track of a
- * moving block boundary between the new tree and the old tree, and
- * files will need to be moved from the old directory and inserted
- * into the new tree.  If the new directory requires space which isn't
- * yet available, blocks from the beginning part of the old directory
- * may need to be moved to the end of the directory to make room for
- * the new tree:
- *
- *    --------------------------------------------------------
- *    |  new tree   |        | old tree                      |
- *    --------------------------------------------------------
- *                  ^ ptr    ^ptr
- *                tail new   head old
- * 
- * This is going to be a pain in the tuckus to implement, and will
- * require a lot more disk accesses.  So I'm going to skip it for now;
- * it's only really going to be an issue for really, really big
- * filesystems (when we reach the level of tens of millions of files
- * in a single directory).  It will probably be easier to simply
- * require that e2fsck use VM first.
- */
-
-#include <string.h>
-#include <ctype.h>
-#include <errno.h>
-#include "e2fsck.h"
-#include "problem.h"
-
-struct fill_dir_struct {
-        char *buf;
-        struct ext2_inode *inode;
-        int err;
-        e2fsck_t ctx;
-        struct hash_entry *harray;
-        int max_array, num_array;
-        int dir_size;
-        int compress;
-        ino_t parent;
-};
-
-struct hash_entry {
-        ext2_dirhash_t  hash;
-        ext2_dirhash_t  minor_hash;
-        struct ext2_dir_entry   *dir;
-};
-
-struct out_dir {
-        int             num;
-        int             max;
-        char            *buf;
-        ext2_dirhash_t  *hashes;
-};
-
-static int fill_dir_block(ext2_filsys fs,
-                          blk_t *block_nr,
-                          e2_blkcnt_t blockcnt,
-                          blk_t ref_block EXT2FS_ATTR((unused)),
-                          int ref_offset EXT2FS_ATTR((unused)),
-                          void *priv_data)
-{
-        struct fill_dir_struct  *fd = (struct fill_dir_struct *) priv_data;
-        struct hash_entry       *new_array, *ent;
-        struct ext2_dir_entry   *dirent;
-        char                    *dir;
-        unsigned int            offset, dir_offset;
-        
-        if (blockcnt < 0)
-                return 0;
-
-        offset = blockcnt * fs->blocksize;
-        if (offset + fs->blocksize > fd->inode->i_size) {
-                fd->err = EXT2_ET_DIR_CORRUPTED;
-                return BLOCK_ABORT;
-        }
-        dir = (fd->buf+offset);
-        if (HOLE_BLKADDR(*block_nr)) {
-                memset(dir, 0, fs->blocksize);
-                dirent = (struct ext2_dir_entry *) dir;
-                dirent->rec_len = fs->blocksize;
-        } else {
-                fd->err = ext2fs_read_dir_block(fs, *block_nr, dir);
-                if (fd->err)
-                        return BLOCK_ABORT;
-        }
-        /* While the directory block is "hot", index it. */
-        dir_offset = 0;
-        while (dir_offset < fs->blocksize) {
-                dirent = (struct ext2_dir_entry *) (dir + dir_offset);
-                if (((dir_offset + dirent->rec_len) > fs->blocksize) ||
-                    (dirent->rec_len < 8) ||
-                    ((dirent->rec_len % 4) != 0) ||
-                    (((dirent->name_len & 0xFF)+8) > dirent->rec_len)) {
-                        fd->err = EXT2_ET_DIR_CORRUPTED;
-                        return BLOCK_ABORT;
-                }
-                dir_offset += dirent->rec_len;
-                if (dirent->inode == 0)
-                        continue;
-                if (!fd->compress && ((dirent->name_len&0xFF) == 1) &&
-                    (dirent->name[0] == '.'))
-                        continue;
-                if (!fd->compress && ((dirent->name_len&0xFF) == 2) &&
-                    (dirent->name[0] == '.') && (dirent->name[1] == '.')) {
-                        fd->parent = dirent->inode;
-                        continue;
-                }
-                if (fd->num_array >= fd->max_array) {
-                        new_array = realloc(fd->harray,
-                            sizeof(struct hash_entry) * (fd->max_array+500));
-                        if (!new_array) {
-                                fd->err = ENOMEM;
-                                return BLOCK_ABORT;
-                        }
-                        fd->harray = new_array;
-                        fd->max_array += 500;
-                }
-                ent = fd->harray + fd->num_array++;
-                ent->dir = dirent;
-                fd->dir_size += EXT2_DIR_REC_LEN(dirent->name_len & 0xFF);
-                if (fd->compress)
-                        ent->hash = ent->minor_hash = 0;
-                else {
-                        fd->err = ext2fs_dirhash(fs->super->s_def_hash_version,
-                                                 dirent->name,
-                                                 dirent->name_len & 0xFF,
-                                                 fs->super->s_hash_seed,
-                                                 &ent->hash, &ent->minor_hash);
-                        if (fd->err)
-                                return BLOCK_ABORT;
-                }
-        }
-        
-        return 0;
-}
-
-/* Used for sorting the hash entry */
-static EXT2_QSORT_TYPE name_cmp(const void *a, const void *b)
-{
-        const struct hash_entry *he_a = (const struct hash_entry *) a;
-        const struct hash_entry *he_b = (const struct hash_entry *) b;
-        int     ret;
-        int     min_len;
-
-        min_len = he_a->dir->name_len;
-        if (min_len > he_b->dir->name_len)
-                min_len = he_b->dir->name_len;
-
-        ret = strncmp(he_a->dir->name, he_b->dir->name, min_len);
-        if (ret == 0) {
-                if (he_a->dir->name_len > he_b->dir->name_len)
-                        ret = 1;
-                else if (he_a->dir->name_len < he_b->dir->name_len)
-                        ret = -1;
-                else
-                        ret = he_b->dir->inode - he_a->dir->inode;
-        }
-        return ret;
-}
-
-/* Used for sorting the hash entry */
-static EXT2_QSORT_TYPE hash_cmp(const void *a, const void *b)
-{
-        const struct hash_entry *he_a = (const struct hash_entry *) a;
-        const struct hash_entry *he_b = (const struct hash_entry *) b;
-        int     ret;
-        
-        if (he_a->hash > he_b->hash)
-                ret = 1;
-        else if (he_a->hash < he_b->hash)
-                ret = -1;
-        else {
-                if (he_a->minor_hash > he_b->minor_hash)
-                        ret = 1;
-                else if (he_a->minor_hash < he_b->minor_hash)
-                        ret = -1;
-                else
-                        ret = name_cmp(a, b);
-        }
-        return ret;
-}
-
-static errcode_t alloc_size_dir(ext2_filsys fs, struct out_dir *outdir, 
-                                int blocks)
-{
-        void                    *new_mem;
-
-        if (outdir->max) {
-                new_mem = realloc(outdir->buf, blocks * fs->blocksize);
-                if (!new_mem)
-                        return ENOMEM;
-                outdir->buf = new_mem;
-                new_mem = realloc(outdir->hashes,
-                                  blocks * sizeof(ext2_dirhash_t));
-                if (!new_mem)
-                        return ENOMEM;
-                outdir->hashes = new_mem;
-        } else {
-                outdir->buf = malloc(blocks * fs->blocksize);
-                outdir->hashes = malloc(blocks * sizeof(ext2_dirhash_t));
-                outdir->num = 0;
-        }
-        outdir->max = blocks;
-        return 0;
-}
-
-static void free_out_dir(struct out_dir *outdir)
-{
-        if (outdir->buf)
-                free(outdir->buf);
-        if (outdir->hashes)
-                free(outdir->hashes);
-        outdir->max = 0;
-        outdir->num =0;
-}
-
-static errcode_t get_next_block(ext2_filsys fs, struct out_dir *outdir,
-                         char ** ret)
-{
-        errcode_t       retval;
-
-        if (outdir->num >= outdir->max) {
-                retval = alloc_size_dir(fs, outdir, outdir->max + 50);
-                if (retval)
-                        return retval;
-        }
-        *ret = outdir->buf + (outdir->num++ * fs->blocksize);
-        memset(*ret, 0, fs->blocksize);
-        return 0;
-}
-
-/*
- * This function is used to make a unique filename.  We do this by
- * appending ~0, and then incrementing the number.  However, we cannot
- * expand the length of the filename beyond the padding available in
- * the directory entry.
- */
-static void mutate_name(char *str, __u16 *len)
-{
-        int     i;
-        __u16   l = *len & 0xFF, h = *len & 0xff00;
-        
-        /*
-         * First check to see if it looks the name has been mutated
-         * already
-         */
-        for (i = l-1; i > 0; i--) {
-                if (!isdigit(str[i]))
-                        break;
-        }
-        if ((i == l-1) || (str[i] != '~')) {
-                if (((l-1) & 3) < 2)
-                        l += 2;
-                else
-                        l = (l+3) & ~3;
-                str[l-2] = '~';
-                str[l-1] = '0';
-                *len = l | h;
-                return;
-        }
-        for (i = l-1; i >= 0; i--) {
-                if (isdigit(str[i])) {
-                        if (str[i] == '9')
-                                str[i] = '0';
-                        else {
-                                str[i]++;
-                                return;
-                        }
-                        continue;
-                }
-                if (i == 1) {
-                        if (str[0] == 'z')
-                                str[0] = 'A';
-                        else if (str[0] == 'Z') {
-                                str[0] = '~';
-                                str[1] = '0';
-                        } else
-                                str[0]++;
-                } else if (i > 0) {
-                        str[i] = '1';
-                        str[i-1] = '~';
-                } else {
-                        if (str[0] == '~')
-                                str[0] = 'a';
-                        else 
-                                str[0]++;
-                }
-                break;
-        }
-}
-
-static int duplicate_search_and_fix(e2fsck_t ctx, ext2_filsys fs,
-                                    ext2_ino_t ino,
-                                    struct fill_dir_struct *fd)
-{
-        struct problem_context  pctx;
-        struct hash_entry       *ent, *prev;
-        int                     i, j;
-        int                     fixed = 0;
-        char                    new_name[256];
-        __u16                   new_len;
-        
-        clear_problem_context(&pctx);
-        pctx.ino = ino;
-
-        for (i=1; i < fd->num_array; i++) {
-                ent = fd->harray + i;
-                prev = ent - 1;
-                if (!ent->dir->inode ||
-                    ((ent->dir->name_len & 0xFF) !=
-                     (prev->dir->name_len & 0xFF)) ||
-                    (strncmp(ent->dir->name, prev->dir->name,
-                             ent->dir->name_len & 0xFF)))
-                        continue;
-                pctx.dirent = ent->dir;
-                if ((ent->dir->inode == prev->dir->inode) &&
-                    fix_problem(ctx, PR_2_DUPLICATE_DIRENT, &pctx)) {
-                        e2fsck_adjust_inode_count(ctx, ent->dir->inode, -1);
-                        ent->dir->inode = 0;
-                        fixed++;
-                        continue;
-                }
-                memcpy(new_name, ent->dir->name, ent->dir->name_len & 0xFF);
-                new_len = ent->dir->name_len;
-                mutate_name(new_name, &new_len);
-                for (j=0; j < fd->num_array; j++) {
-                        if ((i==j) ||
-                            ((ent->dir->name_len & 0xFF) !=
-                             (fd->harray[j].dir->name_len & 0xFF)) ||
-                            (strncmp(new_name, fd->harray[j].dir->name,
-                                     new_len & 0xFF)))
-                                continue;
-                        mutate_name(new_name, &new_len);
-                        
-                        j = -1;
-                }
-                new_name[new_len & 0xFF] = 0;
-                pctx.str = new_name;
-                if (fix_problem(ctx, PR_2_NON_UNIQUE_FILE, &pctx)) {
-                        memcpy(ent->dir->name, new_name, new_len & 0xFF);
-                        ent->dir->name_len = new_len;
-                        ext2fs_dirhash(fs->super->s_def_hash_version,
-                                       ent->dir->name,
-                                       ent->dir->name_len & 0xFF,
-                                       fs->super->s_hash_seed,
-                                       &ent->hash, &ent->minor_hash);
-                        fixed++;
-                }
-        }
-        return fixed;
-}
-
-
-static errcode_t copy_dir_entries(ext2_filsys fs,
-                                  struct fill_dir_struct *fd,
-                                  struct out_dir *outdir)
-{
-        errcode_t               retval;
-        char                    *block_start;
-        struct hash_entry       *ent;
-        struct ext2_dir_entry   *dirent;
-        int                     i, rec_len, left;
-        ext2_dirhash_t          prev_hash;
-        int                     offset;
-        
-        outdir->max = 0;
-        retval = alloc_size_dir(fs, outdir,
-                                (fd->dir_size / fs->blocksize) + 2);
-        if (retval)
-                return retval;
-        outdir->num = fd->compress ? 0 : 1;
-        offset = 0;
-        outdir->hashes[0] = 0;
-        prev_hash = 1;
-        if ((retval = get_next_block(fs, outdir, &block_start)))
-                return retval;
-        dirent = (struct ext2_dir_entry *) block_start;
-        left = fs->blocksize;
-        for (i=0; i < fd->num_array; i++) {
-                ent = fd->harray + i;
-                if (ent->dir->inode == 0)
-                        continue;
-                rec_len = EXT2_DIR_REC_LEN(ent->dir->name_len & 0xFF);
-                if (rec_len > left) {
-                        if (left)
-                                dirent->rec_len += left;
-                        if ((retval = get_next_block(fs, outdir,
-                                                      &block_start)))
-                                return retval;
-                        offset = 0;
-                }
-                left = fs->blocksize - offset;
-                dirent = (struct ext2_dir_entry *) (block_start + offset);
-                if (offset == 0) {
-                        if (ent->hash == prev_hash)
-                                outdir->hashes[outdir->num-1] = ent->hash | 1;
-                        else
-                                outdir->hashes[outdir->num-1] = ent->hash;
-                }
-                dirent->inode = ent->dir->inode;
-                dirent->name_len = ent->dir->name_len;
-                dirent->rec_len = rec_len;
-                memcpy(dirent->name, ent->dir->name, dirent->name_len & 0xFF);
-                offset += rec_len;
-                left -= rec_len;
-                if (left < 12) {
-                        dirent->rec_len += left;
-                        offset += left;
-                        left = 0;
-                }
-                prev_hash = ent->hash;
-        }
-        if (left)
-                dirent->rec_len += left;
-
-        return 0;
-}
-
-
-static struct ext2_dx_root_info *set_root_node(ext2_filsys fs, char *buf,
-                                    ext2_ino_t ino, ext2_ino_t parent)
-{
-        struct ext2_dir_entry           *dir;
-        struct ext2_dx_root_info        *root;
-        struct ext2_dx_countlimit       *limits;
-        int                             filetype = 0;
-
-        if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_FILETYPE)
-                filetype = EXT2_FT_DIR << 8;
-        
-        memset(buf, 0, fs->blocksize);
-        dir = (struct ext2_dir_entry *) buf;
-        dir->inode = ino;
-        dir->name[0] = '.';
-        dir->name_len = 1 | filetype;
-        dir->rec_len = 12;
-        dir = (struct ext2_dir_entry *) (buf + 12);
-        dir->inode = parent;
-        dir->name[0] = '.';
-        dir->name[1] = '.';
-        dir->name_len = 2 | filetype;
-        dir->rec_len = fs->blocksize - 12;
-        
-        root = (struct ext2_dx_root_info *) (buf+24);
-        root->reserved_zero = 0;
-        root->hash_version = fs->super->s_def_hash_version;
-        root->info_length = 8;
-        root->indirect_levels = 0;
-        root->unused_flags = 0;
-
-        limits = (struct ext2_dx_countlimit *) (buf+32);
-        limits->limit = (fs->blocksize - 32) / sizeof(struct ext2_dx_entry);
-        limits->count = 0;
-
-        return root;
-}
-
-
-static struct ext2_dx_entry *set_int_node(ext2_filsys fs, char *buf)
-{
-        struct ext2_dir_entry           *dir;
-        struct ext2_dx_countlimit       *limits;
-
-        memset(buf, 0, fs->blocksize);
-        dir = (struct ext2_dir_entry *) buf;
-        dir->inode = 0;
-        dir->rec_len = fs->blocksize;
-        
-        limits = (struct ext2_dx_countlimit *) (buf+8);
-        limits->limit = (fs->blocksize - 8) / sizeof(struct ext2_dx_entry);
-        limits->count = 0;
-
-        return (struct ext2_dx_entry *) limits;
-}
-
-/*
- * This function takes the leaf nodes which have been written in
- * outdir, and populates the root node and any necessary interior nodes.
- */
-static errcode_t calculate_tree(ext2_filsys fs,
-                                struct out_dir *outdir,
-                                ext2_ino_t ino,
-                                ext2_ino_t parent)
-{
-        struct ext2_dx_root_info        *root_info;
-        struct ext2_dx_entry            *root, *dx_ent = 0;
-        struct ext2_dx_countlimit       *root_limit, *limit;
-        errcode_t                       retval;
-        char                            * block_start;
-        int                             i, c1, c2, nblks;
-        int                             limit_offset, root_offset;
-        
-        root_info = set_root_node(fs, outdir->buf, ino, parent);
-        root_offset = limit_offset = ((char *) root_info - outdir->buf) +
-                root_info->info_length;
-        root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset);
-        c1 = root_limit->limit;
-        nblks = outdir->num;
-
-        /* Write out the pointer blocks */
-        if (nblks-1 <= c1) {
-                /* Just write out the root block, and we're done */
-                root = (struct ext2_dx_entry *) (outdir->buf + root_offset);
-                for (i=1; i < nblks; i++) {
-                        root->block = ext2fs_cpu_to_le32(i);
-                        if (i != 1)
-                                root->hash =
-                                        ext2fs_cpu_to_le32(outdir->hashes[i]);
-                        root++;
-                        c1--;
-                }
-        } else {
-                c2 = 0;
-                limit = 0;
-                root_info->indirect_levels = 1;
-                for (i=1; i < nblks; i++) {
-                        if (c1 == 0)
-                                return ENOSPC;
-                        if (c2 == 0) {
-                                if (limit)
-                                        limit->limit = limit->count = 
-                ext2fs_cpu_to_le16(limit->limit);
-                                root = (struct ext2_dx_entry *)
-                                        (outdir->buf + root_offset);
-                                root->block = ext2fs_cpu_to_le32(outdir->num);
-                                if (i != 1)
-                                        root->hash =
-                        ext2fs_cpu_to_le32(outdir->hashes[i]);
-                                if ((retval =  get_next_block(fs, outdir,
-                                                              &block_start)))
-                                        return retval;
-                                dx_ent = set_int_node(fs, block_start);
-                                limit = (struct ext2_dx_countlimit *) dx_ent;
-                                c2 = limit->limit;
-                                root_offset += sizeof(struct ext2_dx_entry);
-                                c1--;
-                        }
-                        dx_ent->block = ext2fs_cpu_to_le32(i);
-                        if (c2 != limit->limit)
-                                dx_ent->hash =
-                                        ext2fs_cpu_to_le32(outdir->hashes[i]);
-                        dx_ent++;
-                        c2--;
-                }
-                limit->count = ext2fs_cpu_to_le16(limit->limit - c2);
-                limit->limit = ext2fs_cpu_to_le16(limit->limit);
-        }
-        root_limit = (struct ext2_dx_countlimit *) (outdir->buf + limit_offset);
-        root_limit->count = ext2fs_cpu_to_le16(root_limit->limit - c1);
-        root_limit->limit = ext2fs_cpu_to_le16(root_limit->limit);
-
-        return 0;
-}
-
-struct write_dir_struct {
-        struct out_dir *outdir;
-        errcode_t       err;
-        e2fsck_t        ctx;
-        int             cleared;
-};
-
-/*
- * Helper function which writes out a directory block.
- */
-static int write_dir_block(ext2_filsys fs,
-                           blk_t        *block_nr,
-                           e2_blkcnt_t blockcnt,
-                           blk_t ref_block EXT2FS_ATTR((unused)),
-                           int ref_offset EXT2FS_ATTR((unused)), 
-                           void *priv_data)
-{
-        struct write_dir_struct *wd = (struct write_dir_struct *) priv_data;
-        blk_t   blk;
-        char    *dir;
-
-        if (*block_nr == 0)
-                return 0;
-        if (blockcnt >= wd->outdir->num) {
-                e2fsck_read_bitmaps(wd->ctx);
-                blk = *block_nr;
-                ext2fs_unmark_block_bitmap(wd->ctx->block_found_map, blk);
-                ext2fs_block_alloc_stats(fs, blk, -1);
-                *block_nr = 0;
-                wd->cleared++;
-                return BLOCK_CHANGED;
-        }
-        if (blockcnt < 0)
-                return 0;
-
-        dir = wd->outdir->buf + (blockcnt * fs->blocksize);
-        wd->err = ext2fs_write_dir_block(fs, *block_nr, dir);
-        if (wd->err)
-                return BLOCK_ABORT;
-        return 0;
-}
-
-static errcode_t write_directory(e2fsck_t ctx, ext2_filsys fs,
-                                 struct out_dir *outdir,
-                                 ext2_ino_t ino, int compress)
-{
-        struct write_dir_struct wd;
-        errcode_t       retval;
-        struct ext2_inode       inode;
-
-        retval = e2fsck_expand_directory(ctx, ino, -1, outdir->num);
-        if (retval)
-                return retval;
-
-        wd.outdir = outdir;
-        wd.err = 0;
-        wd.ctx = ctx;
-        wd.cleared = 0;
-
-        retval = ext2fs_block_iterate2(fs, ino, 0, 0,
-                                       write_dir_block, &wd);
-        if (retval)
-                return retval;
-        if (wd.err)
-                return wd.err;
-
-        e2fsck_read_inode(ctx, ino, &inode, "rehash_dir");
-        if (compress)
-                inode.i_flags &= ~EXT2_INDEX_FL;
-        else
-                inode.i_flags |= EXT2_INDEX_FL;
-        inode.i_size = outdir->num * fs->blocksize;
-        inode.i_blocks -= (fs->blocksize / 512) * wd.cleared;
-        e2fsck_write_inode(ctx, ino, &inode, "rehash_dir");
-
-        return 0;
-}
-
-errcode_t e2fsck_rehash_dir(e2fsck_t ctx, ext2_ino_t ino)
-{
-        ext2_filsys             fs = ctx->fs;
-        errcode_t               retval;
-        struct ext2_inode       inode;
-        char                    *dir_buf = 0;
-        struct fill_dir_struct  fd;
-        struct out_dir          outdir;
-        
-        outdir.max = outdir.num = 0;
-        outdir.buf = 0;
-        outdir.hashes = 0;
-        e2fsck_read_inode(ctx, ino, &inode, "rehash_dir");
-
-        retval = ENOMEM;
-        fd.harray = 0;
-        dir_buf = malloc(inode.i_size);
-        if (!dir_buf)
-                goto errout;
-
-        fd.max_array = inode.i_size / 32;
-        fd.num_array = 0;
-        fd.harray = malloc(fd.max_array * sizeof(struct hash_entry));
-        if (!fd.harray)
-                goto errout;
-
-        fd.ctx = ctx;
-        fd.buf = dir_buf;
-        fd.inode = &inode;
-        fd.err = 0;
-        fd.dir_size = 0;
-        fd.compress = 0;
-        if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) ||
-            (inode.i_size / fs->blocksize) < 2)
-                fd.compress = 1;
-        fd.parent = 0;
-
-        /* Read in the entire directory into memory */
-        retval = ext2fs_block_iterate2(fs, ino, 0, 0,
-                                       fill_dir_block, &fd);
-        if (fd.err) {
-                retval = fd.err;
-                goto errout;
-        }
-
-#if 0
-        printf("%d entries (%d bytes) found in inode %d\n",
-               fd.num_array, fd.dir_size, ino);
-#endif
-
-        /* Sort the list */
-resort:
-        if (fd.compress)
-                qsort(fd.harray+2, fd.num_array-2,
-                      sizeof(struct hash_entry), name_cmp);
-        else
-                qsort(fd.harray, fd.num_array,
-                      sizeof(struct hash_entry), hash_cmp);
-
-        /*
-         * Look for duplicates
-         */
-        if (duplicate_search_and_fix(ctx, fs, ino, &fd))
-                goto resort;
-
-        if (ctx->options & E2F_OPT_NO) {
-                retval = 0;
-                goto errout;
-        }
-
-        /*
-         * Copy the directory entries.  In a htree directory these
-         * will become the leaf nodes.
-         */
-        retval = copy_dir_entries(fs, &fd, &outdir);
-        if (retval)
-                goto errout;
-        
-        free(dir_buf); dir_buf = 0;
-
-        if (!fd.compress) {
-                /* Calculate the interior nodes */
-                retval = calculate_tree(fs, &outdir, ino, fd.parent);
-                if (retval)
-                        goto errout;
-        }
-        
-        retval = write_directory(ctx, fs, &outdir, ino, fd.compress);
-        if (retval)
-                goto errout;
-
-errout:
-        if (dir_buf)
-                free(dir_buf);
-        if (fd.harray)
-                free(fd.harray);
-
-        free_out_dir(&outdir);
-        return retval;
-}
-
-void e2fsck_rehash_directories(e2fsck_t ctx)
-{
-        struct problem_context  pctx;
-#ifdef RESOURCE_TRACK
-        struct resource_track   rtrack;
-#endif
-        struct dir_info         *dir;
-        ext2_u32_iterate        iter;
-        ext2_ino_t              ino;
-        errcode_t               retval;
-        int                     i, cur, max, all_dirs, dir_index, first = 1;
-
-#ifdef RESOURCE_TRACK
-        init_resource_track(&rtrack);
-#endif
-
-        all_dirs = ctx->options & E2F_OPT_COMPRESS_DIRS;
-
-        if (!ctx->dirs_to_hash && !all_dirs)
-                return;
-
-        e2fsck_get_lost_and_found(ctx, 0);
-                
-        clear_problem_context(&pctx);
-
-        dir_index = ctx->fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX;
-        cur = 0;
-        if (all_dirs) {
-                i = 0;
-                max = e2fsck_get_num_dirinfo(ctx);
-        } else {
-                retval = ext2fs_u32_list_iterate_begin(ctx->dirs_to_hash, 
-                                                       &iter);
-                if (retval) {
-                        pctx.errcode = retval;
-                        fix_problem(ctx, PR_3A_OPTIMIZE_ITER, &pctx);
-                        return;
-                }
-                max = ext2fs_u32_list_count(ctx->dirs_to_hash);
-        }
-        while (1) {
-                if (all_dirs) {
-                        if ((dir = e2fsck_dir_info_iter(ctx, &i)) == 0)
-                                break;
-                        ino = dir->ino;
-                } else {
-                        if (!ext2fs_u32_list_iterate(iter, &ino))
-                                break;
-                }
-                if (ino == ctx->lost_and_found)
-                        continue;
-                pctx.dir = ino;
-                if (first) {
-                        fix_problem(ctx, PR_3A_PASS_HEADER, &pctx);
-                        first = 0;
-                }
-#if 0
-                fix_problem(ctx, PR_3A_OPTIMIZE_DIR, &pctx);
-#endif
-                pctx.errcode = e2fsck_rehash_dir(ctx, ino);
-                if (pctx.errcode) {
-                        end_problem_latch(ctx, PR_LATCH_OPTIMIZE_DIR);
-                        fix_problem(ctx, PR_3A_OPTIMIZE_DIR_ERR, &pctx);
-                }
-                if (ctx->progress && !ctx->progress_fd)
-                        e2fsck_simple_progress(ctx, "Rebuilding directory",
-                               100.0 * (float) (++cur) / (float) max, ino);
-        }
-        end_problem_latch(ctx, PR_LATCH_OPTIMIZE_DIR);
-        if (!all_dirs)
-                ext2fs_u32_list_iterate_end(iter);
-        
-        if (ctx->dirs_to_hash)
-                ext2fs_u32_list_free(ctx->dirs_to_hash);
-        ctx->dirs_to_hash = 0;
-
-#ifdef RESOURCE_TRACK
-        if (ctx->options & E2F_OPT_TIME2) {
-                e2fsck_clear_progbar(ctx);
-                print_resource_track("Pass 3A", &rtrack);
-        }
-#endif
-}
diff --git a/e2fsprogs/e2fsck/revoke.c b/e2fsprogs/e2fsck/revoke.c
deleted file mode 100644
index 388bf5b5d..000000000
--- a/e2fsprogs/e2fsck/revoke.c
+++ /dev/null
@@ -1,640 +0,0 @@
-/*
- * linux/fs/revoke.c
- * 
- * Written by Stephen C. Tweedie <sct@redhat.com>, 2000
- *
- * Copyright 2000 Red Hat corp --- All Rights Reserved
- *
- * This file is part of the Linux kernel and is made available under
- * the terms of the GNU General Public License, version 2, or at your
- * option, any later version, incorporated herein by reference.
- *
- * Journal revoke routines for the generic filesystem journaling code;
- * part of the ext2fs journaling system.
- *
- * Revoke is the mechanism used to prevent old log records for deleted
- * metadata from being replayed on top of newer data using the same
- * blocks.  The revoke mechanism is used in two separate places:
- * 
- * + Commit: during commit we write the entire list of the current
- *   transaction's revoked blocks to the journal
- * 
- * + Recovery: during recovery we record the transaction ID of all
- *   revoked blocks.  If there are multiple revoke records in the log
- *   for a single block, only the last one counts, and if there is a log
- *   entry for a block beyond the last revoke, then that log entry still
- *   gets replayed.
- *
- * We can get interactions between revokes and new log data within a
- * single transaction:
- *
- * Block is revoked and then journaled:
- *   The desired end result is the journaling of the new block, so we 
- *   cancel the revoke before the transaction commits.
- *
- * Block is journaled and then revoked:
- *   The revoke must take precedence over the write of the block, so we
- *   need either to cancel the journal entry or to write the revoke
- *   later in the log than the log block.  In this case, we choose the
- *   latter: journaling a block cancels any revoke record for that block
- *   in the current transaction, so any revoke for that block in the
- *   transaction must have happened after the block was journaled and so
- *   the revoke must take precedence.
- *
- * Block is revoked and then written as data: 
- *   The data write is allowed to succeed, but the revoke is _not_
- *   cancelled.  We still need to prevent old log records from
- *   overwriting the new data.  We don't even need to clear the revoke
- *   bit here.
- *
- * Revoke information on buffers is a tri-state value:
- *
- * RevokeValid clear:   no cached revoke status, need to look it up
- * RevokeValid set, Revoked clear:
- *                      buffer has not been revoked, and cancel_revoke
- *                      need do nothing.
- * RevokeValid set, Revoked set:
- *                      buffer has been revoked.  
- */
-
-#ifndef __KERNEL__
-#include "jfs_user.h"
-#else
-#include <linux/sched.h>
-#include <linux/fs.h>
-#include <linux/jbd.h>
-#include <linux/errno.h>
-#include <linux/slab.h>
-#include <linux/locks.h>
-#include <linux/list.h>
-#include <linux/smp_lock.h>
-#include <linux/init.h>
-#endif
-
-static kmem_cache_t *revoke_record_cache;
-static kmem_cache_t *revoke_table_cache;
-
-/* Each revoke record represents one single revoked block.  During
-   journal replay, this involves recording the transaction ID of the
-   last transaction to revoke this block. */
-
-struct jbd_revoke_record_s 
-{
-        struct list_head  hash;
-        tid_t             sequence;     /* Used for recovery only */
-        unsigned long     blocknr;      
-};
-
-
-/* The revoke table is just a simple hash table of revoke records. */
-struct jbd_revoke_table_s
-{
-        /* It is conceivable that we might want a larger hash table
-         * for recovery.  Must be a power of two. */
-        int               hash_size; 
-        int               hash_shift; 
-        struct list_head *hash_table;
-};
-
-
-#ifdef __KERNEL__
-static void write_one_revoke_record(journal_t *, transaction_t *,
-                                    struct journal_head **, int *,
-                                    struct jbd_revoke_record_s *);
-static void flush_descriptor(journal_t *, struct journal_head *, int);
-#endif
-
-/* Utility functions to maintain the revoke table */
-
-/* Borrowed from buffer.c: this is a tried and tested block hash function */
-static inline int hash(journal_t *journal, unsigned long block)
-{
-        struct jbd_revoke_table_s *table = journal->j_revoke;
-        int hash_shift = table->hash_shift;
-        
-        return ((block << (hash_shift - 6)) ^
-                (block >> 13) ^
-                (block << (hash_shift - 12))) & (table->hash_size - 1);
-}
-
-static int insert_revoke_hash(journal_t *journal, unsigned long blocknr,
-                              tid_t seq)
-{
-        struct list_head *hash_list;
-        struct jbd_revoke_record_s *record;
-
-#ifdef __KERNEL__
-repeat:
-#endif
-        record = kmem_cache_alloc(revoke_record_cache, GFP_NOFS);
-        if (!record)
-                goto oom;
-
-        record->sequence = seq;
-        record->blocknr = blocknr;
-        hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];
-        list_add(&record->hash, hash_list);
-        return 0;
-
-oom:
-#ifdef __KERNEL__
-        if (!journal_oom_retry)
-                return -ENOMEM;
-        jbd_debug(1, "ENOMEM in " __FUNCTION__ ", retrying.\n");
-        current->policy |= SCHED_YIELD;
-        schedule();
-        goto repeat;
-#else
-        return -ENOMEM;
-#endif
-}
-
-/* Find a revoke record in the journal's hash table. */
-
-static struct jbd_revoke_record_s *find_revoke_record(journal_t *journal,
-                                                      unsigned long blocknr)
-{
-        struct list_head *hash_list;
-        struct jbd_revoke_record_s *record;
-        
-        hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];
-
-        record = (struct jbd_revoke_record_s *) hash_list->next;
-        while (&(record->hash) != hash_list) {
-                if (record->blocknr == blocknr)
-                        return record;
-                record = (struct jbd_revoke_record_s *) record->hash.next;
-        }
-        return NULL;
-}
-
-int __init journal_init_revoke_caches(void)
-{
-        revoke_record_cache = kmem_cache_create("revoke_record",
-                                           sizeof(struct jbd_revoke_record_s),
-                                           0, SLAB_HWCACHE_ALIGN, NULL, NULL);
-        if (revoke_record_cache == 0)
-                return -ENOMEM;
-
-        revoke_table_cache = kmem_cache_create("revoke_table",
-                                           sizeof(struct jbd_revoke_table_s),
-                                           0, 0, NULL, NULL);
-        if (revoke_table_cache == 0) {
-                kmem_cache_destroy(revoke_record_cache);
-                revoke_record_cache = NULL;
-                return -ENOMEM;
-        }
-        return 0;
-}       
-
-void journal_destroy_revoke_caches(void)
-{
-        kmem_cache_destroy(revoke_record_cache);
-        revoke_record_cache = 0;
-        kmem_cache_destroy(revoke_table_cache);
-        revoke_table_cache = 0;
-}
-
-/* Initialise the revoke table for a given journal to a given size. */
-
-int journal_init_revoke(journal_t *journal, int hash_size)
-{
-        int shift, tmp;
-        
-        J_ASSERT (journal->j_revoke == NULL);
-        
-        journal->j_revoke = kmem_cache_alloc(revoke_table_cache, GFP_KERNEL);
-        if (!journal->j_revoke)
-                return -ENOMEM;
-        
-        /* Check that the hash_size is a power of two */
-        J_ASSERT ((hash_size & (hash_size-1)) == 0);
-
-        journal->j_revoke->hash_size = hash_size;
-
-        shift = 0;
-        tmp = hash_size;
-        while((tmp >>= 1UL) != 0UL)
-                shift++;
-        journal->j_revoke->hash_shift = shift;
-
-        journal->j_revoke->hash_table =
-                kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL);
-        if (!journal->j_revoke->hash_table) {
-                kmem_cache_free(revoke_table_cache, journal->j_revoke);
-                journal->j_revoke = NULL;
-                return -ENOMEM;
-        }
-        
-        for (tmp = 0; tmp < hash_size; tmp++)
-                INIT_LIST_HEAD(&journal->j_revoke->hash_table[tmp]);
-        
-        return 0;
-}
-
-/* Destoy a journal's revoke table.  The table must already be empty! */
-
-void journal_destroy_revoke(journal_t *journal)
-{
-        struct jbd_revoke_table_s *table;
-        struct list_head *hash_list;
-        int i;
-        
-        table = journal->j_revoke;
-        if (!table)
-                return;
-        
-        for (i=0; i<table->hash_size; i++) {
-                hash_list = &table->hash_table[i];
-                J_ASSERT (list_empty(hash_list));
-        }
-        
-        kfree(table->hash_table);
-        kmem_cache_free(revoke_table_cache, table);
-        journal->j_revoke = NULL;
-}
-
-
-#ifdef __KERNEL__
-
-/* 
- * journal_revoke: revoke a given buffer_head from the journal.  This
- * prevents the block from being replayed during recovery if we take a
- * crash after this current transaction commits.  Any subsequent
- * metadata writes of the buffer in this transaction cancel the
- * revoke.  
- *
- * Note that this call may block --- it is up to the caller to make
- * sure that there are no further calls to journal_write_metadata
- * before the revoke is complete.  In ext3, this implies calling the
- * revoke before clearing the block bitmap when we are deleting
- * metadata. 
- *
- * Revoke performs a journal_forget on any buffer_head passed in as a
- * parameter, but does _not_ forget the buffer_head if the bh was only
- * found implicitly. 
- *
- * bh_in may not be a journalled buffer - it may have come off
- * the hash tables without an attached journal_head.
- *
- * If bh_in is non-zero, journal_revoke() will decrement its b_count
- * by one.
- */
-
-int journal_revoke(handle_t *handle, unsigned long blocknr, 
-                   struct buffer_head *bh_in)
-{
-        struct buffer_head *bh = NULL;
-        journal_t *journal;
-        kdev_t dev;
-        int err;
-
-        if (bh_in)
-                BUFFER_TRACE(bh_in, "enter");
-
-        journal = handle->h_transaction->t_journal;
-        if (!journal_set_features(journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)){
-                J_ASSERT (!"Cannot set revoke feature!");
-                return -EINVAL;
-        }
-
-        dev = journal->j_fs_dev;
-        bh = bh_in;
-
-        if (!bh) {
-                bh = get_hash_table(dev, blocknr, journal->j_blocksize);
-                if (bh)
-                        BUFFER_TRACE(bh, "found on hash");
-        }
-#ifdef JBD_EXPENSIVE_CHECKING
-        else {
-                struct buffer_head *bh2;
-
-                /* If there is a different buffer_head lying around in
-                 * memory anywhere... */
-                bh2 = get_hash_table(dev, blocknr, journal->j_blocksize);
-                if (bh2) {
-                        /* ... and it has RevokeValid status... */
-                        if ((bh2 != bh) &&
-                            test_bit(BH_RevokeValid, &bh2->b_state))
-                                /* ...then it better be revoked too,
-                                 * since it's illegal to create a revoke
-                                 * record against a buffer_head which is
-                                 * not marked revoked --- that would
-                                 * risk missing a subsequent revoke
-                                 * cancel. */
-                                J_ASSERT_BH(bh2, test_bit(BH_Revoked, &
-                                                          bh2->b_state));
-                        __brelse(bh2);
-                }
-        }
-#endif
-
-        /* We really ought not ever to revoke twice in a row without
-           first having the revoke cancelled: it's illegal to free a
-           block twice without allocating it in between! */
-        if (bh) {
-                J_ASSERT_BH(bh, !test_bit(BH_Revoked, &bh->b_state));
-                set_bit(BH_Revoked, &bh->b_state);
-                set_bit(BH_RevokeValid, &bh->b_state);
-                if (bh_in) {
-                        BUFFER_TRACE(bh_in, "call journal_forget");
-                        journal_forget(handle, bh_in);
-                } else {
-                        BUFFER_TRACE(bh, "call brelse");
-                        __brelse(bh);
-                }
-        }
-
-        lock_journal(journal);
-        jbd_debug(2, "insert revoke for block %lu, bh_in=%p\n", blocknr, bh_in);
-        err = insert_revoke_hash(journal, blocknr,
-                                handle->h_transaction->t_tid);
-        unlock_journal(journal);
-        BUFFER_TRACE(bh_in, "exit");
-        return err;
-}
-
-/*
- * Cancel an outstanding revoke.  For use only internally by the
- * journaling code (called from journal_get_write_access).
- *
- * We trust the BH_Revoked bit on the buffer if the buffer is already
- * being journaled: if there is no revoke pending on the buffer, then we
- * don't do anything here.
- *
- * This would break if it were possible for a buffer to be revoked and
- * discarded, and then reallocated within the same transaction.  In such
- * a case we would have lost the revoked bit, but when we arrived here
- * the second time we would still have a pending revoke to cancel.  So,
- * do not trust the Revoked bit on buffers unless RevokeValid is also
- * set.
- *
- * The caller must have the journal locked.
- */
-int journal_cancel_revoke(handle_t *handle, struct journal_head *jh)
-{
-        struct jbd_revoke_record_s *record;
-        journal_t *journal = handle->h_transaction->t_journal;
-        int need_cancel;
-        int did_revoke = 0;     /* akpm: debug */
-        struct buffer_head *bh = jh2bh(jh);
-        
-        jbd_debug(4, "journal_head %p, cancelling revoke\n", jh);
-
-        /* Is the existing Revoke bit valid?  If so, we trust it, and
-         * only perform the full cancel if the revoke bit is set.  If
-         * not, we can't trust the revoke bit, and we need to do the
-         * full search for a revoke record. */
-        if (test_and_set_bit(BH_RevokeValid, &bh->b_state))
-                need_cancel = (test_and_clear_bit(BH_Revoked, &bh->b_state));
-        else {
-                need_cancel = 1;
-                clear_bit(BH_Revoked, &bh->b_state);
-        }
-
-        if (need_cancel) {
-                record = find_revoke_record(journal, bh->b_blocknr);
-                if (record) {
-                        jbd_debug(4, "cancelled existing revoke on "
-                                  "blocknr %lu\n", bh->b_blocknr);
-                        list_del(&record->hash);
-                        kmem_cache_free(revoke_record_cache, record);
-                        did_revoke = 1;
-                }
-        }
-
-#ifdef JBD_EXPENSIVE_CHECKING
-        /* There better not be one left behind by now! */
-        record = find_revoke_record(journal, bh->b_blocknr);
-        J_ASSERT_JH(jh, record == NULL);
-#endif
-
-        /* Finally, have we just cleared revoke on an unhashed
-         * buffer_head?  If so, we'd better make sure we clear the
-         * revoked status on any hashed alias too, otherwise the revoke
-         * state machine will get very upset later on. */
-        if (need_cancel && !bh->b_pprev) {
-                struct buffer_head *bh2;
-                bh2 = get_hash_table(bh->b_dev, bh->b_blocknr, bh->b_size);
-                if (bh2) {
-                        clear_bit(BH_Revoked, &bh2->b_state);
-                        __brelse(bh2);
-                }
-        }
-        
-        return did_revoke;
-}
-
-
-/*
- * Write revoke records to the journal for all entries in the current
- * revoke hash, deleting the entries as we go.
- *
- * Called with the journal lock held.
- */
-
-void journal_write_revoke_records(journal_t *journal, 
-                                  transaction_t *transaction)
-{
-        struct journal_head *descriptor;
-        struct jbd_revoke_record_s *record;
-        struct jbd_revoke_table_s *revoke;
-        struct list_head *hash_list;
-        int i, offset, count;
-
-        descriptor = NULL; 
-        offset = 0;
-        count = 0;
-        revoke = journal->j_revoke;
-        
-        for (i = 0; i < revoke->hash_size; i++) {
-                hash_list = &revoke->hash_table[i];
-
-                while (!list_empty(hash_list)) {
-                        record = (struct jbd_revoke_record_s *) 
-                                hash_list->next;
-                        write_one_revoke_record(journal, transaction,
-                                                &descriptor, &offset, 
-                                                record);
-                        count++;
-                        list_del(&record->hash);
-                        kmem_cache_free(revoke_record_cache, record);
-                }
-        }
-        if (descriptor) 
-                flush_descriptor(journal, descriptor, offset);
-        jbd_debug(1, "Wrote %d revoke records\n", count);
-}
-
-/* 
- * Write out one revoke record.  We need to create a new descriptor
- * block if the old one is full or if we have not already created one.  
- */
-
-static void write_one_revoke_record(journal_t *journal, 
-                                    transaction_t *transaction,
-                                    struct journal_head **descriptorp, 
-                                    int *offsetp,
-                                    struct jbd_revoke_record_s *record)
-{
-        struct journal_head *descriptor;
-        int offset;
-        journal_header_t *header;
-
-        /* If we are already aborting, this all becomes a noop.  We
-           still need to go round the loop in
-           journal_write_revoke_records in order to free all of the
-           revoke records: only the IO to the journal is omitted. */
-        if (is_journal_aborted(journal))
-                return;
-
-        descriptor = *descriptorp;
-        offset = *offsetp;
-
-        /* Make sure we have a descriptor with space left for the record */
-        if (descriptor) {
-                if (offset == journal->j_blocksize) {
-                        flush_descriptor(journal, descriptor, offset);
-                        descriptor = NULL;
-                }
-        }
-        
-        if (!descriptor) {
-                descriptor = journal_get_descriptor_buffer(journal);
-                if (!descriptor)
-                        return;
-                header = (journal_header_t *) &jh2bh(descriptor)->b_data[0];
-                header->h_magic     = htonl(JFS_MAGIC_NUMBER);
-                header->h_blocktype = htonl(JFS_REVOKE_BLOCK);
-                header->h_sequence  = htonl(transaction->t_tid);
-
-                /* Record it so that we can wait for IO completion later */
-                JBUFFER_TRACE(descriptor, "file as BJ_LogCtl");
-                journal_file_buffer(descriptor, transaction, BJ_LogCtl);
-
-                offset = sizeof(journal_revoke_header_t);
-                *descriptorp = descriptor;
-        }
-        
-        * ((unsigned int *)(&jh2bh(descriptor)->b_data[offset])) = 
-                htonl(record->blocknr);
-        offset += 4;
-        *offsetp = offset;
-}
-
-/* 
- * Flush a revoke descriptor out to the journal.  If we are aborting,
- * this is a noop; otherwise we are generating a buffer which needs to
- * be waited for during commit, so it has to go onto the appropriate
- * journal buffer list.
- */
-
-static void flush_descriptor(journal_t *journal, 
-                             struct journal_head *descriptor, 
-                             int offset)
-{
-        journal_revoke_header_t *header;
-
-        if (is_journal_aborted(journal)) {
-                JBUFFER_TRACE(descriptor, "brelse");
-                __brelse(jh2bh(descriptor));
-                return;
-        }
-        
-        header = (journal_revoke_header_t *) jh2bh(descriptor)->b_data;
-        header->r_count = htonl(offset);
-        set_bit(BH_JWrite, &jh2bh(descriptor)->b_state);
-        {
-                struct buffer_head *bh = jh2bh(descriptor);
-                BUFFER_TRACE(bh, "write");
-                ll_rw_block (WRITE, 1, &bh);
-        }
-}
-
-#endif
-
-/* 
- * Revoke support for recovery.
- *
- * Recovery needs to be able to:
- *
- *  record all revoke records, including the tid of the latest instance
- *  of each revoke in the journal
- *
- *  check whether a given block in a given transaction should be replayed
- *  (ie. has not been revoked by a revoke record in that or a subsequent
- *  transaction)
- * 
- *  empty the revoke table after recovery.
- */
-
-/*
- * First, setting revoke records.  We create a new revoke record for
- * every block ever revoked in the log as we scan it for recovery, and
- * we update the existing records if we find multiple revokes for a
- * single block. 
- */
-
-int journal_set_revoke(journal_t *journal, 
-                       unsigned long blocknr, 
-                       tid_t sequence)
-{
-        struct jbd_revoke_record_s *record;
-        
-        record = find_revoke_record(journal, blocknr);
-        if (record) {
-                /* If we have multiple occurences, only record the
-                 * latest sequence number in the hashed record */
-                if (tid_gt(sequence, record->sequence))
-                        record->sequence = sequence;
-                return 0;
-        } 
-        return insert_revoke_hash(journal, blocknr, sequence);
-}
-
-/* 
- * Test revoke records.  For a given block referenced in the log, has
- * that block been revoked?  A revoke record with a given transaction
- * sequence number revokes all blocks in that transaction and earlier
- * ones, but later transactions still need replayed.
- */
-
-int journal_test_revoke(journal_t *journal, 
-                        unsigned long blocknr,
-                        tid_t sequence)
-{
-        struct jbd_revoke_record_s *record;
-        
-        record = find_revoke_record(journal, blocknr);
-        if (!record)
-                return 0;
-        if (tid_gt(sequence, record->sequence))
-                return 0;
-        return 1;
-}
-
-/*
- * Finally, once recovery is over, we need to clear the revoke table so
- * that it can be reused by the running filesystem.
- */
-
-void journal_clear_revoke(journal_t *journal)
-{
-        int i;
-        struct list_head *hash_list;
-        struct jbd_revoke_record_s *record;
-        struct jbd_revoke_table_s *revoke_var;
-        
-        revoke_var = journal->j_revoke;
-        
-        for (i = 0; i < revoke_var->hash_size; i++) {
-                hash_list = &revoke_var->hash_table[i];
-                while (!list_empty(hash_list)) {
-                        record = (struct jbd_revoke_record_s*) hash_list->next;
-                        list_del(&record->hash);
-                        kmem_cache_free(revoke_record_cache, record);
-                }
-        }
-}
-
diff --git a/e2fsprogs/e2fsck/super.c b/e2fsprogs/e2fsck/super.c
deleted file mode 100644
index 294cd80e4..000000000
--- a/e2fsprogs/e2fsck/super.c
+++ /dev/null
@@ -1,713 +0,0 @@
-/*
- * e2fsck.c - superblock checks
- * 
- * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- */
-
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#endif
-
-#ifndef EXT2_SKIP_UUID
-#include "uuid/uuid.h"
-#endif
-#include "e2fsck.h"
-#include "problem.h"
-
-#define MIN_CHECK 1
-#define MAX_CHECK 2
-
-static void check_super_value(e2fsck_t ctx, const char *descr,
-                              unsigned long value, int flags,
-                              unsigned long min_val, unsigned long max_val)
-{
-        struct          problem_context pctx;
-
-        if (((flags & MIN_CHECK) && (value < min_val)) ||
-            ((flags & MAX_CHECK) && (value > max_val))) {
-                clear_problem_context(&pctx);
-                pctx.num = value;
-                pctx.str = descr;
-                fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT; /* never get here! */
-        }
-}
-
-/*
- * This routine may get stubbed out in special compilations of the
- * e2fsck code..
- */
-#ifndef EXT2_SPECIAL_DEVICE_SIZE
-errcode_t e2fsck_get_device_size(e2fsck_t ctx)
-{
-        return (ext2fs_get_device_size(ctx->filesystem_name,
-                                       EXT2_BLOCK_SIZE(ctx->fs->super),
-                                       &ctx->num_blocks));
-}
-#endif
-
-/*
- * helper function to release an inode
- */
-struct process_block_struct {
-        e2fsck_t        ctx;
-        char            *buf;
-        struct problem_context *pctx;
-        int             truncating;
-        int             truncate_offset;
-        e2_blkcnt_t     truncate_block;
-        int             truncated_blocks;
-        int             abort;
-        errcode_t       errcode;
-};
-
-static int release_inode_block(ext2_filsys fs,
-                               blk_t    *block_nr,
-                               e2_blkcnt_t blockcnt,
-                               blk_t    ref_blk EXT2FS_ATTR((unused)),
-                               int      ref_offset EXT2FS_ATTR((unused)),
-                               void *priv_data)
-{
-        struct process_block_struct *pb;
-        e2fsck_t                ctx;
-        struct problem_context  *pctx;
-        blk_t                   blk = *block_nr;
-        int                     retval = 0;
-
-        pb = (struct process_block_struct *) priv_data;
-        ctx = pb->ctx;
-        pctx = pb->pctx;
-
-        pctx->blk = blk;
-        pctx->blkcount = blockcnt;
-
-        if (HOLE_BLKADDR(blk))
-                return 0;
-
-        if ((blk < fs->super->s_first_data_block) ||
-            (blk >= fs->super->s_blocks_count)) {
-                fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, pctx);
-        return_abort:
-                pb->abort = 1;
-                return BLOCK_ABORT;
-        }
-
-        if (!ext2fs_test_block_bitmap(fs->block_map, blk)) {
-                fix_problem(ctx, PR_0_ORPHAN_ALREADY_CLEARED_BLOCK, pctx);
-                goto return_abort;
-        }
-
-        /*
-         * If we are deleting an orphan, then we leave the fields alone.
-         * If we are truncating an orphan, then update the inode fields
-         * and clean up any partial block data.
-         */
-        if (pb->truncating) {
-                /*
-                 * We only remove indirect blocks if they are
-                 * completely empty.
-                 */
-                if (blockcnt < 0) {
-                        int     i, limit;
-                        blk_t   *bp;
-                        
-                        pb->errcode = io_channel_read_blk(fs->io, blk, 1,
-                                                        pb->buf);
-                        if (pb->errcode)
-                                goto return_abort;
-
-                        limit = fs->blocksize >> 2;
-                        for (i = 0, bp = (blk_t *) pb->buf;
-                             i < limit;  i++, bp++)
-                                if (*bp)
-                                        return 0;
-                }
-                /*
-                 * We don't remove direct blocks until we've reached
-                 * the truncation block.
-                 */
-                if (blockcnt >= 0 && blockcnt < pb->truncate_block)
-                        return 0;
-                /*
-                 * If part of the last block needs truncating, we do
-                 * it here.
-                 */
-                if ((blockcnt == pb->truncate_block) && pb->truncate_offset) {
-                        pb->errcode = io_channel_read_blk(fs->io, blk, 1,
-                                                        pb->buf);
-                        if (pb->errcode)
-                                goto return_abort;
-                        memset(pb->buf + pb->truncate_offset, 0,
-                               fs->blocksize - pb->truncate_offset);
-                        pb->errcode = io_channel_write_blk(fs->io, blk, 1,
-                                                         pb->buf);
-                        if (pb->errcode)
-                                goto return_abort;
-                }
-                pb->truncated_blocks++;
-                *block_nr = 0;
-                retval |= BLOCK_CHANGED;
-        }
-        
-        ext2fs_block_alloc_stats(fs, blk, -1);
-        return retval;
-}
-                
-/*
- * This function releases an inode.  Returns 1 if an inconsistency was
- * found.  If the inode has a link count, then it is being truncated and
- * not deleted.
- */
-static int release_inode_blocks(e2fsck_t ctx, ext2_ino_t ino,
-                                struct ext2_inode *inode, char *block_buf,
-                                struct problem_context *pctx)
-{
-        struct process_block_struct     pb;
-        ext2_filsys                     fs = ctx->fs;
-        errcode_t                       retval;
-        __u32                           count;
-
-        if (!ext2fs_inode_has_valid_blocks(inode))
-                return 0;
-
-        pb.buf = block_buf + 3 * ctx->fs->blocksize;
-        pb.ctx = ctx;
-        pb.abort = 0;
-        pb.errcode = 0;
-        pb.pctx = pctx;
-        if (inode->i_links_count) {
-                pb.truncating = 1;
-                pb.truncate_block = (e2_blkcnt_t)
-                        ((((long long)inode->i_size_high << 32) +
-                          inode->i_size + fs->blocksize - 1) /
-                         fs->blocksize);
-                pb.truncate_offset = inode->i_size % fs->blocksize;
-        } else {
-                pb.truncating = 0;
-                pb.truncate_block = 0;
-                pb.truncate_offset = 0;
-        }
-        pb.truncated_blocks = 0;
-        retval = ext2fs_block_iterate2(fs, ino, BLOCK_FLAG_DEPTH_TRAVERSE, 
-                                      block_buf, release_inode_block, &pb);
-        if (retval) {
-                com_err("release_inode_blocks", retval,
-                        _("while calling ext2fs_block_iterate for inode %d"),
-                        ino);
-                return 1;
-        }
-        if (pb.abort)
-                return 1;
-
-        /* Refresh the inode since ext2fs_block_iterate may have changed it */
-        e2fsck_read_inode(ctx, ino, inode, "release_inode_blocks");
-
-        if (pb.truncated_blocks)
-                inode->i_blocks -= pb.truncated_blocks *
-                        (fs->blocksize / 512);
-
-        if (inode->i_file_acl) {
-                retval = ext2fs_adjust_ea_refcount(fs, inode->i_file_acl,
-                                                   block_buf, -1, &count);
-                if (retval == EXT2_ET_BAD_EA_BLOCK_NUM) {
-                        retval = 0;
-                        count = 1;
-                }
-                if (retval) {
-                        com_err("release_inode_blocks", retval,
-                _("while calling ext2fs_adjust_ea_refocunt for inode %d"),
-                                ino);
-                        return 1;
-                }
-                if (count == 0)
-                        ext2fs_block_alloc_stats(fs, inode->i_file_acl, -1);
-                inode->i_file_acl = 0;
-        }
-        return 0;
-}
-
-/*
- * This function releases all of the orphan inodes.  It returns 1 if
- * it hit some error, and 0 on success.
- */
-static int release_orphan_inodes(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        ext2_ino_t      ino, next_ino;
-        struct ext2_inode inode;
-        struct problem_context pctx;
-        char *block_buf;
-
-        if ((ino = fs->super->s_last_orphan) == 0)
-                return 0;
-
-        /*
-         * Win or lose, we won't be using the head of the orphan inode
-         * list again.
-         */
-        fs->super->s_last_orphan = 0;
-        ext2fs_mark_super_dirty(fs);
-
-        /*
-         * If the filesystem contains errors, don't run the orphan
-         * list, since the orphan list can't be trusted; and we're
-         * going to be running a full e2fsck run anyway...
-         */
-        if (fs->super->s_state & EXT2_ERROR_FS)
-                return 0;
-        
-        if ((ino < EXT2_FIRST_INODE(fs->super)) ||
-            (ino > fs->super->s_inodes_count)) {
-                clear_problem_context(&pctx);
-                pctx.ino = ino;
-                fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_HEAD_INODE, &pctx);
-                return 1;
-        }
-
-        block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4,
-                                                    "block iterate buffer");
-        e2fsck_read_bitmaps(ctx);
-        
-        while (ino) {
-                e2fsck_read_inode(ctx, ino, &inode, "release_orphan_inodes");
-                clear_problem_context(&pctx);
-                pctx.ino = ino;
-                pctx.inode = &inode;
-                pctx.str = inode.i_links_count ? _("Truncating") :
-                        _("Clearing");
-
-                fix_problem(ctx, PR_0_ORPHAN_CLEAR_INODE, &pctx);
-
-                next_ino = inode.i_dtime;
-                if (next_ino &&
-                    ((next_ino < EXT2_FIRST_INODE(fs->super)) ||
-                     (next_ino > fs->super->s_inodes_count))) {
-                        pctx.ino = next_ino;
-                        fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_INODE, &pctx);
-                        goto return_abort;
-                }
-
-                if (release_inode_blocks(ctx, ino, &inode, block_buf, &pctx))
-                        goto return_abort;
-
-                if (!inode.i_links_count) {
-                        ext2fs_inode_alloc_stats2(fs, ino, -1,
-                                                  LINUX_S_ISDIR(inode.i_mode));
-                        inode.i_dtime = time(0);
-                } else {
-                        inode.i_dtime = 0;
-                }
-                e2fsck_write_inode(ctx, ino, &inode, "delete_file");
-                ino = next_ino;
-        }
-        ext2fs_free_mem(&block_buf);
-        return 0;
-return_abort:
-        ext2fs_free_mem(&block_buf);
-        return 1;
-}
-
-/*
- * Check the resize inode to make sure it is sane.  We check both for
- * the case where on-line resizing is not enabled (in which case the
- * resize inode should be cleared) as well as the case where on-line
- * resizing is enabled.
- */
-void check_resize_inode(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        struct ext2_inode inode;
-        struct problem_context  pctx;
-        int             i, j, gdt_off, ind_off;
-        blk_t           blk, pblk, expect;
-        __u32           *dind_buf = 0, *ind_buf;
-        errcode_t       retval;
-
-        clear_problem_context(&pctx);
-
-        /* 
-         * If the resize inode feature isn't set, then 
-         * s_reserved_gdt_blocks must be zero.
-         */
-        if (!(fs->super->s_feature_compat & 
-              EXT2_FEATURE_COMPAT_RESIZE_INODE)) {
-                if (fs->super->s_reserved_gdt_blocks) {
-                        pctx.num = fs->super->s_reserved_gdt_blocks;
-                        if (fix_problem(ctx, PR_0_NONZERO_RESERVED_GDT_BLOCKS,
-                                        &pctx)) {
-                                fs->super->s_reserved_gdt_blocks = 0;
-                                ext2fs_mark_super_dirty(fs);
-                        }
-                }
-        }
-
-        /* Read the resizde inode */
-        pctx.ino = EXT2_RESIZE_INO;
-        retval = ext2fs_read_inode(fs, EXT2_RESIZE_INO, &inode);
-        if (retval) {
-                if (fs->super->s_feature_compat & 
-                    EXT2_FEATURE_COMPAT_RESIZE_INODE)
-                        ctx->flags |= E2F_FLAG_RESIZE_INODE;
-                return;
-        }
-
-        /* 
-         * If the resize inode feature isn't set, check to make sure 
-         * the resize inode is cleared; then we're done.
-         */
-        if (!(fs->super->s_feature_compat & 
-              EXT2_FEATURE_COMPAT_RESIZE_INODE)) {
-                for (i=0; i < EXT2_N_BLOCKS; i++) {
-                        if (inode.i_block[i])
-                                break;
-                }
-                if ((i < EXT2_N_BLOCKS) &&
-                    fix_problem(ctx, PR_0_CLEAR_RESIZE_INODE, &pctx)) {
-                        memset(&inode, 0, sizeof(inode));
-                        e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode,
-                                           "clear_resize");
-                }
-                return;
-        }
-
-        /* 
-         * The resize inode feature is enabled; check to make sure the
-         * only block in use is the double indirect block
-         */
-        blk = inode.i_block[EXT2_DIND_BLOCK];
-        for (i=0; i < EXT2_N_BLOCKS; i++) {
-                if (i != EXT2_DIND_BLOCK && inode.i_block[i])
-                        break;
-        }
-        if ((i < EXT2_N_BLOCKS) || !blk || !inode.i_links_count ||
-            !(inode.i_mode & LINUX_S_IFREG) ||
-            (blk < fs->super->s_first_data_block ||
-             blk >= fs->super->s_blocks_count)) {
-        resize_inode_invalid:
-                if (fix_problem(ctx, PR_0_RESIZE_INODE_INVALID, &pctx)) {
-                        memset(&inode, 0, sizeof(inode));
-                        e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode,
-                                           "clear_resize");
-                        ctx->flags |= E2F_FLAG_RESIZE_INODE;
-                }
-                if (!(ctx->options & E2F_OPT_READONLY)) {
-                        fs->super->s_state &= ~EXT2_VALID_FS;
-                        ext2fs_mark_super_dirty(fs);
-                }
-                goto cleanup;
-        }
-        dind_buf = (__u32 *) e2fsck_allocate_memory(ctx, fs->blocksize * 2,
-                                                    "resize dind buffer");
-        ind_buf = (__u32 *) ((char *) dind_buf + fs->blocksize);
-
-        retval = ext2fs_read_ind_block(fs, blk, dind_buf);
-        if (retval)
-                goto resize_inode_invalid;
-
-        gdt_off = fs->desc_blocks;
-        pblk = fs->super->s_first_data_block + 1 + fs->desc_blocks;
-        for (i = 0; i < fs->super->s_reserved_gdt_blocks / 4; 
-             i++, gdt_off++, pblk++) {
-                gdt_off %= fs->blocksize/4;
-                if (dind_buf[gdt_off] != pblk)
-                        goto resize_inode_invalid;
-                retval = ext2fs_read_ind_block(fs, pblk, ind_buf);
-                if (retval) 
-                        goto resize_inode_invalid;
-                ind_off = 0;
-                for (j = 1; j < fs->group_desc_count; j++) {
-                        if (!ext2fs_bg_has_super(fs, j))
-                                continue;
-                        expect = pblk + (j * fs->super->s_blocks_per_group);
-                        if (ind_buf[ind_off] != expect)
-                                goto resize_inode_invalid;
-                        ind_off++;
-                }
-        }
-
-cleanup:
-        if (dind_buf)
-                ext2fs_free_mem(&dind_buf);
-
- }
-
-void check_super_block(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        blk_t   first_block, last_block;
-        struct ext2_super_block *sb = fs->super;
-        struct ext2_group_desc *gd;
-        blk_t   blocks_per_group = fs->super->s_blocks_per_group;
-        blk_t   bpg_max;
-        int     inodes_per_block;
-        int     ipg_max;
-        int     inode_size;
-        dgrp_t  i;
-        blk_t   should_be;
-        struct problem_context  pctx;
-        __u32   free_blocks = 0, free_inodes = 0;
-
-        inodes_per_block = EXT2_INODES_PER_BLOCK(fs->super);
-        ipg_max = inodes_per_block * (blocks_per_group - 4);
-        if (ipg_max > EXT2_MAX_INODES_PER_GROUP(sb))
-                ipg_max = EXT2_MAX_INODES_PER_GROUP(sb);
-        bpg_max = 8 * EXT2_BLOCK_SIZE(sb);
-        if (bpg_max > EXT2_MAX_BLOCKS_PER_GROUP(sb))
-                bpg_max = EXT2_MAX_BLOCKS_PER_GROUP(sb);
-
-        ctx->invalid_inode_bitmap_flag = (int *) e2fsck_allocate_memory(ctx,
-                 sizeof(int) * fs->group_desc_count, "invalid_inode_bitmap");
-        ctx->invalid_block_bitmap_flag = (int *) e2fsck_allocate_memory(ctx,
-                 sizeof(int) * fs->group_desc_count, "invalid_block_bitmap");
-        ctx->invalid_inode_table_flag = (int *) e2fsck_allocate_memory(ctx,
-                sizeof(int) * fs->group_desc_count, "invalid_inode_table");
-
-        clear_problem_context(&pctx);
-
-        /*
-         * Verify the super block constants...
-         */
-        check_super_value(ctx, "inodes_count", sb->s_inodes_count,
-                          MIN_CHECK, 1, 0);
-        check_super_value(ctx, "blocks_count", sb->s_blocks_count,
-                          MIN_CHECK, 1, 0);
-        check_super_value(ctx, "first_data_block", sb->s_first_data_block,
-                          MAX_CHECK, 0, sb->s_blocks_count);
-        check_super_value(ctx, "log_block_size", sb->s_log_block_size,
-                          MIN_CHECK | MAX_CHECK, 0,
-                          EXT2_MAX_BLOCK_LOG_SIZE - EXT2_MIN_BLOCK_LOG_SIZE);
-        check_super_value(ctx, "log_frag_size", sb->s_log_frag_size,
-                          MIN_CHECK | MAX_CHECK, 0, sb->s_log_block_size);
-        check_super_value(ctx, "frags_per_group", sb->s_frags_per_group,
-                          MIN_CHECK | MAX_CHECK, sb->s_blocks_per_group,
-                          bpg_max);
-        check_super_value(ctx, "blocks_per_group", sb->s_blocks_per_group,
-                          MIN_CHECK | MAX_CHECK, 8, bpg_max);
-        check_super_value(ctx, "inodes_per_group", sb->s_inodes_per_group,
-                          MIN_CHECK | MAX_CHECK, inodes_per_block, ipg_max);
-        check_super_value(ctx, "r_blocks_count", sb->s_r_blocks_count,
-                          MAX_CHECK, 0, sb->s_blocks_count / 2);
-        check_super_value(ctx, "reserved_gdt_blocks", 
-                          sb->s_reserved_gdt_blocks, MAX_CHECK, 0,
-                          fs->blocksize/4);
-        inode_size = EXT2_INODE_SIZE(sb);
-        check_super_value(ctx, "inode_size",
-                          inode_size, MIN_CHECK | MAX_CHECK,
-                          EXT2_GOOD_OLD_INODE_SIZE, fs->blocksize);
-        if (inode_size & (inode_size - 1)) {
-                pctx.num = inode_size;
-                pctx.str = "inode_size";
-                fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT; /* never get here! */
-                return;
-        }
-                
-        if (!ctx->num_blocks) {
-                pctx.errcode = e2fsck_get_device_size(ctx);
-                if (pctx.errcode && pctx.errcode != EXT2_ET_UNIMPLEMENTED) {
-                        fix_problem(ctx, PR_0_GETSIZE_ERROR, &pctx);
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return;
-                }
-                if ((pctx.errcode != EXT2_ET_UNIMPLEMENTED) &&
-                    (ctx->num_blocks < sb->s_blocks_count)) {
-                        pctx.blk = sb->s_blocks_count;
-                        pctx.blk2 = ctx->num_blocks;
-                        if (fix_problem(ctx, PR_0_FS_SIZE_WRONG, &pctx)) {
-                                ctx->flags |= E2F_FLAG_ABORT;
-                                return;
-                        }
-                }
-        }
-
-        if (sb->s_log_block_size != (__u32) sb->s_log_frag_size) {
-                pctx.blk = EXT2_BLOCK_SIZE(sb);
-                pctx.blk2 = EXT2_FRAG_SIZE(sb);
-                fix_problem(ctx, PR_0_NO_FRAGMENTS, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-
-        should_be = sb->s_frags_per_group >>
-                (sb->s_log_block_size - sb->s_log_frag_size);           
-        if (sb->s_blocks_per_group != should_be) {
-                pctx.blk = sb->s_blocks_per_group;
-                pctx.blk2 = should_be;
-                fix_problem(ctx, PR_0_BLOCKS_PER_GROUP, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-
-        should_be = (sb->s_log_block_size == 0) ? 1 : 0;
-        if (sb->s_first_data_block != should_be) {
-                pctx.blk = sb->s_first_data_block;
-                pctx.blk2 = should_be;
-                fix_problem(ctx, PR_0_FIRST_DATA_BLOCK, &pctx);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-
-        should_be = sb->s_inodes_per_group * fs->group_desc_count;
-        if (sb->s_inodes_count != should_be) {
-                pctx.ino = sb->s_inodes_count;
-                pctx.ino2 = should_be;
-                if (fix_problem(ctx, PR_0_INODE_COUNT_WRONG, &pctx)) {
-                        sb->s_inodes_count = should_be;
-                        ext2fs_mark_super_dirty(fs);
-                }
-        }
-
-        /*
-         * Verify the group descriptors....
-         */
-        first_block =  sb->s_first_data_block;
-        last_block = first_block + blocks_per_group;
-
-        for (i = 0, gd=fs->group_desc; i < fs->group_desc_count; i++, gd++) {
-                pctx.group = i;
-                
-                if (i == fs->group_desc_count - 1)
-                        last_block = sb->s_blocks_count;
-                if ((gd->bg_block_bitmap < first_block) ||
-                    (gd->bg_block_bitmap >= last_block)) {
-                        pctx.blk = gd->bg_block_bitmap;
-                        if (fix_problem(ctx, PR_0_BB_NOT_GROUP, &pctx))
-                                gd->bg_block_bitmap = 0;
-                }
-                if (gd->bg_block_bitmap == 0) {
-                        ctx->invalid_block_bitmap_flag[i]++;
-                        ctx->invalid_bitmaps++;
-                }
-                if ((gd->bg_inode_bitmap < first_block) ||
-                    (gd->bg_inode_bitmap >= last_block)) {
-                        pctx.blk = gd->bg_inode_bitmap;
-                        if (fix_problem(ctx, PR_0_IB_NOT_GROUP, &pctx))
-                                gd->bg_inode_bitmap = 0;
-                }
-                if (gd->bg_inode_bitmap == 0) {
-                        ctx->invalid_inode_bitmap_flag[i]++;
-                        ctx->invalid_bitmaps++;
-                }
-                if ((gd->bg_inode_table < first_block) ||
-                    ((gd->bg_inode_table +
-                      fs->inode_blocks_per_group - 1) >= last_block)) {
-                        pctx.blk = gd->bg_inode_table;
-                        if (fix_problem(ctx, PR_0_ITABLE_NOT_GROUP, &pctx))
-                                gd->bg_inode_table = 0;
-                }
-                if (gd->bg_inode_table == 0) {
-                        ctx->invalid_inode_table_flag[i]++;
-                        ctx->invalid_bitmaps++;
-                }
-                free_blocks += gd->bg_free_blocks_count;
-                free_inodes += gd->bg_free_inodes_count;
-                first_block += sb->s_blocks_per_group;
-                last_block += sb->s_blocks_per_group;
-
-                if ((gd->bg_free_blocks_count > sb->s_blocks_per_group) ||
-                    (gd->bg_free_inodes_count > sb->s_inodes_per_group) ||
-                    (gd->bg_used_dirs_count > sb->s_inodes_per_group))
-                        ext2fs_unmark_valid(fs);
-
-        }
-
-        /*
-         * Update the global counts from the block group counts.  This
-         * is needed for an experimental patch which eliminates
-         * locking the entire filesystem when allocating blocks or
-         * inodes; if the filesystem is not unmounted cleanly, the
-         * global counts may not be accurate.
-         */
-        if ((free_blocks != sb->s_free_blocks_count) ||
-            (free_inodes != sb->s_free_inodes_count)) {
-                if (ctx->options & E2F_OPT_READONLY)
-                        ext2fs_unmark_valid(fs);
-                else {
-                        sb->s_free_blocks_count = free_blocks;
-                        sb->s_free_inodes_count = free_inodes;
-                        ext2fs_mark_super_dirty(fs);
-                }
-        }
-        
-        if ((sb->s_free_blocks_count > sb->s_blocks_count) ||
-            (sb->s_free_inodes_count > sb->s_inodes_count))
-                ext2fs_unmark_valid(fs);
-
-
-        /*
-         * If we have invalid bitmaps, set the error state of the
-         * filesystem.
-         */
-        if (ctx->invalid_bitmaps && !(ctx->options & E2F_OPT_READONLY)) {
-                sb->s_state &= ~EXT2_VALID_FS;
-                ext2fs_mark_super_dirty(fs);
-        }
-
-        clear_problem_context(&pctx);
-        
-#ifndef EXT2_SKIP_UUID
-        /*
-         * If the UUID field isn't assigned, assign it.
-         */
-        if (!(ctx->options & E2F_OPT_READONLY) && uuid_is_null(sb->s_uuid)) {
-                if (fix_problem(ctx, PR_0_ADD_UUID, &pctx)) {
-                        uuid_generate(sb->s_uuid);
-                        ext2fs_mark_super_dirty(fs);
-                        fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
-                }
-        }
-#endif
-
-        /*
-         * For the Hurd, check to see if the filetype option is set,
-         * since it doesn't support it.
-         */
-        if (!(ctx->options & E2F_OPT_READONLY) &&
-            fs->super->s_creator_os == EXT2_OS_HURD &&
-            (fs->super->s_feature_incompat &
-             EXT2_FEATURE_INCOMPAT_FILETYPE)) {
-                if (fix_problem(ctx, PR_0_HURD_CLEAR_FILETYPE, &pctx)) {
-                        fs->super->s_feature_incompat &=
-                                ~EXT2_FEATURE_INCOMPAT_FILETYPE;
-                        ext2fs_mark_super_dirty(fs);
-
-                }
-        }
-
-        /*
-         * If we have any of the compatibility flags set, we need to have a
-         * revision 1 filesystem.  Most kernels will not check the flags on
-         * a rev 0 filesystem and we may have corruption issues because of
-         * the incompatible changes to the filesystem.
-         */
-        if (!(ctx->options & E2F_OPT_READONLY) &&
-            fs->super->s_rev_level == EXT2_GOOD_OLD_REV &&
-            (fs->super->s_feature_compat ||
-             fs->super->s_feature_ro_compat ||
-             fs->super->s_feature_incompat) &&
-            fix_problem(ctx, PR_0_FS_REV_LEVEL, &pctx)) {
-                ext2fs_update_dynamic_rev(fs);
-                ext2fs_mark_super_dirty(fs);
-        }
-
-        check_resize_inode(ctx);
-
-        /*
-         * Clean up any orphan inodes, if present.
-         */
-        if (!(ctx->options & E2F_OPT_READONLY) && release_orphan_inodes(ctx)) {
-                fs->super->s_state &= ~EXT2_VALID_FS;
-                ext2fs_mark_super_dirty(fs);
-        }
-
-        /*
-         * Move the ext3 journal file, if necessary.
-         */
-        e2fsck_move_ext3_journal(ctx);
-        return;
-}
diff --git a/e2fsprogs/e2fsck/swapfs.c b/e2fsprogs/e2fsck/swapfs.c
deleted file mode 100644
index a737b9624..000000000
--- a/e2fsprogs/e2fsck/swapfs.c
+++ /dev/null
@@ -1,268 +0,0 @@
-/*
- * swapfs.c --- byte-swap an ext2 filesystem
- *
- * Copyright 1996, 1997 by Theodore Ts'o
- * 
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- * 
- */
-
-#ifdef HAVE_ERRNO_H
-#include <errno.h>
-#endif
-#include "e2fsck.h"
-
-#ifdef ENABLE_SWAPFS
-
-struct swap_block_struct {
-        ext2_ino_t      ino;
-        int             isdir;
-        errcode_t       errcode;
-        char            *dir_buf;
-        struct ext2_inode *inode;
-};
-
-/*
- * This is a helper function for block_iterate.  We mark all of the
- * indirect and direct blocks as changed, so that block_iterate will
- * write them out.
- */
-static int swap_block(ext2_filsys fs, blk_t *block_nr, int blockcnt,
-                      void *priv_data)
-{
-        errcode_t       retval;
-        
-        struct swap_block_struct *sb = (struct swap_block_struct *) priv_data;
-
-        if (sb->isdir && (blockcnt >= 0) && *block_nr) {
-                retval = ext2fs_read_dir_block(fs, *block_nr, sb->dir_buf);
-                if (retval) {
-                        sb->errcode = retval;
-                        return BLOCK_ABORT;
-                }
-                retval = ext2fs_write_dir_block(fs, *block_nr, sb->dir_buf);
-                if (retval) {
-                        sb->errcode = retval;
-                        return BLOCK_ABORT;
-                }
-        }
-        if (blockcnt >= 0) {
-                if (blockcnt < EXT2_NDIR_BLOCKS)
-                        return 0;
-                return BLOCK_CHANGED;
-        }
-        if (blockcnt == BLOCK_COUNT_IND) {
-                if (*block_nr == sb->inode->i_block[EXT2_IND_BLOCK])
-                        return 0;
-                return BLOCK_CHANGED;
-        }
-        if (blockcnt == BLOCK_COUNT_DIND) {
-                if (*block_nr == sb->inode->i_block[EXT2_DIND_BLOCK])
-                        return 0;
-                return BLOCK_CHANGED;
-        }
-        if (blockcnt == BLOCK_COUNT_TIND) {
-                if (*block_nr == sb->inode->i_block[EXT2_TIND_BLOCK])
-                        return 0;
-                return BLOCK_CHANGED;
-        }
-        return BLOCK_CHANGED;
-}
-
-/*
- * This function is responsible for byte-swapping all of the indirect,
- * block pointers.  It is also responsible for byte-swapping directories.
- */
-static void swap_inode_blocks(e2fsck_t ctx, ext2_ino_t ino, char *block_buf,
-                              struct ext2_inode *inode)
-{
-        errcode_t                       retval;
-        struct swap_block_struct        sb;
-
-        sb.ino = ino;
-        sb.inode = inode;
-        sb.dir_buf = block_buf + ctx->fs->blocksize*3;
-        sb.errcode = 0;
-        sb.isdir = 0;
-        if (LINUX_S_ISDIR(inode->i_mode))
-                sb.isdir = 1;
-
-        retval = ext2fs_block_iterate(ctx->fs, ino, 0, block_buf,
-                                      swap_block, &sb);
-        if (retval) {
-                com_err("swap_inode_blocks", retval,
-                        _("while calling ext2fs_block_iterate"));
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        if (sb.errcode) {
-                com_err("swap_inode_blocks", sb.errcode,
-                        _("while calling iterator function"));
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-}
-
-static void swap_inodes(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        dgrp_t                  group;
-        unsigned int            i;
-        ext2_ino_t              ino = 1;
-        char                    *buf, *block_buf;
-        errcode_t               retval;
-        struct ext2_inode *     inode;
-
-        e2fsck_use_inode_shortcuts(ctx, 1);
-        
-        retval = ext2fs_get_mem(fs->blocksize * fs->inode_blocks_per_group,
-                                &buf);
-        if (retval) {
-                com_err("swap_inodes", retval,
-                        _("while allocating inode buffer"));
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4,
-                                                    "block interate buffer");
-        for (group = 0; group < fs->group_desc_count; group++) {
-                retval = io_channel_read_blk(fs->io,
-                      fs->group_desc[group].bg_inode_table,
-                      fs->inode_blocks_per_group, buf);
-                if (retval) {
-                        com_err("swap_inodes", retval,
-                                _("while reading inode table (group %d)"),
-                                group);
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return;
-                }
-                inode = (struct ext2_inode *) buf;
-                for (i=0; i < fs->super->s_inodes_per_group;
-                     i++, ino++, inode++) {
-                        ctx->stashed_ino = ino;
-                        ctx->stashed_inode = inode;
-                        
-                        if (fs->flags & EXT2_FLAG_SWAP_BYTES_READ)
-                                ext2fs_swap_inode(fs, inode, inode, 0);
-                        
-                        /*
-                         * Skip deleted files.
-                         */
-                        if (inode->i_links_count == 0)
-                                continue;
-                        
-                        if (LINUX_S_ISDIR(inode->i_mode) ||
-                            ((inode->i_block[EXT2_IND_BLOCK] ||
-                              inode->i_block[EXT2_DIND_BLOCK] ||
-                              inode->i_block[EXT2_TIND_BLOCK]) &&
-                             ext2fs_inode_has_valid_blocks(inode)))
-                                swap_inode_blocks(ctx, ino, block_buf, inode);
-
-                        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                                return;
-                        
-                        if (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE)
-                                ext2fs_swap_inode(fs, inode, inode, 1);
-                }
-                retval = io_channel_write_blk(fs->io,
-                      fs->group_desc[group].bg_inode_table,
-                      fs->inode_blocks_per_group, buf);
-                if (retval) {
-                        com_err("swap_inodes", retval,
-                                _("while writing inode table (group %d)"),
-                                group);
-                        ctx->flags |= E2F_FLAG_ABORT;
-                        return;
-                }
-        }
-        ext2fs_free_mem(&buf);
-        ext2fs_free_mem(&block_buf);
-        e2fsck_use_inode_shortcuts(ctx, 0);
-        ext2fs_flush_icache(fs);
-}
-
-#if defined(__powerpc__) && defined(EXT2FS_ENABLE_SWAPFS)
-/*
- * On the PowerPC, the big-endian variant of the ext2 filesystem
- * has its bitmaps stored as 32-bit words with bit 0 as the LSB
- * of each word.  Thus a bitmap with only bit 0 set would be, as
- * a string of bytes, 00 00 00 01 00 ...
- * To cope with this, we byte-reverse each word of a bitmap if
- * we have a big-endian filesystem, that is, if we are *not*
- * byte-swapping other word-sized numbers.
- */
-#define EXT2_BIG_ENDIAN_BITMAPS
-#endif
-
-#ifdef EXT2_BIG_ENDIAN_BITMAPS
-static void ext2fs_swap_bitmap(ext2fs_generic_bitmap bmap)
-{
-        __u32 *p = (__u32 *) bmap->bitmap;
-        int n, nbytes = (bmap->end - bmap->start + 7) / 8;
-                
-        for (n = nbytes / sizeof(__u32); n > 0; --n, ++p)
-                *p = ext2fs_swab32(*p);
-}
-#endif
-
-
-void swap_filesys(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-#ifdef RESOURCE_TRACK
-        struct resource_track   rtrack;
-
-        init_resource_track(&rtrack);
-#endif
-
-        if (!(ctx->options & E2F_OPT_PREEN))
-                printf(_("Pass 0: Doing byte-swap of filesystem\n"));
-        
-#ifdef MTRACE
-        mtrace_print("Byte swap");
-#endif
-
-        if (fs->super->s_mnt_count) {
-                fprintf(stderr, _("%s: the filesystem must be freshly "
-                        "checked using fsck\n"
-                        "and not mounted before trying to "
-                        "byte-swap it.\n"), ctx->device_name);
-                ctx->flags |= E2F_FLAG_ABORT;
-                return;
-        }
-        if (fs->flags & EXT2_FLAG_SWAP_BYTES) {
-                fs->flags &= ~(EXT2_FLAG_SWAP_BYTES|
-                               EXT2_FLAG_SWAP_BYTES_WRITE);
-                fs->flags |= EXT2_FLAG_SWAP_BYTES_READ;
-        } else {
-                fs->flags &= ~EXT2_FLAG_SWAP_BYTES_READ;
-                fs->flags |= EXT2_FLAG_SWAP_BYTES_WRITE;
-        }
-        swap_inodes(ctx);
-        if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
-                return;
-        if (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE)
-                fs->flags |= EXT2_FLAG_SWAP_BYTES;
-        fs->flags &= ~(EXT2_FLAG_SWAP_BYTES_READ|
-                       EXT2_FLAG_SWAP_BYTES_WRITE);
-
-#ifdef EXT2_BIG_ENDIAN_BITMAPS
-        e2fsck_read_bitmaps(ctx);
-        ext2fs_swap_bitmap(fs->inode_map);
-        ext2fs_swap_bitmap(fs->block_map);
-        fs->flags |= EXT2_FLAG_BB_DIRTY | EXT2_FLAG_IB_DIRTY;
-#endif
-        fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
-        ext2fs_flush(fs);
-        fs->flags |= EXT2_FLAG_MASTER_SB_ONLY;
-        
-#ifdef RESOURCE_TRACK
-        if (ctx->options & E2F_OPT_TIME2)
-                print_resource_track(_("Byte swap"), &rtrack);
-#endif
-}
-
-#endif
diff --git a/e2fsprogs/e2fsck/util.c b/e2fsprogs/e2fsck/util.c
deleted file mode 100644
index 311156e23..000000000
--- a/e2fsprogs/e2fsck/util.c
+++ /dev/null
@@ -1,503 +0,0 @@
-/*
- * util.c --- miscellaneous utilities
- * 
- * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
- *
- * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
- * %End-Header%
- */
-
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <ctype.h>
-
-#ifdef HAVE_CONIO_H
-#undef HAVE_TERMIOS_H
-#include <conio.h>
-#define read_a_char()   getch()
-#else
-#ifdef HAVE_TERMIOS_H
-#include <termios.h>
-#endif
-#include <stdio.h>
-#endif
-
-#ifdef HAVE_MALLOC_H
-#include <malloc.h>
-#endif
-
-#include "e2fsck.h"
-
-extern e2fsck_t e2fsck_global_ctx;   /* Try your very best not to use this! */
-
-#include <sys/time.h>
-#include <sys/resource.h>
-
-#if 0
-void fatal_error(e2fsck_t ctx, const char *msg)
-{
-        if (msg) 
-                fprintf (stderr, "e2fsck: %s\n", msg);
-        if (ctx->fs && ctx->fs->io) {
-                if (ctx->fs->io->magic == EXT2_ET_MAGIC_IO_CHANNEL)
-                        io_channel_flush(ctx->fs->io);
-                else
-                        fprintf(stderr, "e2fsck: io manager magic bad!\n");
-        }
-        ctx->flags |= E2F_FLAG_ABORT;
-        if (ctx->flags & E2F_FLAG_SETJMP_OK)
-                longjmp(ctx->abort_loc, 1);
-        exit(FSCK_ERROR);
-}
-#endif
-
-void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size,
-                             const char *description)
-{
-        void *ret;
-        char buf[256];
-
-#ifdef DEBUG_ALLOCATE_MEMORY
-        printf("Allocating %d bytes for %s...\n", size, description);
-#endif
-        ret = malloc(size);
-        if (!ret) {
-                sprintf(buf, "Can't allocate %s\n", description);
-                fatal_error(ctx, buf);
-        }
-        memset(ret, 0, size);
-        return ret;
-}
-
-char *string_copy(e2fsck_t ctx EXT2FS_ATTR((unused)), 
-                  const char *str, int len)
-{
-        char    *ret;
-        
-        if (!str)
-                return NULL;
-        if (!len)
-                len = strlen(str);
-        ret = malloc(len+1);
-        if (ret) {
-                strncpy(ret, str, len);
-                ret[len] = 0;
-        }
-        return ret;
-}
-
-#ifndef HAVE_STRNLEN
-/*
- * Incredibly, libc5 doesn't appear to have strnlen.  So we have to
- * provide our own.
- */
-int e2fsck_strnlen(const char * s, int count)
-{
-        const char *cp = s;
-
-        while (count-- && *cp)
-                cp++;
-        return cp - s;
-}
-#endif
-
-#ifndef HAVE_CONIO_H
-static int read_a_char(void)
-{
-        char    c;
-        int     r;
-        int     fail = 0;
-
-        while(1) {
-                if (e2fsck_global_ctx &&
-                    (e2fsck_global_ctx->flags & E2F_FLAG_CANCEL)) {
-                        return 3;
-                }
-                r = read(0, &c, 1);
-                if (r == 1)
-                        return c;
-                if (fail++ > 100)
-                        break;
-        }
-        return EOF;
-}
-#endif
-
-int ask_yn(const char * string, int def)
-{
-        int             c;
-        const char      *defstr;
-        const char      *short_yes = _("yY");
-        const char      *short_no = _("nN");
-
-#ifdef HAVE_TERMIOS_H
-        struct termios  termios, tmp;
-
-        tcgetattr (0, &termios);
-        tmp = termios;
-        tmp.c_lflag &= ~(ICANON | ECHO);
-        tmp.c_cc[VMIN] = 1;
-        tmp.c_cc[VTIME] = 0;
-        tcsetattr (0, TCSANOW, &tmp);
-#endif
-
-        if (def == 1)
-                defstr = _(_("<y>"));
-        else if (def == 0)
-                defstr = _(_("<n>"));
-        else
-                defstr = _(" (y/n)");
-        printf("%s%s? ", string, defstr);
-        while (1) {
-                fflush (stdout);
-                if ((c = read_a_char()) == EOF)
-                        break;
-                if (c == 3) {
-#ifdef HAVE_TERMIOS_H
-                        tcsetattr (0, TCSANOW, &termios);
-#endif
-                        if (e2fsck_global_ctx &&
-                            e2fsck_global_ctx->flags & E2F_FLAG_SETJMP_OK) {
-                                puts("\n");
-                                longjmp(e2fsck_global_ctx->abort_loc, 1);
-                        }
-                        puts(_("cancelled!\n"));
-                        return 0;
-                }
-                if (strchr(short_yes, (char) c)) {
-                        def = 1;
-                        break;
-                }
-                else if (strchr(short_no, (char) c)) {
-                        def = 0;
-                        break;
-                }
-                else if ((c == ' ' || c == '\n') && (def != -1))
-                        break;
-        }
-        if (def)
-                puts(_("yes\n"));
-        else
-                puts (_("no\n"));
-#ifdef HAVE_TERMIOS_H
-        tcsetattr (0, TCSANOW, &termios);
-#endif
-        return def;
-}
-
-int ask (e2fsck_t ctx, const char * string, int def)
-{
-        if (ctx->options & E2F_OPT_NO) {
-                printf (_("%s? no\n\n"), string);
-                return 0;
-        }
-        if (ctx->options & E2F_OPT_YES) {
-                printf (_("%s? yes\n\n"), string);
-                return 1;
-        }
-        if (ctx->options & E2F_OPT_PREEN) {
-                printf ("%s? %s\n\n", string, def ? _("yes") : _("no"));
-                return def;
-        }
-        return ask_yn(string, def);
-}
-
-void e2fsck_read_bitmaps(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        errcode_t       retval;
-
-        if (ctx->invalid_bitmaps) {
-                com_err(ctx->program_name, 0,
-                    _("e2fsck_read_bitmaps: illegal bitmap block(s) for %s"),
-                        ctx->device_name);
-                fatal_error(ctx, 0);
-        }
-
-        ehandler_operation(_("reading inode and block bitmaps"));
-        retval = ext2fs_read_bitmaps(fs);
-        ehandler_operation(0);
-        if (retval) {
-                com_err(ctx->program_name, retval,
-                        _("while retrying to read bitmaps for %s"),
-                        ctx->device_name);
-                fatal_error(ctx, 0);
-        }
-}
-
-void e2fsck_write_bitmaps(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-        errcode_t       retval;
-
-        if (ext2fs_test_bb_dirty(fs)) {
-                ehandler_operation(_("writing block bitmaps"));
-                retval = ext2fs_write_block_bitmap(fs);
-                ehandler_operation(0);
-                if (retval) {
-                        com_err(ctx->program_name, retval,
-                            _("while retrying to write block bitmaps for %s"),
-                                ctx->device_name);
-                        fatal_error(ctx, 0);
-                }
-        }
-
-        if (ext2fs_test_ib_dirty(fs)) {
-                ehandler_operation(_("writing inode bitmaps"));
-                retval = ext2fs_write_inode_bitmap(fs);
-                ehandler_operation(0);
-                if (retval) {
-                        com_err(ctx->program_name, retval,
-                            _("while retrying to write inode bitmaps for %s"),
-                                ctx->device_name);
-                        fatal_error(ctx, 0);
-                }
-        }
-}
-
-void preenhalt(e2fsck_t ctx)
-{
-        ext2_filsys fs = ctx->fs;
-
-        if (!(ctx->options & E2F_OPT_PREEN))
-                return;
-        fprintf(stderr, _("\n\n%s: UNEXPECTED INCONSISTENCY; "
-                "RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"),
-               ctx->device_name);
-        if (fs != NULL) {
-                fs->super->s_state |= EXT2_ERROR_FS;
-                ext2fs_mark_super_dirty(fs);
-                ext2fs_close(fs);
-        }
-        exit(FSCK_UNCORRECTED);
-}
-
-#ifdef RESOURCE_TRACK
-void init_resource_track(struct resource_track *track)
-{
-#ifdef HAVE_GETRUSAGE
-        struct rusage r;
-#endif
-        
-        track->brk_start = sbrk(0);
-        gettimeofday(&track->time_start, 0);
-#ifdef HAVE_GETRUSAGE
-#ifdef sun
-        memset(&r, 0, sizeof(struct rusage));
-#endif
-        getrusage(RUSAGE_SELF, &r);
-        track->user_start = r.ru_utime;
-        track->system_start = r.ru_stime;
-#else
-        track->user_start.tv_sec = track->user_start.tv_usec = 0;
-        track->system_start.tv_sec = track->system_start.tv_usec = 0;
-#endif
-}
-
-#ifdef __GNUC__
-#define _INLINE_ __inline__
-#else
-#define _INLINE_
-#endif
-
-static _INLINE_ float timeval_subtract(struct timeval *tv1,
-                                       struct timeval *tv2)
-{
-        return ((tv1->tv_sec - tv2->tv_sec) +
-                ((float) (tv1->tv_usec - tv2->tv_usec)) / 1000000);
-}
-
-void print_resource_track(const char *desc, struct resource_track *track)
-{
-#ifdef HAVE_GETRUSAGE
-        struct rusage r;
-#endif
-#ifdef HAVE_MALLINFO
-        struct mallinfo malloc_info;
-#endif
-        struct timeval time_end;
-
-        gettimeofday(&time_end, 0);
-
-        if (desc)
-                printf("%s: ", desc);
-
-#ifdef HAVE_MALLINFO
-#define kbytes(x)       (((x) + 1023) / 1024)
-        
-        malloc_info = mallinfo();
-        printf(_("Memory used: %dk/%dk (%dk/%dk), "),
-               kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd),
-               kbytes(malloc_info.uordblks), kbytes(malloc_info.fordblks));
-#else
-        printf(_("Memory used: %d, "),
-               (int) (((char *) sbrk(0)) - ((char *) track->brk_start)));
-#endif  
-#ifdef HAVE_GETRUSAGE
-        getrusage(RUSAGE_SELF, &r);
-
-        printf(_("time: %5.2f/%5.2f/%5.2f\n"),
-               timeval_subtract(&time_end, &track->time_start),
-               timeval_subtract(&r.ru_utime, &track->user_start),
-               timeval_subtract(&r.ru_stime, &track->system_start));
-#else
-        printf(_("elapsed time: %6.3f\n"),
-               timeval_subtract(&time_end, &track->time_start));
-#endif
-}
-#endif /* RESOURCE_TRACK */
-
-void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino,
-                              struct ext2_inode * inode, const char *proc)
-{
-        int retval;
-
-        retval = ext2fs_read_inode(ctx->fs, ino, inode);
-        if (retval) {
-                com_err("ext2fs_read_inode", retval,
-                        _("while reading inode %ld in %s"), ino, proc);
-                fatal_error(ctx, 0);
-        }
-}
-
-extern void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino,
-                               struct ext2_inode * inode, int bufsize,
-                               const char *proc)
-{
-        int retval;
-
-        retval = ext2fs_write_inode_full(ctx->fs, ino, inode, bufsize);
-        if (retval) {
-                com_err("ext2fs_write_inode", retval,
-                        _("while writing inode %ld in %s"), ino, proc);
-                fatal_error(ctx, 0);
-        }
-}
-
-extern void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino,
-                               struct ext2_inode * inode, const char *proc)
-{
-        int retval;
-
-        retval = ext2fs_write_inode(ctx->fs, ino, inode);
-        if (retval) {
-                com_err("ext2fs_write_inode", retval,
-                        _("while writing inode %ld in %s"), ino, proc);
-                fatal_error(ctx, 0);
-        }
-}
-
-#ifdef MTRACE
-void mtrace_print(char *mesg)
-{
-        FILE    *malloc_get_mallstream();
-        FILE    *f = malloc_get_mallstream();
-
-        if (f)
-                fprintf(f, "============= %s\n", mesg);
-}
-#endif
-
-blk_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, const char *name,
-                   io_manager manager)
-{
-        struct ext2_super_block *sb;
-        io_channel              io = NULL;
-        void                    *buf = NULL;
-        int                     blocksize;
-        blk_t                   superblock, ret_sb = 8193;
-        
-        if (fs && fs->super) {
-                ret_sb = (fs->super->s_blocks_per_group +
-                          fs->super->s_first_data_block);
-                if (ctx) {
-                        ctx->superblock = ret_sb;
-                        ctx->blocksize = fs->blocksize;
-                }
-                return ret_sb;
-        }
-                
-        if (ctx) {
-                if (ctx->blocksize) {
-                        ret_sb = ctx->blocksize * 8;
-                        if (ctx->blocksize == 1024)
-                                ret_sb++;
-                        ctx->superblock = ret_sb;
-                        return ret_sb;
-                }
-                ctx->superblock = ret_sb;
-                ctx->blocksize = 1024;
-        }
-
-        if (!name || !manager)
-                goto cleanup;
-
-        if (manager->open(name, 0, &io) != 0)
-                goto cleanup;
-
-        if (ext2fs_get_mem(SUPERBLOCK_SIZE, &buf))
-                goto cleanup;
-        sb = (struct ext2_super_block *) buf;
-
-        for (blocksize = EXT2_MIN_BLOCK_SIZE;
-             blocksize <= EXT2_MAX_BLOCK_SIZE ; blocksize *= 2) {
-                superblock = blocksize*8;
-                if (blocksize == 1024)
-                        superblock++;
-                io_channel_set_blksize(io, blocksize);
-                if (io_channel_read_blk(io, superblock,
-                                        -SUPERBLOCK_SIZE, buf))
-                        continue;
-#ifdef EXT2FS_ENABLE_SWAPFS
-                if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
-                        ext2fs_swap_super(sb);
-#endif
-                if (sb->s_magic == EXT2_SUPER_MAGIC) {
-                        ret_sb = superblock;
-                        if (ctx) {
-                                ctx->superblock = superblock;
-                                ctx->blocksize = blocksize;
-                        }
-                        break;
-                }
-        }
-
-cleanup:
-        if (io)
-                io_channel_close(io);
-        if (buf)
-                ext2fs_free_mem(&buf);
-        return (ret_sb);
-}
-
-/*
- * Given a mode, return the ext2 file type
- */
-int ext2_file_type(unsigned int mode)
-{
-        if (LINUX_S_ISREG(mode))
-                return EXT2_FT_REG_FILE;
-
-        if (LINUX_S_ISDIR(mode))
-                return EXT2_FT_DIR;
-        
-        if (LINUX_S_ISCHR(mode))
-                return EXT2_FT_CHRDEV;
-        
-        if (LINUX_S_ISBLK(mode))
-                return EXT2_FT_BLKDEV;
-        
-        if (LINUX_S_ISLNK(mode))
-                return EXT2_FT_SYMLINK;
-
-        if (LINUX_S_ISFIFO(mode))
-                return EXT2_FT_FIFO;
-        
-        if (LINUX_S_ISSOCK(mode))
-                return EXT2_FT_SOCK;
-        
-        return 0;
-}