#include "clusterautoconfig.h"

#include <stdio.h>

#include <stdint.h>

#include <inttypes.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <string.h>

#include <unistd.h>

#include <libintl.h>

#include <errno.h>

#include <time.h>

#define _(String) gettext(String)

#include <logging.h>

#include "libgfs2.h"

#include "fsck.h"

#include "util.h"

#include "fs_recovery.h"

#include "metawalk.h"

#include "inode_hash.h"

#define CLEAR_POINTER(x) \

	if (x) { \

		free(x); \

		x = NULL; \

	}

#define HIGHEST_BLOCK 0xffffffffffffffff

static int was_mounted_ro = 0;

static uint64_t possible_root = HIGHEST_BLOCK;

static struct master_dir fix_md;

static unsigned long long blks_2free = 0;

extern int sb_fixed;

/**

 * block_mounters

 *

 * Change the lock protocol so nobody can mount the fs

 *

 */

static int block_mounters(struct gfs2_sbd *sdp, int block_em)

{

	if (block_em) {

		/* verify it starts with lock_ */

		if (!strncmp(sdp->sd_sb.sb_lockproto, "lock_", 5)) {

			/* Change lock_ to fsck_ */

			memcpy(sdp->sd_sb.sb_lockproto, "fsck_", 5);

		}

		/* FIXME: Need to do other verification in the else

		 * case */

	} else {

		/* verify it starts with fsck_ */

		/* verify it starts with lock_ */

		if (!strncmp(sdp->sd_sb.sb_lockproto, "fsck_", 5)) {

			/* Change fsck_ to lock_ */

			memcpy(sdp->sd_sb.sb_lockproto, "lock_", 5);

		}

	}

	if (lgfs2_sb_write(&sdp->sd_sb, sdp->device_fd, sdp->bsize)) {

		stack;

		return -1;

	}

	return 0;

}

static void gfs2_dup_free(void)

{

	struct osi_node *n;

	struct duptree *dt;

	while ((n = osi_first(&dup_blocks))) {

		dt = (struct duptree *)n;

		dup_delete(dt);

	}

}

static void gfs2_dirtree_free(void)

{

	struct osi_node *n;

	struct dir_info *dt;

	while ((n = osi_first(&dirtree))) {

		dt = (struct dir_info *)n;

		dirtree_delete(dt);

	}

}

static void gfs2_inodetree_free(void)

{

	struct osi_node *n;

	struct inode_info *dt;

	while ((n = osi_first(&inodetree))) {

		dt = (struct inode_info *)n;

		inodetree_delete(dt);

	}

}

/*

 * empty_super_block - free all structures in the super block

 * sdp: the in-core super block

 *

 * This function frees all allocated structures within the

 * super block.  It does not free the super block itself.

 *

 * Returns: Nothing

 */

static void empty_super_block(struct gfs2_sbd *sdp)

{

	log_info( _("Freeing buffers.\n"));

	gfs2_rgrp_free(&sdp->rgtree);

	gfs2_inodetree_free();

	gfs2_dirtree_free();

	gfs2_dup_free();

}

/**

 * set_block_ranges

 * @sdp: superblock

 *

 * Uses info in rgrps and jindex to determine boundaries of the

 * file system.

 *

 * Returns: 0 on success, -1 on failure

 */

static int set_block_ranges(struct gfs2_sbd *sdp)

