/* pass1 checks inodes for format & type, duplicate blocks, & incorrect

 * block count.

 *

 * It builds up tables that contains the state of each block (free,

 * block in use, metadata type, etc), as well as bad blocks and

 * duplicate blocks.  (See block_list.[ch] for more info)

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <sys/time.h>

#include <sys/stat.h>

#include <unistd.h>

#include <string.h>

#include <time.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#include <inttypes.h>

#include <libintl.h>

#define _(String) gettext(String)

#include <logging.h>

#include "libgfs2.h"

#include "fsck.h"

#include "inode_hash.h"

#include "util.h"

#include "link.h"

#include "metawalk.h"

#include "fs_recovery.h"

struct special_blocks gfs1_rindex_blks;

struct gfs2_bmap *bl = NULL;

struct block_count {

	uint64_t indir_count;

	uint64_t data_count;

	uint64_t ea_count;

};

static int p1check_leaf(struct gfs2_inode *ip, uint64_t block, void *private);

static int check_metalist(struct gfs2_inode *ip, uint64_t block,

			  struct gfs2_buffer_head **bh, int h, int *is_valid,

			  int *was_duplicate, void *private);

static int undo_check_metalist(struct gfs2_inode *ip, uint64_t block,

			       int h, void *private);

static int check_data(struct gfs2_inode *ip, uint64_t metablock,

		      uint64_t block, void *private,

		      struct gfs2_buffer_head *bh, uint64_t *ptr);

static int undo_check_data(struct gfs2_inode *ip, uint64_t block,

			   void *private);

static int check_eattr_indir(struct gfs2_inode *ip, uint64_t indirect,

			     uint64_t parent, struct gfs2_buffer_head **bh,

			     void *private);

static int check_eattr_leaf(struct gfs2_inode *ip, uint64_t block,

			    uint64_t parent, struct gfs2_buffer_head **bh,

			    void *private);

static int check_eattr_entries(struct gfs2_inode *ip,

			       struct gfs2_buffer_head *leaf_bh,

			       struct gfs2_ea_header *ea_hdr,

			       struct gfs2_ea_header *ea_hdr_prev,

			       void *private);

static int check_extended_leaf_eattr(struct gfs2_inode *ip, int i,

				     uint64_t *data_ptr,

				     struct gfs2_buffer_head *leaf_bh,

				     uint32_t tot_ealen,

				     struct gfs2_ea_header *ea_hdr,

				     struct gfs2_ea_header *ea_hdr_prev,

				     void *private);

static int finish_eattr_indir(struct gfs2_inode *ip, int leaf_pointers,

			      int leaf_pointer_errors, void *private);

static int invalidate_metadata(struct gfs2_inode *ip, uint64_t block,

			       struct gfs2_buffer_head **bh, int h,

			       int *is_valid, int *was_duplicate,

			       void *private);

static int invalidate_leaf(struct gfs2_inode *ip, uint64_t block,

			   void *private);

static int invalidate_data(struct gfs2_inode *ip, uint64_t metablock,

			   uint64_t block, void *private,

			   struct gfs2_buffer_head *bh, uint64_t *ptr);

static int invalidate_eattr_indir(struct gfs2_inode *ip, uint64_t block,

				  uint64_t parent,

				  struct gfs2_buffer_head **bh,

				  void *private);

static int invalidate_eattr_leaf(struct gfs2_inode *ip, uint64_t block,

				 uint64_t parent, struct gfs2_buffer_head **bh,

				 void *private);

static int handle_ip(struct gfs2_sbd *sdp, struct gfs2_inode *ip);

static int delete_block(struct gfs2_inode *ip, uint64_t block,

			struct gfs2_buffer_head **bh, const char *btype,

			void *private);

static int gfs2_blockmap_set(struct gfs2_bmap *bmap, uint64_t bblock, int mark)

{

	static unsigned char *byte;

	static uint64_t b;

	if (!bmap)

		return 0;

	if (bblock > bmap->size)

		return -1;

	byte = bmap->map + BLOCKMAP_SIZE2(bblock);

	b = BLOCKMAP_BYTE_OFFSET2(bblock);

	*byte &= ~(BLOCKMAP_MASK2 << b);

	*byte |= (mark & BLOCKMAP_MASK2) << b;

	return 0;

}

/*

 * _fsck_blockmap_set - Mark a block in the 4-bit blockmap and the 2-bit

 *                      bitmap, and adjust free space accordingly.

 */

