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

1 files changed, 0 insertions, 2122 deletions

diff --git a/e2fsprogs/e2fsck/pass1.c b/e2fsprogs/e2fsck/pass1.c
deleted file mode 100644
index 8d01cae..0000000
--- 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;
-	}
-}