#include "clusterautoconfig.h"

#include <stdio.h>

#include <string.h>

#include <inttypes.h>

#include <stdlib.h>

#include <libintl.h>

#define _(String) gettext(String)

#include <logging.h>

#include "libgfs2.h"

#include "fsck.h"

#include "util.h"

#define GFS1_BLKST_USEDMETA 4

static int check_block_status(struct gfs2_sbd *sdp,  struct gfs2_bmap *bl,

			      char *buffer, unsigned int buflen,

			      uint64_t *rg_block, uint64_t rg_data,

			      uint32_t *count)

{

	unsigned char *byte, *end;

	unsigned int bit;

	unsigned char rg_status;

	int q;

	uint64_t block;

	/* FIXME verify cast */

	byte = (unsigned char *) buffer;

	bit = 0;

	end = (unsigned char *) buffer + buflen;

	while (byte < end) {

		rg_status = ((*byte >> bit) & GFS2_BIT_MASK);

		block = rg_data + *rg_block;

		warm_fuzzy_stuff(block);

		if (skip_this_pass || fsck_abort) /* if asked to skip the rest */

			return 0;

		q = block_type(bl, block);

		/* GFS1 file systems will have to suffer from slower fsck run

		 * times because in GFS, there's no 1:1 relationship between

		 * bits and counts. If a bit is marked "dinode" in GFS1, it

		 * may be dinode -OR- any kind of metadata. I consider GFS1 to

		 * be a rare exception, so acceptable loss at this point. So

		 * we must determine whether it's really a dinode or other

		 * metadata by reading it in. */

		if (sdp->gfs1 && q == GFS2_BLKST_DINODE) {

			struct gfs2_buffer_head *bh;

			bh = bread(sdp, block);

			if (gfs2_check_meta(bh, GFS2_METATYPE_DI) == 0)

				count[GFS2_BLKST_DINODE]++;

			else

				count[GFS1_BLKST_USEDMETA]++;

			brelse(bh);

		} else {

			count[q]++;

		}

		/* If one node opens a file and another node deletes it, we

		   may be left with a block that appears to be "unlinked" in

		   the bitmap, but nothing links to it. This is a valid case

		   and should be cleaned up by the file system eventually.

		   So we ignore it. */

		if (q == GFS2_BLKST_UNLINKED) {

			log_err( _("Unlinked inode found at block %llu "

				   "(0x%llx).\n"),

				 (unsigned long long)block,

				 (unsigned long long)block);

			if (query(_("Do you want to reclaim the block? "

				   "(y/n) "))) {

				lgfs2_rgrp_t rg = gfs2_blk2rgrpd(sdp, block);

				if (gfs2_set_bitmap(rg, block, GFS2_BLKST_FREE))

					log_err(_("Unlinked block %llu "

						  "(0x%llx) bitmap not fixed."

						  "\n"),

						(unsigned long long)block,

						(unsigned long long)block);

				else {

					log_err(_("Unlinked block %llu "

						  "(0x%llx) bitmap fixed.\n"),

						(unsigned long long)block,

						(unsigned long long)block);

					count[GFS2_BLKST_UNLINKED]--;

					count[GFS2_BLKST_FREE]++;

				}

			} else {

				log_info( _("Unlinked block found at block %llu"

					    " (0x%llx), left unchanged.\n"),

					(unsigned long long)block,

					(unsigned long long)block);

			}

		} else if (rg_status != q) {

			log_err( _("Block %llu (0x%llx) bitmap says %u (%s) "

				   "but FSCK saw %u (%s)\n"),

				 (unsigned long long)block,

				 (unsigned long long)block, rg_status,

				 block_type_string(rg_status), q,

				 block_type_string(q));

			if (q) /* Don't print redundant "free" */

				log_err( _("Metadata type is %u (%s)\n"), q,

					 block_type_string(q));

			if (query(_("Fix bitmap for block %llu (0x%llx) ? (y/n) "),

				 (unsigned long long)block,

				 (unsigned long long)block)) {

				lgfs2_rgrp_t rg = gfs2_blk2rgrpd(sdp, block);

				if (gfs2_set_bitmap(rg, block, q))

					log_err( _("Repair failed.\n"));

				else

					log_err( _("Fixed.\n"));

			} else

				log_err( _("Bitmap at block %llu (0x%llx) left inconsistent\n"),

					(unsigned long long)block,

					(unsigned long long)block);

		}

		(*rg_block)++;

		bit += GFS2_BIT_SIZE;

		if (bit >= 8){

			bit = 0;

			byte++;

		}

	}

	return 0;

}