static int _fsck_blockmap_set(struct gfs2_inode *ip, uint64_t bblock,

			      const char *btype, int mark, int error_on_dinode,

			      const char *caller, int fline)

{

	int error = _fsck_bitmap_set(ip, bblock, btype, mark, error_on_dinode,

				     caller, fline);

	if (error)

		return error;

	return gfs2_blockmap_set(bl, bblock, mark);

}

#define fsck_blockmap_set(ip, b, bt, m) \

	_fsck_blockmap_set(ip, b, bt, m, 0, __FUNCTION__, __LINE__)

#define fsck_blkmap_set_noino(ip, b, bt, m) \

	_fsck_blockmap_set(ip, b, bt, m, 1, __FUNCTION__, __LINE__)

/**

 * delete_block - delete a block associated with an inode

 */

static int delete_block(struct gfs2_inode *ip, uint64_t block,

			struct gfs2_buffer_head **bh, const char *btype,

			void *private)

{

	if (valid_block_ip(ip, block)) {

		fsck_blockmap_set(ip, block, btype, GFS2_BLKST_FREE);

		return 0;

	}

	return -1;

}

/* This is a pass1-specific leaf repair. Since we are not allowed to do

 * block allocations, we do what we can. */

static int pass1_repair_leaf(struct gfs2_inode *ip, uint64_t *leaf_no,

			     int lindex, int ref_count, const char *msg)

{

	uint64_t *cpyptr;

	char *padbuf;

	int pad_size, i;

	log_err( _("Directory Inode %llu (0x%llx) points to leaf %llu"

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

		 (unsigned long long)ip->i_di.di_num.no_addr,

		 (unsigned long long)ip->i_di.di_num.no_addr,

		 (unsigned long long)*leaf_no,

		 (unsigned long long)*leaf_no, msg);

	if (!query( _("Attempt to patch around it? (y/n) "))) {

		log_err( _("Bad leaf left in place.\n"));

		goto out;

	}

	padbuf = malloc(ref_count * sizeof(uint64_t));

	cpyptr = (uint64_t *)padbuf;

	for (i = 0; i < ref_count; i++) {

		*cpyptr = 0;

		cpyptr++;

	}

	pad_size = ref_count * sizeof(uint64_t);

	log_err(_("Writing zeros to the hash table of directory %lld "

		  "(0x%llx) at index: 0x%x for 0x%x pointers.\n"),

		(unsigned long long)ip->i_di.di_num.no_addr,

		(unsigned long long)ip->i_di.di_num.no_addr, lindex,

		ref_count);

	if (ip->i_sbd->gfs1)

		gfs1_writei(ip, padbuf, lindex * sizeof(uint64_t), pad_size);

	else

		gfs2_writei(ip, padbuf, lindex * sizeof(uint64_t), pad_size);

	free(padbuf);

	log_err( _("Directory Inode %llu (0x%llx) patched.\n"),

		 (unsigned long long)ip->i_di.di_num.no_addr,

		 (unsigned long long)ip->i_di.di_num.no_addr);

out:

	*leaf_no = 0;

	return 0;

}

struct metawalk_fxns pass1_fxns = {

	.private = NULL,

	.check_leaf = p1check_leaf,

	.check_metalist = check_metalist,

	.check_data = check_data,

	.check_eattr_indir = check_eattr_indir,

	.check_eattr_leaf = check_eattr_leaf,

	.check_dentry = NULL,

	.check_eattr_entry = check_eattr_entries,

	.check_eattr_extentry = check_extended_leaf_eattr,

	.big_file_msg = big_file_comfort,

	.repair_leaf = pass1_repair_leaf,

	.undo_check_meta = undo_check_metalist,

	.undo_check_data = undo_check_data,

	.delete_block = delete_block,

};

struct metawalk_fxns invalidate_fxns = {

	.private = NULL,

	.check_metalist = invalidate_metadata,

	.check_data = invalidate_data,

	.check_leaf = invalidate_leaf,

	.check_eattr_indir = invalidate_eattr_indir,

	.check_eattr_leaf = invalidate_eattr_leaf,

	.delete_block = delete_block,

};

/*

 * resuscitate_metalist - make sure a system directory entry's metadata blocks

 *                        are marked "in use" in the bitmap.

 *

 * This function makes sure metadata blocks for system and root directories are

 * marked "in use" by the bitmap.  You don't want root's indirect blocks

 * deleted, do you? Or worse, reused for lost+found.

 */

static int resuscitate_metalist(struct gfs2_inode *ip, uint64_t block,

				struct gfs2_buffer_head **bh, int h,

				int *is_valid, int *was_duplicate,

				void *private)

{

	struct block_count *bc = (struct block_count *)private;

	*is_valid = 1;

	*was_duplicate = 0;

	*bh = NULL;

	if (!valid_block_ip(ip, block)){ /* blk outside of FS */

		fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,

				  _("itself"), GFS2_BLKST_UNLINKED);

		log_err( _("Bad indirect block pointer (invalid or out of "

			   "range) found in system inode %lld (0x%llx).\n"),

			 (unsigned long long)ip->i_di.di_num.no_addr,

			 (unsigned long long)ip->i_di.di_num.no_addr);

		*is_valid = 0;

		return meta_is_good;

	}

	if (fsck_system_inode(ip->i_sbd, block))

		fsck_blockmap_set(ip, block, _("system file"),

				  ip->i_sbd->gfs1 ?

				  GFS2_BLKST_DINODE : GFS2_BLKST_USED);

	else

		check_n_fix_bitmap(ip->i_sbd, ip->i_rgd, block, 0,

				   ip->i_sbd->gfs1 ?

				   GFS2_BLKST_DINODE : GFS2_BLKST_USED);

	bc->indir_count++;

	return meta_is_good;

}