{

	struct osi_node *n, *next = NULL;

	struct rgrp_tree *rgd;

	struct gfs2_rindex *ri;

	char buf[sdp->sd_sb.sb_bsize];

	uint64_t rmax = 0;

	uint64_t rmin = 0;

	int error;

	log_info( _("Setting block ranges..."));

	for (n = osi_first(&sdp->rgtree); n; n = next) {

		next = osi_next(n);

		rgd = (struct rgrp_tree *)n;

		ri = &rgd->ri;

		if (ri->ri_data0 + ri->ri_data &&

		    ri->ri_data0 + ri->ri_data - 1 > rmax)

			rmax = ri->ri_data0 + ri->ri_data - 1;

		if (!rmin || ri->ri_data0 < rmin)

			rmin = ri->ri_data0;

	}

	last_fs_block = rmax;

	if (last_fs_block > 0xffffffff && sizeof(unsigned long) <= 4) {

		log_crit( _("This file system is too big for this computer to handle.\n"));

		log_crit( _("Last fs block = 0x%llx, but sizeof(unsigned long) is %zu bytes.\n"),

			 (unsigned long long)last_fs_block,

			 sizeof(unsigned long));

		goto fail;

	}

	last_data_block = rmax;

	first_data_block = rmin;

	if (fsck_lseek(sdp->device_fd, (last_fs_block * sdp->sd_sb.sb_bsize))){

		log_crit( _("Can't seek to last block in file system: %llu"

			 " (0x%llx)\n"), (unsigned long long)last_fs_block,

			 (unsigned long long)last_fs_block);

		goto fail;

	}

	memset(buf, 0, sdp->sd_sb.sb_bsize);

	error = read(sdp->device_fd, buf, sdp->sd_sb.sb_bsize);

	if (error != sdp->sd_sb.sb_bsize){

		log_crit( _("Can't read last block in file system (error %u), "

			 "last_fs_block: %llu (0x%llx)\n"), error,

			 (unsigned long long)last_fs_block,

			 (unsigned long long)last_fs_block);

		goto fail;

	}

	log_info(_("0x%llx to 0x%llx\n"), (unsigned long long)first_data_block,

		 (unsigned long long)last_data_block);

	return 0;

 fail:

	log_info( _("Error\n"));

	return -1;

}

/**

 * check_rgrp_integrity - verify a rgrp free block count against the bitmap

 */

static void check_rgrp_integrity(struct gfs2_sbd *sdp, struct rgrp_tree *rgd,

				 int *fixit, int *this_rg_fixed,

				 int *this_rg_bad, int *this_rg_cleaned)