static void update_rgrp(struct gfs2_sbd *sdp, struct rgrp_tree *rgp,

			struct gfs2_bmap *bl, uint32_t *count)

{

	uint32_t i;

	struct gfs2_bitmap *bits;

	uint64_t rg_block = 0;

	int update = 0;

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

	for(i = 0; i < rgp->ri.ri_length; i++) {

		bits = &rgp->bits[i];

		/* update the bitmaps */

		if (check_block_status(sdp, bl, bits->bi_bh->b_data + bits->bi_offset,

		                       bits->bi_len, &rg_block, rgp->ri.ri_data0, count))

			return;

		if (skip_this_pass || fsck_abort) /* if asked to skip the rest */

			return;

	}

	/* actually adjust counters and write out to disk */

	if (rgp->rg.rg_free != count[GFS2_BLKST_FREE]) {

		log_err( _("RG #%llu (0x%llx) free count inconsistent: "

			"is %u should be %u\n"),

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

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

			rgp->rg.rg_free, count[GFS2_BLKST_FREE]);

		rgp->rg.rg_free = count[GFS2_BLKST_FREE];

		update = 1;

	}

	if (rgp->rg.rg_dinodes != count[GFS2_BLKST_DINODE]) {

		log_err( _("RG #%llu (0x%llx) Inode count inconsistent: is "

			   "%u should be %u\n"),

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

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

			 rgp->rg.rg_dinodes, count[GFS2_BLKST_DINODE]);

		rgp->rg.rg_dinodes = count[GFS2_BLKST_DINODE];

		update = 1;

	}

	if (sdp->gfs1 && gfs1rg->rg_usedmeta != count[GFS1_BLKST_USEDMETA]) {

		log_err( _("RG #%llu (0x%llx) Used metadata count "

			   "inconsistent: is %u should be %u\n"),

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

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

			 gfs1rg->rg_usedmeta, count[GFS1_BLKST_USEDMETA]);

		gfs1rg->rg_usedmeta = count[GFS1_BLKST_USEDMETA];

		update = 1;

	}

	if (sdp->gfs1 && gfs1rg->rg_freemeta != count[GFS2_BLKST_UNLINKED]) {

		log_err( _("RG #%llu (0x%llx) Free metadata count "

			   "inconsistent: is %u should be %u\n"),

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

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

			 gfs1rg->rg_freemeta, count[GFS2_BLKST_UNLINKED]);

		gfs1rg->rg_freemeta = count[GFS2_BLKST_UNLINKED];

		update = 1;

	}

	if (!sdp->gfs1 && (rgp->ri.ri_data != count[GFS2_BLKST_FREE] +

			   count[GFS2_BLKST_USED] +

			   count[GFS2_BLKST_UNLINKED] +

			   count[GFS2_BLKST_DINODE])) {

		/* FIXME not sure how to handle this case ATM - it

		 * means that the total number of blocks we've counted

		 * exceeds the blocks in the rg */

		log_err( _("Internal fsck error: %u != %u + %u + %u + %u\n"),

			 rgp->ri.ri_data, count[GFS2_BLKST_FREE],

			 count[GFS2_BLKST_USED], count[GFS2_BLKST_UNLINKED],

			 count[GFS2_BLKST_DINODE]);

		exit(FSCK_ERROR);

	}

	if (update) {

		if (query( _("Update resource group counts? (y/n) "))) {

			log_warn( _("Resource group counts updated\n"));

			/* write out the rgrp */

			if (sdp->gfs1)

				gfs_rgrp_out(gfs1rg, rgp->bits[0].bi_bh);

			else

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

		} else

			log_err( _("Resource group counts left inconsistent\n"));

	}

}

/**

 * pass5 - check resource groups

 *

 * fix free block maps

 * fix used inode maps

 */

int pass5(struct gfs2_sbd *sdp, struct gfs2_bmap *bl)

{

	struct osi_node *n, *next = NULL;

	struct rgrp_tree *rgp = NULL;

	uint32_t count[5]; /* we need 5 because of GFS1 usedmeta */

	uint64_t rg_count = 0;

	/* Reconcile RG bitmaps with fsck bitmap */

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

		next = osi_next(n);

		if (skip_this_pass || fsck_abort) /* if asked to skip the rest */

			return FSCK_OK;

		log_info( _("Verifying Resource Group #%llu\n"), (unsigned long long)rg_count);

		memset(count, 0, sizeof(count));

		rgp = (struct rgrp_tree *)n;

		rg_count++;

		/* Compare the bitmaps and report the differences */

		update_rgrp(sdp, rgp, bl, count);

	}

	/* Fix up superblock info based on this - don't think there's

	 * anything to do here... */

	return FSCK_OK;

}