/*

 * resuscitate_dentry - make sure a system directory entry is alive

 *

 * This function makes sure directory entries in system directories are

 * kept alive.  You don't want journal0 deleted from jindex, do you?

 */

static int resuscitate_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,

			      struct gfs2_dirent *prev_de,

			      struct gfs2_buffer_head *bh, char *filename,

			      uint32_t *count, int *lindex, void *priv)

{

	struct gfs2_sbd *sdp = ip->i_sbd;

	struct gfs2_dirent dentry, *de;

	char tmp_name[PATH_MAX];

	uint64_t block;

	memset(&dentry, 0, sizeof(struct gfs2_dirent));

	gfs2_dirent_in(&dentry, (char *)dent);

	de = &dentry;

	block = de->de_inum.no_addr;

	/* Start of checks */

	memset(tmp_name, 0, sizeof(tmp_name));

	if (de->de_name_len < sizeof(tmp_name))

		strncpy(tmp_name, filename, de->de_name_len);

	else

		strncpy(tmp_name, filename, sizeof(tmp_name) - 1);

	if (!valid_block_ip(ip, block)) {

		log_err( _("Block # referenced by system directory entry %s "

			   "in inode %lld (0x%llx) is invalid or out of range;"

			   " ignored.\n"),

			 tmp_name, (unsigned long long)ip->i_di.di_num.no_addr,

			 (unsigned long long)ip->i_di.di_num.no_addr);

		return 0;

	}

	/* If this is a system dinode, we'll handle it later in

	   check_system_inodes.  If not, it'll be handled by pass1 but

	   since it's in a system directory we need to make sure it's

	   represented in the rgrp bitmap. */

	if (fsck_system_inode(sdp, block))

		fsck_blockmap_set(ip, block, _("system file"),

				  GFS2_BLKST_DINODE);

	else

		check_n_fix_bitmap(sdp, ip->i_rgd, block, 0,

				   GFS2_BLKST_DINODE);

	/* Return the number of leaf entries so metawalk doesn't flag this

	   leaf as having none. */

	*count = be16_to_cpu(((struct gfs2_leaf *)bh->b_data)->lf_entries);

	return 0;

}

struct metawalk_fxns sysdir_fxns = {

	.private = NULL,

	.check_metalist = resuscitate_metalist,

	.check_dentry = resuscitate_dentry,

	.delete_block = delete_block,

};

static int p1check_leaf(struct gfs2_inode *ip, uint64_t block, void *private)