{

	uint32_t rg_free, rg_reclaimed, rg_unlinked, rg_usedmeta, rg_useddi;

	int rgb, x, y, off, bytes_to_check, total_bytes_to_check, asked = 0;

	unsigned int state;

	struct gfs_rgrp *gfs1rg = (struct gfs_rgrp *)&rgd->rg;

	uint64_t diblock;

	struct gfs2_buffer_head *bh;

	rg_free = rg_reclaimed = rg_unlinked = rg_usedmeta = rg_useddi = 0;

	total_bytes_to_check = rgd->ri.ri_bitbytes;

	*this_rg_fixed = *this_rg_bad = *this_rg_cleaned = 0;

	diblock = rgd->ri.ri_data0;

	for (rgb = 0; rgb < rgd->ri.ri_length; rgb++){

		/* Count up the free blocks in the bitmap */

		off = (rgb) ? sizeof(struct gfs2_meta_header) :

			sizeof(struct gfs2_rgrp);

		if (total_bytes_to_check <= sdp->bsize - off)

			bytes_to_check = total_bytes_to_check;

		else

			bytes_to_check = sdp->bsize - off;

		total_bytes_to_check -= bytes_to_check;

		for (x = 0; x < bytes_to_check; x++) {

			unsigned char *byte;

			byte = (unsigned char *)&rgd->bits[rgb].bi_bh->b_data[off + x];

			if (*byte == 0x55) {

				diblock += GFS2_NBBY;

				continue;

			}

			if (*byte == 0x00) {

				diblock += GFS2_NBBY;

				rg_free += GFS2_NBBY;

				continue;

			}

			for (y = 0; y < GFS2_NBBY; y++) {

				state = (*byte >>

					 (GFS2_BIT_SIZE * y)) & GFS2_BIT_MASK;

				if (state == GFS2_BLKST_USED) {

					diblock++;

					continue;

				}

				if (state == GFS2_BLKST_DINODE) {

					if (sdp->gfs1) {

						bh = bread(sdp, diblock);

						if (!gfs2_check_meta(bh,

							GFS2_METATYPE_DI))

							rg_useddi++;

						else

							rg_usedmeta++;

						brelse(bh);

					}

					diblock++;

					continue;

				}

				if (state == GFS2_BLKST_FREE) {

					diblock++;

					rg_free++;

					continue;

				}

				/* GFS2_BLKST_UNLINKED */

				if (sdp->gfs1)

					log_info(_("Free metadata block 0x%llx"

						   " found.\n"),

						 (unsigned long long)diblock);

				else

					log_info(_("Unlinked dinode 0x%llx "

						   "found.\n"),

						 (unsigned long long)diblock);

				if (!asked) {

					char msg[256];

					asked = 1;

					sprintf(msg,

						_("Okay to reclaim free "

						  "metadata in resource group "

						  "%lld (0x%llx)? (y/n)"),

						(unsigned long long)rgd->ri.ri_addr,

						(unsigned long long)rgd->ri.ri_addr);

					if (query("%s", msg))

						*fixit = 1;

				}

				if (!(*fixit)) {

					rg_unlinked++;

					diblock++;

					continue;

				}

				*byte &= ~(GFS2_BIT_MASK <<

					   (GFS2_BIT_SIZE * y));

				bmodified(rgd->bits[rgb].bi_bh);

				rg_reclaimed++;

				rg_free++;

				rgd->rg.rg_free++;

				if (sdp->gfs1 && gfs1rg->rg_freemeta)

					gfs1rg->rg_freemeta--;

				log_info(_("Free metadata block %lld (0x%llx) "

					   "reclaimed.\n"),

					 (unsigned long long)diblock,

					 (unsigned long long)diblock);

				bh = bread(sdp, diblock);

				if (!gfs2_check_meta(bh, GFS2_METATYPE_DI)) {

					struct gfs2_inode *ip =

						fsck_inode_get(sdp, rgd, bh);

					if (ip->i_di.di_blocks > 1) {

						blks_2free +=

							ip->i_di.di_blocks - 1;

						log_info(_("%lld blocks "

							   "(total) may need "

							   "to be freed in "

							   "pass 5.\n"),

							 blks_2free);

					}

					fsck_inode_put(&ip);

				}

				brelse(bh);

				diblock++;

			}

		}

	}

	/* The unlinked blocks we reclaim shouldn't be considered errors,

	   since we're just reclaiming them as a courtesy. If we already

	   got permission to reclaim them, we adjust the rgrp counts

	   accordingly. That way, only "real" rgrp count inconsistencies

	   will be reported. */

	if (rg_reclaimed && *fixit) {

		if (sdp->gfs1)

			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh);

		else

			gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_bh->b_data);

		bmodified(rgd->bits[0].bi_bh);

		*this_rg_cleaned = 1;

		log_info( _("The rgrp at %lld (0x%llx) was cleaned of %d "

			    "free metadata blocks.\n"),

			  (unsigned long long)rgd->ri.ri_addr,

			  (unsigned long long)rgd->ri.ri_addr,

			  rg_reclaimed);

	}

	if (rgd->rg.rg_free != rg_free) {

		*this_rg_bad = 1;

		*this_rg_cleaned = 0;

		log_err( _("Error: resource group %lld (0x%llx): "

			   "free space (%d) does not match bitmap (%d)\n"),

			 (unsigned long long)rgd->ri.ri_addr,

			 (unsigned long long)rgd->ri.ri_addr,

			 rgd->rg.rg_free, rg_free);

		if (query( _("Fix the rgrp free blocks count? (y/n)"))) {

			rgd->rg.rg_free = rg_free;

			if (sdp->gfs1)

				gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh);

			else

				gfs2_rgrp_out(&rgd->rg, rgd->bits[0].bi_bh->b_data);

			bmodified(rgd->bits[0].bi_bh);

			*this_rg_fixed = 1;

			log_err( _("The rgrp was fixed.\n"));

		} else

			log_err( _("The rgrp was not fixed.\n"));

	}

	if (!sdp->gfs1)

		return;

	if (gfs1rg->rg_freemeta != rg_unlinked) {

		*this_rg_bad = 1;

		*this_rg_cleaned = 0;

		log_err( _("Error: resource group %lld (0x%llx): "

			   "free meta  (%d) does not match bitmap (%d)\n"),

			 (unsigned long long)rgd->ri.ri_addr,

			 (unsigned long long)rgd->ri.ri_addr,

			 gfs1rg->rg_freemeta, rg_unlinked);

		if (query( _("Fix the rgrp free meta blocks count? (y/n)"))) {

			gfs1rg->rg_freemeta = rg_unlinked;

			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg, rgd->bits[0].bi_bh);

			*this_rg_fixed = 1;

			log_err( _("The rgrp was fixed.\n"));

		} else

			log_err( _("The rgrp was not fixed.\n"));

	}

	if (gfs1rg->rg_useddi != rg_useddi) {

		*this_rg_bad = 1;

		*this_rg_cleaned = 0;

		log_err( _("Error: resource group %lld (0x%llx): used dinode "

			   "count (%d) does not match bitmap (%d)\n"),

			 (unsigned long long)rgd->ri.ri_addr,

			 (unsigned long long)rgd->ri.ri_addr,

			 gfs1rg->rg_useddi, rg_useddi);

		if (query( _("Fix the rgrp used dinode block count? (y/n)"))) {

			gfs1rg->rg_useddi = rg_useddi;

			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg,

				     rgd->bits[0].bi_bh);

			*this_rg_fixed = 1;

			log_err( _("The rgrp was fixed.\n"));

		} else

			log_err( _("The rgrp was not fixed.\n"));

	}

	if (gfs1rg->rg_usedmeta != rg_usedmeta) {

		*this_rg_bad = 1;

		*this_rg_cleaned = 0;

		log_err( _("Error: resource group %lld (0x%llx): used "

			   "metadata (%d) does not match bitmap (%d)\n"),

			 (unsigned long long)rgd->ri.ri_addr,

			 (unsigned long long)rgd->ri.ri_addr,

			 gfs1rg->rg_usedmeta, rg_usedmeta);

		if (query( _("Fix the rgrp used meta blocks count? (y/n)"))) {

			gfs1rg->rg_usedmeta = rg_usedmeta;

			gfs_rgrp_out((struct gfs_rgrp *)&rgd->rg,

				     rgd->bits[0].bi_bh);

			*this_rg_fixed = 1;

			log_err( _("The rgrp was fixed.\n"));

		} else

			log_err( _("The rgrp was not fixed.\n"));

	}

	/*

	else {

		log_debug( _("Resource group %lld (0x%llx) free space "

			     "is consistent: free: %d reclaimed: %d\n"),

			   (unsigned long long)rgd->ri.ri_addr,

			   (unsigned long long)rgd->ri.ri_addr,

			   rg_free, rg_reclaimed);

	}*/

}