{

	struct block_count *bc = (struct block_count *) private;

	int q;

	/* Note if we've gotten this far, the block has already passed the

	   check in metawalk: gfs2_check_meta(lbh, GFS2_METATYPE_LF).

	   So we know it's a leaf block. */

	bc->indir_count++;

	q = block_type(bl, block);

	if (q != GFS2_BLKST_FREE) {

		log_err( _("Found duplicate block #%llu (0x%llx) referenced "

			   "as a directory leaf in dinode "

			   "%llu (0x%llx) - was marked %d (%s)\n"),

			 (unsigned long long)block,

			 (unsigned long long)block,

			 (unsigned long long)ip->i_di.di_num.no_addr,

			 (unsigned long long)ip->i_di.di_num.no_addr, q,

			 block_type_string(q));

		add_duplicate_ref(ip, block, ref_as_meta, 0, INODE_VALID);

		if (q == (ip->i_sbd->gfs1 ? GFS2_BLKST_DINODE :

			  GFS2_BLKST_USED))

			/* If the previous reference also saw this as a leaf,

			   it was already checked, so don't check again. */

			return EEXIST; /* non-fatal */

	}

	fsck_blockmap_set(ip, block, _("directory leaf"),

			  ip->i_sbd->gfs1 ? GFS2_BLKST_DINODE :

			  GFS2_BLKST_USED);

	return 0;

}

static int check_metalist(struct gfs2_inode *ip, uint64_t block,

			  struct gfs2_buffer_head **bh, int h, int *is_valid,

			  int *was_duplicate, void *private)

{

	int q;

	int iblk_type;

	struct gfs2_buffer_head *nbh;

	struct block_count *bc = (struct block_count *)private;

	const char *blktypedesc;

	*bh = NULL;

	*was_duplicate = 0;

	*is_valid = 0;

	if (!valid_block_ip(ip, block)) { /* blk outside of FS */

		/* The bad dinode should be invalidated later due to

		   "unrecoverable" errors.  The inode itself should be

		   set "free" and removed from the inodetree by

		   undo_check_metalist. */

		fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,

				  _("bad block referencing"), GFS2_BLKST_UNLINKED);

		log_debug( _("Bad indirect block (invalid/out of range) "

			     "found in inode %lld (0x%llx).\n"),

			   (unsigned long long)ip->i_di.di_num.no_addr,

			   (unsigned long long)ip->i_di.di_num.no_addr);

		return meta_skip_further;

	}

	if (is_dir(&ip->i_di, ip->i_sbd->gfs1) && h == ip->i_di.di_height) {

		iblk_type = GFS2_METATYPE_JD;

		blktypedesc = _("a directory hash table block");

	} else {

		iblk_type = GFS2_METATYPE_IN;

		blktypedesc = _("a journaled data block");

	}

	q = block_type(bl, block);

	if (q != GFS2_BLKST_FREE) {

		log_err( _("Found duplicate block #%llu (0x%llx) referenced "

			   "as metadata in indirect block for dinode "

			   "%llu (0x%llx) - was marked %d (%s)\n"),

			 (unsigned long long)block,

			 (unsigned long long)block,

			 (unsigned long long)ip->i_di.di_num.no_addr,

			 (unsigned long long)ip->i_di.di_num.no_addr, q,

			 block_type_string(q));

		*was_duplicate = 1;

	}

	nbh = bread(ip->i_sbd, block);

	*is_valid = (gfs2_check_meta(nbh, iblk_type) == 0);

	if (!(*is_valid)) {

		log_err( _("Inode %lld (0x%llx) has a bad indirect block "

			   "pointer %lld (0x%llx) (points to something "

			   "that is not %s).\n"),

			 (unsigned long long)ip->i_di.di_num.no_addr,

			 (unsigned long long)ip->i_di.di_num.no_addr,

			 (unsigned long long)block,

			 (unsigned long long)block, blktypedesc);

		brelse(nbh);

		return meta_skip_further;

	}

	bc->indir_count++;

	if (*was_duplicate) {

		add_duplicate_ref(ip, block, ref_as_meta, 0,

				  *is_valid ? INODE_VALID : INODE_INVALID);

		brelse(nbh);

	} else {

		*bh = nbh;

		fsck_blockmap_set(ip, block, _("indirect"), ip->i_sbd->gfs1 ?

				  GFS2_BLKST_DINODE : GFS2_BLKST_USED);

	}

	if (*is_valid)

		return meta_is_good;

	return meta_skip_further;

}

/* undo_reference - undo previously processed data or metadata

 * We've treated the metadata for this dinode as good so far, but not we

 * realize it's bad. So we need to undo what we've done.

 *

 * Returns: 0 - We need to process the block as metadata. In other words,

 *              we need to undo any blocks it refers to.

 *          1 - We can't process the block as metadata.

 */

static int undo_reference(struct gfs2_inode *ip, uint64_t block, int meta,

			  void *private)