/**

 * check_rgrps_integrity - verify rgrp consistency

 * Note: We consider an rgrp "cleaned" if the unlinked meta blocks are

 *       cleaned, so not quite "bad" and not quite "good" but rewritten anyway.

 *

 * Returns: 0 on success, 1 if errors were detected

 */

static void check_rgrps_integrity(struct gfs2_sbd *sdp)

{

	struct osi_node *n, *next = NULL;

	int rgs_good = 0, rgs_bad = 0, rgs_fixed = 0, rgs_cleaned = 0;

	int was_bad = 0, was_fixed = 0, was_cleaned = 0;

	struct rgrp_tree *rgd;

	int reclaim_unlinked = 0;

	log_info( _("Checking the integrity of all resource groups.\n"));

	for (n = osi_first(&sdp->rgtree); n; n = next) {

		next = osi_next(n);

		rgd = (struct rgrp_tree *)n;

		if (fsck_abort)

			return;

		check_rgrp_integrity(sdp, rgd, &reclaim_unlinked,

				     &was_fixed, &was_bad, &was_cleaned);

		if (was_fixed)

			rgs_fixed++;

		if (was_cleaned)

			rgs_cleaned++;

		else if (was_bad)

			rgs_bad++;

		else

			rgs_good++;

	}

	if (rgs_bad || rgs_cleaned) {

		log_err( _("RGs: Consistent: %d   Cleaned: %d   Inconsistent: "

			   "%d   Fixed: %d   Total: %d\n"),

			 rgs_good, rgs_cleaned, rgs_bad, rgs_fixed,

			 rgs_good + rgs_bad + rgs_cleaned);

		if (rgs_cleaned && blks_2free)

			log_err(_("%lld blocks may need to be freed in pass 5 "

				  "due to the cleaned resource groups.\n"),

				blks_2free);

	}

}