{

	struct block_count *bc = (struct block_count *)private;

	struct duptree *dt;

	struct inode_with_dups *id;

	int old_bitmap_state = 0;

	struct rgrp_tree *rgd;

	if (!valid_block_ip(ip, block)) { /* blk outside of FS */

		fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,

				  _("bad block referencing"), GFS2_BLKST_FREE);

		return 1;

	}

	if (meta)

		bc->indir_count--;

	dt = dupfind(block);

	if (dt) {

		/* remove all duplicate reference structures from this inode */

		do {

			id = find_dup_ref_inode(dt, ip);

			if (!id)

				break;

			dup_listent_delete(dt, id);

		} while (id);

		if (dt->refs) {

			log_err(_("Block %llu (0x%llx) is still referenced "

				  "from another inode; not freeing.\n"),

				(unsigned long long)block,

				(unsigned long long)block);

			if (dt->refs == 1) {

				log_err(_("This was the only duplicate "

					  "reference so far; removing it.\n"));

				dup_delete(dt);

			}

			return 1;

		}

	}

	if (!meta) {

		rgd = gfs2_blk2rgrpd(ip->i_sbd, block);

		old_bitmap_state = lgfs2_get_bitmap(ip->i_sbd, block, rgd);

		if (old_bitmap_state == GFS2_BLKST_DINODE)

			return -1;

	}

	fsck_blockmap_set(ip, block,

			  meta ? _("bad indirect") : _("referenced data"),

			  GFS2_BLKST_FREE);

	return 0;

}

static int undo_check_metalist(struct gfs2_inode *ip, uint64_t block,

			       int h, void *private)

{

	return undo_reference(ip, block, 1, private);

}

static int undo_check_data(struct gfs2_inode *ip, uint64_t block,

			   void *private)

{

	return undo_reference(ip, block, 0, private);

}

/* blockmap_set_as_data - set block as 'data' in the blockmap, if not dinode

 *

 * This function tries to set a block that's referenced as data as 'data'

 * in the fsck blockmap. But if that block is marked as 'dinode' in the

 * rgrp bitmap, it does additional checks to see if it looks like a dinode.

 * Note that previous checks were done for duplicate references, so this

 * is checking for dinodes that we haven't processed yet.

 */

static int blockmap_set_as_data(struct gfs2_inode *ip, uint64_t block)

{

	int error;

	struct gfs2_buffer_head *bh;

	struct gfs2_dinode *di;

	error = fsck_blkmap_set_noino(ip, block, _("data"), GFS2_BLKST_USED);

	if (!error)

		return 0;

	error = 0;

	/* The bitmap says it's a dinode, but a block reference begs to differ.

	   So which is it? */

	bh = bread(ip->i_sbd, block);

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

		goto out;

	/* The meta header agrees it's a dinode. But it might be data in

	   disguise, so do some extra checks. */

	di = (struct gfs2_dinode *)bh->b_data;

	if (be64_to_cpu(di->di_num.no_addr) != block)

		goto out;

	log_err(_("Inode %lld (0x%llx) has a reference to block %lld (0x%llx) "

		  "as a data block, but it appears to be a dinode we "

		  "haven't checked yet.\n"),

		(unsigned long long)ip->i_di.di_num.no_addr,

		(unsigned long long)ip->i_di.di_num.no_addr,

		(unsigned long long)block, (unsigned long long)block);

	error = -1;

out:

	if (!error)

		fsck_blockmap_set(ip, block, _("data"),  GFS2_BLKST_USED);

	brelse(bh);

	return error;

}

static int check_data(struct gfs2_inode *ip, uint64_t metablock,

		      uint64_t block, void *private,

		      struct gfs2_buffer_head *bbh, uint64_t *ptr)

{

	int q;

	struct block_count *bc = (struct block_count *) private;

	if (!valid_block_ip(ip, block)) {

		log_err( _("inode %lld (0x%llx) has a bad data block pointer "

			   "%lld (0x%llx) (invalid or out of range) "),

			 (unsigned long long)ip->i_di.di_num.no_addr,

			 (unsigned long long)ip->i_di.di_num.no_addr,

			 (unsigned long long)block, (unsigned long long)block);

		if (metablock == ip->i_di.di_num.no_addr)

			log_err("\n");

		else

			log_err(_("from metadata block %llu (0x%llx)\n"),

				(unsigned long long)metablock,

				(unsigned long long)metablock);

		/* Mark the owner of this block with the bad_block

		 * designator so we know to check it for out of range

		 * blocks later */

		fsck_blockmap_set(ip, ip->i_di.di_num.no_addr,

				  _("bad (out of range) data"),

				  GFS2_BLKST_UNLINKED);

		return -1;

	}