/**

 * rebuild_master - rebuild a destroyed master directory

 */

static int rebuild_master(struct gfs2_sbd *sdp)

{

	struct gfs2_inum inum;

	struct gfs2_buffer_head *bh = NULL;

	int err = 0;

	log_err(_("The system master directory seems to be destroyed.\n"));

	if (!query(_("Okay to rebuild it? (y/n)"))) {

		log_err(_("System master not rebuilt; aborting.\n"));

		return -1;

	}

	log_err(_("Trying to rebuild the master directory.\n"));

	inum.no_formal_ino = sdp->md.next_inum++;

	inum.no_addr = sdp->sd_sb.sb_master_dir.no_addr;

	err = init_dinode(sdp, &bh, &inum, S_IFDIR | 0755, GFS2_DIF_SYSTEM, &inum);

	if (err != 0)

		return -1;

	sdp->master_dir = lgfs2_inode_get(sdp, bh);

	if (sdp->master_dir == NULL) {

		log_crit(_("Error reading master: %s\n"), strerror(errno));

		return -1;

	}

	sdp->master_dir->bh_owned = 1;

	if (fix_md.jiinode) {

		inum.no_formal_ino = sdp->md.next_inum++;

		inum.no_addr = fix_md.jiinode->i_di.di_num.no_addr;

		err = dir_add(sdp->master_dir, "jindex", 6, &inum,

		              IF2DT(S_IFDIR | 0700));

		if (err) {

			log_crit(_("Error %d adding jindex directory\n"), errno);

			exit(FSCK_ERROR);

		}

		sdp->master_dir->i_di.di_nlink++;

	} else {

		err = build_jindex(sdp);

		if (err) {

			log_crit(_("Error %d building jindex\n"), err);

			exit(FSCK_ERROR);

		}

	}

	if (fix_md.pinode) {

		inum.no_formal_ino = sdp->md.next_inum++;

		inum.no_addr = fix_md.pinode->i_di.di_num.no_addr;

		err = dir_add(sdp->master_dir, "per_node", 8, &inum,

			IF2DT(S_IFDIR | 0700));

		if (err) {

			log_crit(_("Error %d adding per_node directory\n"),

				 errno);

			exit(FSCK_ERROR);

		}

		sdp->master_dir->i_di.di_nlink++;

	} else {

		err = build_per_node(sdp);

		if (err) {

			log_crit(_("Error %d building per_node directory\n"),

			         err);

			exit(FSCK_ERROR);

		}

	}

	if (fix_md.inum) {

		inum.no_formal_ino = sdp->md.next_inum++;

		inum.no_addr = fix_md.inum->i_di.di_num.no_addr;

		err = dir_add(sdp->master_dir, "inum", 4, &inum,

			IF2DT(S_IFREG | 0600));

		if (err) {

			log_crit(_("Error %d adding inum inode\n"), errno);

			exit(FSCK_ERROR);

		}

	} else {

		err = build_inum(sdp);

		if (err) {

			log_crit(_("Error %d building inum inode\n"), err);

			exit(FSCK_ERROR);

		}

		gfs2_lookupi(sdp->master_dir, "inum", 4, &sdp->md.inum);

	}

	if (fix_md.statfs) {

		inum.no_formal_ino = sdp->md.next_inum++;

		inum.no_addr = fix_md.statfs->i_di.di_num.no_addr;

		err = dir_add(sdp->master_dir, "statfs", 6, &inum,

			      IF2DT(S_IFREG | 0600));

		if (err) {

			log_crit(_("Error %d adding statfs inode\n"), errno);

			exit(FSCK_ERROR);

		}

	} else {

		err = build_statfs(sdp);

		if (err) {

			log_crit(_("Error %d building statfs inode\n"), err);

			exit(FSCK_ERROR);

		}

		gfs2_lookupi(sdp->master_dir, "statfs", 6, &sdp->md.statfs);

	}

	if (fix_md.riinode) {

		inum.no_formal_ino = sdp->md.next_inum++;

		inum.no_addr = fix_md.riinode->i_di.di_num.no_addr;

		err = dir_add(sdp->master_dir, "rindex", 6, &inum,

			IF2DT(S_IFREG | 0600));

		if (err) {

			log_crit(_("Error %d adding rindex inode\n"), errno);

			exit(FSCK_ERROR);

		}

	} else {

		err = build_rindex(sdp);

		if (err) {

			log_crit(_("Error %d building rindex inode\n"), err);

			exit(FSCK_ERROR);

		}

	}

	if (fix_md.qinode) {

		inum.no_formal_ino = sdp->md.next_inum++;

		inum.no_addr = fix_md.qinode->i_di.di_num.no_addr;

		err = dir_add(sdp->master_dir, "quota", 5, &inum,

			IF2DT(S_IFREG | 0600));

		if (err) {

			log_crit(_("Error %d adding quota inode\n"), errno);

			exit(FSCK_ERROR);

		}

	} else {

		err = build_quota(sdp);

		if (err) {

			log_crit(_("Error %d building quota inode\n"), err);

			exit(FSCK_ERROR);

		}

	}

	log_err(_("Master directory rebuilt.\n"));

	inode_put(&sdp->md.inum);

	inode_put(&sdp->md.statfs);

	inode_put(&sdp->master_dir);

	return 0;

}

/**

 * lookup_per_node - Make sure the per_node directory is read in

 *

 * This function is used to read in the per_node directory.  It is called

 * twice.  The first call tries to read in the dinode early on.  That ensures

 * that if any journals are missing, we can figure out the number of journals

 * from per_node.  However, we unfortunately can't rebuild per_node at that

 * point in time because our resource groups aren't read in yet.

 * The second time it's called is much later when we can rebuild it.

 *

 * allow_rebuild: 0 if rebuilds are not allowed

 *                1 if rebuilds are allowed

 */

static void lookup_per_node(struct gfs2_sbd *sdp, int allow_rebuild)

{

	if (sdp->md.pinode)

		return;

	gfs2_lookupi(sdp->master_dir, "per_node", 8, &sdp->md.pinode);

	if (sdp->md.pinode)

		return;

	if (!allow_rebuild) {

		log_err( _("The gfs2 system per_node directory "

			   "inode is missing, so we might not be \nable to "

			   "rebuild missing journals this run.\n"));

		return;

	}

	if (query( _("The gfs2 system per_node directory "

		     "inode is missing. Okay to rebuild it? (y/n) "))) {

		int err;

		err = build_per_node(sdp);

		if (err) {

			log_crit(_("Error %d rebuilding per_node directory\n"),

				 err);

			exit(FSCK_ERROR);

		}

	}

	gfs2_lookupi(sdp->master_dir, "per_node", 8, &sdp->md.pinode);

	if (!sdp->md.pinode) {

		log_err( _("Unable to rebuild per_node; aborting.\n"));

		exit(FSCK_ERROR);

	}

}

/**

 * fetch_rgrps - fetch the resource groups from disk, and check their integrity

 */

static int fetch_rgrps(struct gfs2_sbd *sdp)