	bc->data_count++; /* keep the count sane anyway */

	q = block_type(bl, block);

	if (q != GFS2_BLKST_FREE) {

		struct gfs2_buffer_head *bh;

		struct gfs2_meta_header mh;

		log_err( _("Found duplicate %s block %llu (0x%llx) "

			   "referenced as data by dinode %llu (0x%llx) "),

			 block_type_string(q),

			 (unsigned long long)block,

			 (unsigned long long)block,

			 (unsigned long long)ip->i_di.di_num.no_addr,

			 (unsigned long long)ip->i_di.di_num.no_addr);

		if (metablock == ip->i_di.di_num.no_addr)

			log_err("\n");

		else

			log_err(_("from metadata block %llu (0x%llx)\n"),

				(unsigned long long)metablock,

				(unsigned long long)metablock);

		switch (q) {

		case GFS2_BLKST_DINODE:

			log_info(_("The block was processed earlier as an "

				   "inode, so it can't possibly be data.\n"));

			/* We still need to add a duplicate record here because

			   when check_metatree tries to delete the inode, we

			   can't have the "undo" functions freeing the block

			   out from other the original referencing inode. */

			add_duplicate_ref(ip, block, ref_as_data, 0,

					  INODE_VALID);

			return 1;

		case GFS2_BLKST_USED: /* tough decision: May be data or meta */

			bh = bread(ip->i_sbd, block);

			gfs2_meta_header_in(&mh, bh->b_data);

			brelse(bh);

			if (mh.mh_magic == GFS2_MAGIC &&

			    mh.mh_type >= GFS2_METATYPE_RG &&

			    mh.mh_type <= GFS2_METATYPE_QC &&

			    mh.mh_type != GFS2_METATYPE_DI &&

			    mh.mh_format % 100 == 0) {

				log_info(_("The block was processed earlier "

					   "as valid metadata, so it can't "

					   "possibly be data.\n"));

				/* We still need to add a duplicate record here

				   because when check_metatree tries to delete

				   the inode, we can't have the "undo"

				   functions freeing the block out from other

				   the original referencing inode. */

				add_duplicate_ref(ip, block, ref_as_data, 0,

						  INODE_VALID);

				return 1;

			}

			log_info( _("Seems to be a normal duplicate; I'll "

				    "sort it out in pass1b.\n"));

			add_duplicate_ref(ip, block, ref_as_data, 0,

					  INODE_VALID);

			/* This inode references the block as data. So if this

			   all is validated, we want to keep this count. */

			return 0;

		case GFS2_BLKST_UNLINKED:

			log_info( _("The block was invalid as metadata but might be "

				    "okay as data.  I'll sort it out in pass1b.\n"));

			add_duplicate_ref(ip, block, ref_as_data, 0, INODE_VALID);

			return 0;

		}

	}

	/* In gfs1, rgrp indirect blocks are marked in the bitmap as "meta".

	   In gfs2, "meta" is only for dinodes. So here we dummy up the

	   blocks so that the bitmap isn't changed improperly. */

	if (ip->i_sbd->gfs1 && ip == ip->i_sbd->md.riinode) {

		log_info(_("Block %lld (0x%llx) is a GFS1 rindex block\n"),

			 (unsigned long long)block, (unsigned long long)block);

		gfs2_special_set(&gfs1_rindex_blks, block);

		fsck_blockmap_set(ip, block, _("rgrp"), GFS2_BLKST_DINODE);

		/*gfs2_meta_rgrp);*/

	} else if (ip->i_sbd->gfs1 && ip->i_di.di_flags & GFS2_DIF_JDATA) {

		log_info(_("Block %lld (0x%llx) is a GFS1 journaled data "

			   "block\n"),

			 (unsigned long long)block, (unsigned long long)block);

		fsck_blockmap_set(ip, block, _("jdata"), GFS2_BLKST_DINODE);

	} else

		return blockmap_set_as_data(ip, block);

	return 0;

}

static int ask_remove_inode_eattr(struct gfs2_inode *ip,

				  struct block_count *bc)

{

	if (ip->i_di.di_eattr == 0)

		return 0; /* eattr was removed prior to this call */

	log_err( _("Inode %lld (0x%llx) has unrecoverable Extended Attribute "

		   "errors.\n"), (unsigned long long)ip->i_di.di_num.no_addr,

		 (unsigned long long)ip->i_di.di_num.no_addr);

	if (query( _("Clear all Extended Attributes from the inode? (y/n) "))){

		undo_reference(ip, ip->i_di.di_eattr, 0, bc);

		ip->i_di.di_eattr = 0;

		bc->ea_count = 0;

		ip->i_di.di_blocks = 1 + bc->indir_count + bc->data_count;

		ip->i_di.di_flags &= ~GFS2_DIF_EA_INDIRECT;

		bmodified(ip->i_bh);

		log_err( _("Extended attributes were removed.\n"));

	} else {

		log_err( _("Extended attributes were not removed.\n"));

	}

	return 0;

}

static int undo_eattr_indir_or_leaf(struct gfs2_inode *ip, uint64_t block,

				    uint64_t parent,

				    struct gfs2_buffer_head **bh,

				    void *private)

{

	struct gfs2_sbd *sdp = ip->i_sbd;

	int q;

	int error;

	struct block_count *bc = (struct block_count *) private;

	if (!valid_block_ip(ip, block))

		return meta_error;

	/* Need to check block_type before undoing the reference, which can

	   set it to free, which would cause the test below to fail. */

	q = block_type(bl, block);

	error = undo_reference(ip, block, 0, private);

	if (error)

		return error;

	bc->ea_count--;

	if (q != (sdp->gfs1 ? GFS2_BLKST_DINODE : GFS2_BLKST_USED))

		return 1;

	*bh = bread(sdp, block);

	return 0;

}

/* complain_eas - complain about extended attribute errors for an inode

 *

 * @ip       - in core inode pointer

 * block     - the block that had the problem

 * duplicate - if this is a duplicate block, don't set it "free"

 * emsg      - what to tell the user about the eas being checked

 * Returns: 1 if the EA is fixed, else 0 if it was not fixed.

 */

static void complain_eas(struct gfs2_inode *ip, uint64_t block,

			 const char *emsg)

{

	log_err(_("Inode #%llu (0x%llx): %s"),

		(unsigned long long)ip->i_di.di_num.no_addr,

		(unsigned long long)ip->i_di.di_num.no_addr, emsg);

	log_err(_(" at block #%lld (0x%llx).\n"),

		 (unsigned long long)block, (unsigned long long)block);

}

static int check_eattr_indir(struct gfs2_inode *ip, uint64_t indirect,

			     uint64_t parent, struct gfs2_buffer_head **bh,

			     void *private)

{

	struct gfs2_sbd *sdp = ip->i_sbd;

	int ret = 0;

	int q;

	struct block_count *bc = (struct block_count *) private;

	/* This inode contains an eattr - it may be invalid, but the

	 * eattr attributes points to a non-zero block */

	if (!valid_block_ip(ip, indirect)) {

		/* Doesn't help to mark this here - this gets checked

		 * in pass1c */

		return 1;

	}

	q = block_type(bl, indirect);

	/* Special duplicate processing:  If we have an EA block,

	   check if it really is an EA.  If it is, let duplicate

	   handling sort it out.  If it isn't, clear it but don't

	   count it as a duplicate. */

	*bh = bread(sdp, indirect);

	if (gfs2_check_meta(*bh, GFS2_METATYPE_IN)) {

		bc->ea_count++;

		if (q != GFS2_BLKST_FREE) { /* Duplicate? */

			add_duplicate_ref(ip, indirect, ref_as_ea, 0,

					  INODE_VALID);

			complain_eas(ip, indirect,

				     _("Bad indirect Extended Attribute "

				       "duplicate found"));

			/* Return 0 here because if all that's wrong is a

			   duplicate block reference, we want pass1b to figure

			   it out. We don't want to delete all the extended

			   attributes as if they are in error. */

			return 0;

		}

		complain_eas(ip, indirect,

			     _("Extended Attribute indirect block has "

			       "incorrect type"));

		return 1;

	}

	if (q != GFS2_BLKST_FREE) { /* Duplicate? */

		add_duplicate_ref(ip, indirect, ref_as_ea, 0, INODE_VALID);

		complain_eas(ip, indirect,

			     _("Duplicate Extended Attribute indirect block"));

		bc->ea_count++;

		ret = 0; /* For the same reason stated above. */

	} else {

		fsck_blockmap_set(ip, indirect,

				  _("indirect Extended Attribute"), sdp->gfs1 ?

				  GFS2_BLKST_DINODE : GFS2_BLKST_USED);

		bc->ea_count++;

	}

	return ret;

}