{

	enum rgindex_trust_level trust_lvl;

	int rgcount, sane = 1;

	const char *level_desc[] = {

		_("Checking if all rgrp and rindex values are good"),

		_("Checking if rindex values may be easily repaired"),

		_("Calculating where the rgrps should be if evenly spaced"),

		_("Trying to rebuild rindex assuming evenly spaced rgrps"),

		_("Trying to rebuild rindex assuming unevenly spaced rgrps"),

	};

	const char *fail_desc[] = {

		_("Some damage was found; we need to take remedial measures"),

		_("rindex is unevenly spaced: either gfs1-style or corrupt"),

		_("rindex calculations don't match: uneven rgrp boundaries"),

		_("Too many rgrp misses: rgrps must be unevenly spaced"),

		_("Too much damage found: we cannot rebuild this rindex"),

	};

	/*******************************************************************

	 ********  Validate and read in resource group information  ********

	 *******************************************************************/

	log_notice(_("Validating resource group index.\n"));

	for (trust_lvl = blind_faith; trust_lvl <= indignation; trust_lvl++) {

		int ret = 0;

		log_notice(_("Level %d resource group check: %s.\n"), trust_lvl + 1,

			  level_desc[trust_lvl]);

		if ((rg_repair(sdp, trust_lvl, &rgcount, &sane) == 0) &&

		    ((ret = ri_update(sdp, 0, &rgcount, &sane)) == 0)) {

			log_notice(_("(level %d passed)\n"), trust_lvl + 1);

			break;

		} else {

			if (ret == -1)

				log_err( _("(level %d failed: %s)\n"),

					 trust_lvl + 1, fail_desc[trust_lvl]);

			else

				log_err( _("(level %d failed at block %lld "

					   "(0x%llx): %s)\n"), trust_lvl + 1,

					 (unsigned long long)ret,

					 (unsigned long long)ret,

					 fail_desc[trust_lvl]);

		}

		if (fsck_abort)

			break;

	}

	if (trust_lvl > indignation) {

		log_err( _("Resource group recovery impossible; I can't fix "

			   "this file system.\n"));

		return -1;

	}

	log_info( _("%u resource groups found.\n"), rgcount);

	check_rgrps_integrity(sdp);

	return 0;

}

/**

 * init_system_inodes

 *

 * Returns: 0 on success, -1 on failure

 */

static int init_system_inodes(struct gfs2_sbd *sdp)

{

	uint64_t inumbuf = 0;

	char *buf;

	struct gfs2_statfs_change sc;

	int err;

	/*******************************************************************

	 ******************  Initialize important inodes  ******************

	 *******************************************************************/

	log_info( _("Initializing special inodes...\n"));

	/* Get root dinode */

	sdp->md.rooti = lgfs2_inode_read(sdp, sdp->sd_sb.sb_root_dir.no_addr);

	if (sdp->md.rooti == NULL)

		return -1;

	/*******************************************************************

	 *****************  Initialize more system inodes  *****************

	 *******************************************************************/

	if (!sdp->gfs1) {

		/* Look for "inum" entry in master dinode */

		gfs2_lookupi(sdp->master_dir, "inum", 4, &sdp->md.inum);

		if (!sdp->md.inum) {

			if (!query( _("The gfs2 system inum inode is missing. "

				      "Okay to rebuild it? (y/n) "))) {

				log_err( _("fsck.gfs2 cannot continue without "

					   "a valid inum file; aborting.\n"));

				goto fail;

			}

			err = build_inum(sdp);

			if (err) {

				log_crit(_("Error %d rebuilding inum inode\n"),

					 err);

				exit(FSCK_ERROR);

			}

			gfs2_lookupi(sdp->master_dir, "inum", 4,

				     &sdp->md.inum);

			if (!sdp->md.inum) {

				log_crit(_("System inum inode was not rebuilt."

					   " Aborting.\n"));

				goto fail;

			}

		}

		/* Read inum entry into buffer */

		err = gfs2_readi(sdp->md.inum, &inumbuf, 0,

				 sdp->md.inum->i_di.di_size);

		if (err != sdp->md.inum->i_di.di_size) {

			log_crit(_("Error %d reading system inum inode. "

				   "Aborting.\n"), err);

			goto fail;

		}

		/* call gfs2_inum_range_in() to retrieve range */

		sdp->md.next_inum = be64_to_cpu(inumbuf);

	}

	if (sdp->gfs1) {

		/* In gfs1, the license_di is always 3 blocks after the jindex_di */

		if ((sbd1->sb_license_di.no_addr != sbd1->sb_jindex_di.no_addr + 3) ||

		    (sbd1->sb_license_di.no_formal_ino != sbd1->sb_jindex_di.no_addr + 3)) {

			if (!query( _("The gfs system statfs inode pointer is incorrect. "

				      "Okay to correct? (y/n) "))) {

				log_err( _("fsck.gfs2 cannot continue without a valid "

					   "statfs file; aborting.\n"));

				goto fail;

			}

			sbd1->sb_license_di.no_addr = sbd1->sb_license_di.no_formal_ino

				= sbd1->sb_jindex_di.no_addr + 3;

		}

		sdp->md.statfs = lgfs2_inode_read(sdp, sbd1->sb_license_di.no_addr);

		if (sdp->md.statfs == NULL) {

			log_crit(_("Error reading statfs inode: %s\n"), strerror(errno));

			goto fail;

		}

	} else

		gfs2_lookupi(sdp->master_dir, "statfs", 6, &sdp->md.statfs);

	if (!sdp->gfs1 && !sdp->md.statfs) {

		if (!query( _("The gfs2 system statfs inode is missing. "

			      "Okay to rebuild it? (y/n) "))) {

			log_err( _("fsck.gfs2 cannot continue without a valid "

				   "statfs file; aborting.\n"));

			goto fail;

		}

		err = build_statfs(sdp);

		if (err) {

			log_crit(_("Error %d rebuilding statfs inode\n"), err);

			exit(FSCK_ERROR);

		}

		gfs2_lookupi(sdp->master_dir, "statfs", 6, &sdp->md.statfs);

		if (!sdp->md.statfs) {

			log_err( _("Rebuild of statfs system file failed."));

			log_err( _("fsck.gfs2 cannot continue without "

				   "a valid statfs file; aborting.\n"));

			goto fail;

		}

		do_init_statfs(sdp);

	}

	if (sdp->md.statfs->i_di.di_size) {

		buf = malloc(sdp->md.statfs->i_di.di_size);

		if (buf) {

			err = gfs2_readi(sdp->md.statfs, buf, 0,

					 sdp->md.statfs->i_di.di_size);

			if (err != sdp->md.statfs->i_di.di_size) {

				log_crit(_("Error %d reading statfs file. "

					   "Aborting.\n"), err);

				free(buf);

				goto fail;

			}

			/* call gfs2_inum_range_in() to retrieve range */

			gfs2_statfs_change_in(&sc, buf);

			free(buf);

		}

	}

	if (sdp->gfs1) {

		/* In gfs1, the quota_di is always 2 blocks after the jindex_di */

		if ((sbd1->sb_quota_di.no_addr != sbd1->sb_jindex_di.no_addr + 2) ||

		    (sbd1->sb_quota_di.no_formal_ino != sbd1->sb_jindex_di.no_addr + 2)) {

			if (!query( _("The gfs system quota inode pointer is incorrect. "

				      " Okay to correct? (y/n) "))) {

				log_err( _("fsck.gfs2 cannot continue without a valid "

					   "quota file; aborting.\n"));

				goto fail;

			}

			sbd1->sb_quota_di.no_addr = sbd1->sb_quota_di.no_formal_ino

				= sbd1->sb_jindex_di.no_addr + 2;

		}

		sdp->md.qinode = lgfs2_inode_read(sdp, sbd1->sb_quota_di.no_addr);

		if (sdp->md.qinode == NULL) {

			log_crit(_("Error reading quota inode: %s\n"), strerror(errno));

			goto fail;

		}

	} else

		gfs2_lookupi(sdp->master_dir, "quota", 5, &sdp->md.qinode);

	if (!sdp->gfs1 && !sdp->md.qinode) {

		if (!query( _("The gfs2 system quota inode is missing. "

			      "Okay to rebuild it? (y/n) "))) {

			log_crit(_("System quota inode was not "

				   "rebuilt.  Aborting.\n"));

			goto fail;

		}

		err = build_quota(sdp);

		if (err) {

			log_crit(_("Error %d rebuilding quota inode\n"), err);

			exit(FSCK_ERROR);

		}

		gfs2_lookupi(sdp->master_dir, "quota", 5, &sdp->md.qinode);

		if (!sdp->md.qinode) {

			log_crit(_("Unable to rebuild system quota file "

				   "inode.  Aborting.\n"));

			goto fail;

		}

	}

	/* Try to lookup the per_node inode.  If it was missing, it is now

	   safe to rebuild it. */

	if (!sdp->gfs1)

		lookup_per_node(sdp, 1);

	/*******************************************************************