static int finish_eattr_indir(struct gfs2_inode *ip, int leaf_pointers,

			      int leaf_pointer_errors, void *private)

{

	struct block_count *bc = (struct block_count *) private;

	if (leaf_pointer_errors == leaf_pointers) /* All eas were bad */

		return ask_remove_inode_eattr(ip, bc);

	log_debug( _("Marking inode #%llu (0x%llx) with extended "

		     "attribute block\n"),

		   (unsigned long long)ip->i_di.di_num.no_addr,

		   (unsigned long long)ip->i_di.di_num.no_addr);

	if (!leaf_pointer_errors)

		return 0;

	log_err( _("Inode %lld (0x%llx) has recoverable indirect "

		   "Extended Attribute errors.\n"),

		   (unsigned long long)ip->i_di.di_num.no_addr,

		   (unsigned long long)ip->i_di.di_num.no_addr);

	if (query( _("Okay to fix the block count for the inode? (y/n) "))) {

		ip->i_di.di_blocks = 1 + bc->indir_count +

			bc->data_count + bc->ea_count;

		bmodified(ip->i_bh);

		log_err(_("Block count fixed: 1+%lld+%lld+%lld = %lld.\n"),

			(unsigned long long)bc->indir_count,

			(unsigned long long)bc->data_count,

			(unsigned long long)bc->ea_count,

			(unsigned long long)ip->i_di.di_blocks);

		return 1;

	}

	log_err( _("Block count not fixed.\n"));

	return 1;

}

/* check_ealeaf_block

 *      checks an extended attribute (not directory) leaf block

 */

static int check_ealeaf_block(struct gfs2_inode *ip, uint64_t block, int btype,

			      struct gfs2_buffer_head **bh, void *private)

{

	struct gfs2_buffer_head *leaf_bh = NULL;

	struct gfs2_sbd *sdp = ip->i_sbd;

	int q;

	struct block_count *bc = (struct block_count *) private;

	q = block_type(bl, block);

	/* Special duplicate processing:  If we have an EA block, check if it

	   really is an EA.  If it is, let duplicate handling sort it out.

	   If it isn't, clear it but don't count it as a duplicate. */

	leaf_bh = bread(sdp, block);

	if (gfs2_check_meta(leaf_bh, btype)) {

		bc->ea_count++;

		if (q != GFS2_BLKST_FREE) { /* Duplicate? */

			add_duplicate_ref(ip, block, ref_as_ea, 0,

					  INODE_VALID);

			complain_eas(ip, block, _("Extended attribute leaf "

						  "duplicate found"));

			/* Return 0 here because if all that's wrong is a

			   duplicate block reference, we want pass1b to figure

			   it out. We don't want to delete all the extended

			   attributes as if they are in error. */

			return 0;

		}

		complain_eas(ip, block, _("Extended Attribute leaf block has "

					  "incorrect type"));

		brelse(leaf_bh);

		return 1;

	}

	if (q != GFS2_BLKST_FREE) { /* Duplicate? */

		complain_eas(ip, block, _("Extended Attribute leaf "

					  "duplicate found"));

		add_duplicate_ref(ip, block, ref_as_data, 0, INODE_VALID);

		bc->ea_count++;

		brelse(leaf_bh);

		/* Return 0 here because if all that's wrong is a duplicate

		   block reference, we want pass1b to figure it out. We don't

		   want to delete all the extended attributes as if they are

		   in error. */

		return 0;

	}

	/* Point of confusion: We've got to set the ea block itself to

	   GFS2_BLKST_USED here.  Elsewhere we mark the inode with

	   gfs2_eattr_block meaning it contains an eattr. */

	fsck_blockmap_set(ip, block, _("Extended Attribute"),

			  sdp->gfs1 ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);

	bc->ea_count++;

	*bh = leaf_bh;

	return 0;

}

/**

 * check_extended_leaf_eattr

 * @ip

 * @el_blk: block number of the extended leaf

 *

 * An EA leaf block can contain EA's with pointers to blocks

 * where the data for that EA is kept.  Those blocks still

 * have the gfs2 meta header of type GFS2_METATYPE_EA

 *