#include "clusterautoconfig.h"

#include <dirent.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <inttypes.h>

#include <sys/stat.h>

#include <libintl.h>

#define _(String) gettext(String)

#include <logging.h>

#include "libgfs2.h"

#include "fsck.h"

#include "util.h"

#include "metawalk.h"

#include "link.h"

#include "lost_n_found.h"

#include "inode_hash.h"

#include "afterpass1_common.h"

#define MAX_FILENAME 256

struct metawalk_fxns pass2_fxns;

struct metawalk_fxns delete_eattrs = {

	.check_eattr_indir = delete_eattr_indir,

	.check_eattr_leaf = delete_eattr_leaf,

	.check_eattr_entry = delete_eattr_entry,

	.check_eattr_extentry = delete_eattr_extentry,

};

/* Set children's parent inode in dir_info structure - ext2 does not set

 * dotdot inode here, but instead in pass3 - should we? */

static int set_parent_dir(struct gfs2_sbd *sdp, struct gfs2_inum child,

			  struct gfs2_inum parent)

{

	struct dir_info *di;

	di = dirtree_find(child.no_addr);

	if (!di) {

		log_err( _("Unable to find block %llu (0x%llx"

			   ") in dir_info list\n"),

			(unsigned long long)child.no_addr,

			(unsigned long long)child.no_addr);

		return -1;

	}

	if (di->dinode.no_addr == child.no_addr &&

	    di->dinode.no_formal_ino == child.no_formal_ino) {

		if (di->treewalk_parent) {

			log_err( _("Another directory at block %lld (0x%llx) "

				   "already contains this child %lld (0x%llx)"

				   " - checking parent %lld (0x%llx)\n"),

				 (unsigned long long)di->treewalk_parent,

				 (unsigned long long)di->treewalk_parent,

				 (unsigned long long)child.no_addr,

				 (unsigned long long)child.no_addr,

				 (unsigned long long)parent.no_addr,

				 (unsigned long long)parent.no_addr);

			return 1;

		}

		log_debug( _("Child %lld (0x%llx) has parent %lld (0x%llx)\n"),

			   (unsigned long long)child.no_addr,

			   (unsigned long long)child.no_addr,

			   (unsigned long long)parent.no_addr,

			   (unsigned long long)parent.no_addr);

		di->treewalk_parent = parent.no_addr;

	}

	return 0;

}

/* Set's the child's '..' directory inode number in dir_info structure */

static int set_dotdot_dir(struct gfs2_sbd *sdp, uint64_t childblock,

			  struct gfs2_inum parent)

{

	struct dir_info *di;

	di = dirtree_find(childblock);

	if (!di) {

		log_err( _("Unable to find block %"PRIu64" (0x%" PRIx64

			   ") in dir_info tree\n"), childblock, childblock);

		return -1;

	}

	if (di->dinode.no_addr != childblock) {

		log_debug("'..' doesn't point to what we found: childblock "

			  "(0x%llx) != dinode (0x%llx)\n",

			  (unsigned long long)childblock,

			  (unsigned long long)di->dinode.no_addr);

		return -1;

	}

	/* Special case for root inode because we set it earlier */

	if (di->dotdot_parent.no_addr &&

	    sdp->md.rooti->i_di.di_num.no_addr != di->dinode.no_addr) {

		/* This should never happen */

		log_crit( _("Dotdot parent already set for block %llu (0x%llx)"

			    "-> %llu (0x%llx)\n"),

			  (unsigned long long)childblock,

			  (unsigned long long)childblock,

			  (unsigned long long)di->dotdot_parent.no_addr,

			  (unsigned long long)di->dotdot_parent.no_addr);

		return -1;

	}

	log_debug("Setting '..' for directory block (0x%llx) to parent "

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

		  (unsigned long long)parent.no_addr);

	di->dotdot_parent.no_addr = parent.no_addr;

	di->dotdot_parent.no_formal_ino = parent.no_formal_ino;

	return 0;

}

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

			     uint64_t parent, struct gfs2_buffer_head **bh,

			     void *private)

{

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

	return 0;

}

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

			    uint64_t parent, struct gfs2_buffer_head **bh,

			    void *private)

{

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

	return 0;

}

static const char *de_type_string(uint8_t de_type)

{

	const char *de_types[15] = {"unknown", "fifo", "chrdev", "invalid",

				    "directory", "invalid", "blkdev", "invalid",

				    "file", "invalid", "symlink", "invalid",

				    "socket", "invalid", "wht"};

	if (de_type < 15)

		return de_types[de_type];

	return de_types[3]; /* invalid */

}

static int check_file_type(uint64_t block, uint8_t de_type, int q,

			   int gfs1, int *isdir)

{

	struct dir_info *dt;

	*isdir = 0;

	if (q != GFS2_BLKST_DINODE) {

		log_err( _("Invalid block type\n"));

		return -1;

	}

	if (de_type == (gfs1 ? GFS_FILE_DIR : DT_DIR))

		*isdir = 1;

	/* Check if the dinode is in the dir tree */

	dt = dirtree_find(block);

	/* This is a bit confusing, so let me explain:

	   If the dirent says the inode supposed to be for a directory,

	   it should be in the dir tree. If it is, no problem, return 0.

	   If it's not, return 1 (wrong type). If it's not supposed to be

	   a directory, it shouldn't be in the dir tree. */

	if (dt)

		return !(*isdir);

	return *isdir;

}

struct metawalk_fxns pass2_fxns_delete = {

	.private = NULL,

	.check_metalist = delete_metadata,

	.check_data = delete_data,

	.check_leaf = delete_leaf,

	.check_eattr_indir = delete_eattr_indir,

	.check_eattr_leaf = delete_eattr_leaf,

	.check_eattr_entry = delete_eattr_entry,

	.check_eattr_extentry = delete_eattr_extentry,

};

/* bad_formal_ino - handle mismatches in formal inode number

 * Returns: 0 if the dirent was repaired

 *          1 if the caller should delete the dirent

 */

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

			  struct gfs2_inum entry, const char *tmp_name,

			  int q, struct gfs2_dirent *de,

			  struct gfs2_buffer_head *bh)

{

	struct inode_info *ii;

	struct dir_info *di = NULL;

	struct gfs2_inode *child_ip;

	struct gfs2_inum childs_dotdot;

	struct gfs2_sbd *sdp = ip->i_sbd;

	int error;

	struct gfs2_inum inum = { 0 };

	ii = inodetree_find(entry.no_addr);

	if (ii)

		inum = ii->di_num;

	else {

		di = dirtree_find(entry.no_addr);

		if (di)

			inum = di->dinode;

		else if (link1_type(&clink1map, entry.no_addr) == 1) {

			struct gfs2_inode *dent_ip;

			dent_ip = fsck_load_inode(ip->i_sbd, entry.no_addr);

			inum = dent_ip->i_di.di_num;

			fsck_inode_put(&dent_ip);

		}

	}

	log_err( _("Directory entry '%s' pointing to block %llu (0x%llx) in "

		   "directory %llu (0x%llx) has the wrong 'formal' inode "

		   "number.\n"), tmp_name, (unsigned long long)entry.no_addr,

		 (unsigned long long)entry.no_addr,

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

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

	log_err( _("The directory entry has %llu (0x%llx) but the inode has "

		   "%llu (0x%llx)\n"), (unsigned long long)entry.no_formal_ino,

		 (unsigned long long)entry.no_formal_ino,

		 (unsigned long long)inum.no_formal_ino,

		 (unsigned long long)inum.no_formal_ino);

	if (q != GFS2_BLKST_DINODE || !strcmp("..", tmp_name)) {

		if (query( _("Remove the corrupt directory entry? (y/n) ")))

			return 1;

		log_err( _("Corrupt directory entry not removed.\n"));

		return 0;

	}

	/* We have a directory pointing to another directory, but the

	   formal inode number still doesn't match. If that directory

	   has a '..' pointing back, just fix up the no_formal_ino. */

	child_ip = lgfs2_inode_read(sdp, entry.no_addr);

	error = dir_search(child_ip, "..", 2, NULL, &childs_dotdot);

	if (!error && childs_dotdot.no_addr == ip->i_di.di_num.no_addr) {

		log_err( _("The entry points to another directory with intact "

			   "linkage.\n"));

		if (query( _("Fix the bad directory entry? (y/n) "))) {

			log_err( _("Fixing the corrupt directory entry.\n"));

			entry.no_formal_ino = inum.no_formal_ino;

			de->de_inum.no_formal_ino = entry.no_formal_ino;

			gfs2_dirent_out(de, (char *)dent);

			bmodified(bh);

			incr_link_count(entry, ip, _("fixed reference"));

			set_parent_dir(sdp, entry, ip->i_di.di_num);

		} else {

			log_err( _("Directory entry not fixed.\n"));

		}

	} else {

		if (query( _("Remove the corrupt directory entry? (y/n) "))) {

			inode_put(&child_ip);

			return 1;

		}

		log_err( _("Corrupt directory entry not removed.\n"));

	}

	inode_put(&child_ip);

	return 0;

}

static int hash_table_index(uint32_t hash, struct gfs2_inode *ip)

{

	return hash >> (32 - ip->i_di.di_depth);

}

static int hash_table_max(int lindex, struct gfs2_inode *ip,

		   struct gfs2_buffer_head *bh)

{

	struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;

	return (1 << (ip->i_di.di_depth - be16_to_cpu(leaf->lf_depth))) +

		lindex - 1;

}

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

			    int ref_count, struct gfs2_buffer_head *lbh)

{

	struct gfs2_leaf *leaf = (struct gfs2_leaf *)lbh->b_data;

	int cur_depth = be16_to_cpu(leaf->lf_depth);

	int exp_count = 1 << (ip->i_di.di_depth - cur_depth);

	int divisor;

	int factor, correct_depth;

	if (exp_count == ref_count)

		return 0;

	factor = 0;

	divisor = ref_count;

	while (divisor > 1) {

		factor++;

		divisor >>= 1;

	}

	if (ip->i_di.di_depth < factor) /* can't be fixed--leaf must be on the

					   wrong dinode. */

		return -1;

	correct_depth = ip->i_di.di_depth - factor;

	if (cur_depth == correct_depth)

		return 0;

	log_err(_("Leaf block %llu (0x%llx) in dinode %llu (0x%llx) has the "

		  "wrong depth: is %d (length %d), should be %d (length "

		  "%d).\n"),

		(unsigned long long)leaf_no, (unsigned long long)leaf_no,

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

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

		cur_depth, ref_count, correct_depth, exp_count);

	if (!query( _("Fix the leaf block? (y/n)"))) {

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

		return 0;

	}

	leaf->lf_depth = cpu_to_be16(correct_depth);

	bmodified(lbh);

	log_err( _("The leaf block depth was fixed.\n"));

	return 1;

}

/* wrong_leaf: Deal with a dirent discovered to be on the wrong leaf block

 *

 * Returns: 1 if the dirent is to be removed, 0 if it needs to be kept,

 *          or -1 on error

 */

static int wrong_leaf(struct gfs2_inode *ip, struct gfs2_inum *entry,

		      const char *tmp_name, int *lindex, int lindex_max,

		      int hash_index, struct gfs2_buffer_head *bh,

		      struct dir_status *ds, struct gfs2_dirent *dent,

		      struct gfs2_dirent *de, struct gfs2_dirent *prev_de,

		      uint32_t *count, int q)

{

	struct gfs2_sbd *sdp = ip->i_sbd;

	struct gfs2_buffer_head *dest_lbh;

	uint64_t planned_leaf, real_leaf;

	int li, dest_ref, error;

	uint64_t *tbl;

	int di_depth;

	log_err(_("Directory entry '%s' at block %lld (0x%llx) is on the "

		  "wrong leaf block.\n"), tmp_name,

		(unsigned long long)entry->no_addr,

		(unsigned long long)entry->no_addr);

	log_err(_("Leaf index is: 0x%x. The range for this leaf block is "

		  "0x%x - 0x%x\n"), hash_index, *lindex, lindex_max);

	if (!query( _("Move the misplaced directory entry to "

		      "a valid leaf block? (y/n) "))) {

		log_err( _("Misplaced directory entry not moved.\n"));

		return 0;

	}

	/* check the destination leaf block's depth */

	tbl = get_dir_hash(ip);

	if (tbl == NULL) {

		perror("get_dir_hash");

		return -1;

	}

	planned_leaf = be64_to_cpu(tbl[hash_index]);

	log_err(_("Moving it from leaf %llu (0x%llx) to %llu (0x%llx)\n"),

		(unsigned long long)be64_to_cpu(tbl[*lindex]),

		(unsigned long long)be64_to_cpu(tbl[*lindex]),

		(unsigned long long)planned_leaf,

		(unsigned long long)planned_leaf);

	/* Can't trust lf_depth; we have to count */

	dest_ref = 0;

	for (li = 0; li < (1 << ip->i_di.di_depth); li++) {

		if (be64_to_cpu(tbl[li]) == planned_leaf)

			dest_ref++;

		else if (dest_ref)

			break;

	}

	dest_lbh = bread(sdp, planned_leaf);

	check_leaf_depth(ip, planned_leaf, dest_ref, dest_lbh);

	brelse(dest_lbh);

	free(tbl);

	/* check if it's already on the correct leaf block */

	error = dir_search(ip, tmp_name, de->de_name_len, NULL, &de->de_inum);

	if (!error) {

		log_err(_("The misplaced directory entry already appears on "

			  "the correct leaf block.\n"));

		log_err( _("The bad duplicate directory entry "

			   "'%s' was cleared.\n"), tmp_name);

		return 1; /* nuke the dent upon return */

	}

	di_depth = ip->i_di.di_depth;

	if (dir_add(ip, tmp_name, de->de_name_len, &de->de_inum,

		    de->de_type) == 0) {

		log_err(_("The misplaced directory entry was moved to a "

			  "valid leaf block.\n"));

		if (ip->i_di.di_depth > di_depth) {

			log_err(_("Directory hash table was doubled.\n"));

			hash_index <<= (ip->i_di.di_depth - di_depth);

			(*lindex) <<= (ip->i_di.di_depth - di_depth);

		}

		if (lgfs2_get_leaf_ptr(ip, hash_index, &real_leaf)) {

			log_err(_("Could not read leaf %d in dinode %"PRIu64": %s\n"), hash_index,

			        (uint64_t)ip->i_di.di_num.no_addr, strerror(errno));

		}

		if (real_leaf != planned_leaf) {

			log_err(_("The planned leaf was split. The new leaf "

				  "is: %llu (0x%llx). di_blocks=%llu\n"),

				(unsigned long long)real_leaf,

				(unsigned long long)real_leaf,

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

			fsck_bitmap_set(ip, real_leaf, _("split leaf"),

					sdp->gfs1 ? GFS2_BLKST_DINODE :

					GFS2_BLKST_USED);

		}

		/* If the misplaced dirent was supposed to be earlier in the

		   hash table, we need to adjust our counts for the blocks

		   that have already been processed. If it's supposed to

		   appear later, we'll count it has part of our normal

		   processing when we get to that leaf block later on in the

		   hash table. */

		if (hash_index > *lindex) {

			log_err(_("Accounting deferred.\n"));

			return 1; /* nuke the dent upon return */

		}

		/* If we get here, it's because we moved a dent to another

		   leaf, but that leaf has already been processed. So we have

		   to nuke the dent from this leaf when we return, but we

		   still need to do the "good dent" accounting. */

		if (de->de_type == (sdp->gfs1 ? GFS_FILE_DIR : DT_DIR)) {

			error = set_parent_dir(sdp, de->de_inum,

					       ip->i_di.di_num);

			if (error > 0)

				/* This is a bit of a kludge, but returning 0

				   in this case causes the caller to go through

				   function set_parent_dir a second time and

				   deal properly with the hard link. */

				return 0;

		}

		error = incr_link_count(*entry, ip,

					_("moved valid reference"));

		if (error > 0 &&

		    bad_formal_ino(ip, dent, *entry, tmp_name, q, de, bh) == 1)

			return 1; /* nuke it */

		/* You cannot do this:

		   (*count)++;

		   The reason is: *count is the count of dentries on the leaf,

		   and we moved the dentry to a previous leaf within the same

		   directory dinode. So the directory counts still get

		   incremented, but not leaf entries. When we called dir_add

		   above, it should have fixed that prev leaf's lf_entries. */

		ds->entry_count++;

		return 1;

	} else {

		log_err(_("Error moving directory entry.\n"));

		return 1; /* nuke it */

	}

}

/* basic_dentry_checks - fundamental checks for directory entries

 *

 * @ip: pointer to the incode inode structure

 * @entry: pointer to the inum info

 * @tmp_name: user-friendly file name

 * @count: pointer to the entry count

 * @de: pointer to the directory entry

 *

 * Returns: 1 means corruption, nuke the dentry, 0 means checks pass

 */

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

			       struct gfs2_inum *entry, const char *tmp_name,

			       uint32_t *count, struct gfs2_dirent *de,

			       struct dir_status *ds, int *q,

			       struct gfs2_buffer_head *bh, int *isdir)

{

	struct gfs2_sbd *sdp = ip->i_sbd;

	uint32_t calculated_hash;

	struct gfs2_inode *entry_ip = NULL;

	int error;

	struct inode_info *ii;

	struct dir_info *di = NULL;

	struct gfs2_inum inum = { 0 };

	*isdir = 0;

	if (!valid_block_ip(ip, entry->no_addr)) {

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

			   "%lld (0x%llx) is invalid\n"),

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

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

		if (query( _("Clear directory entry to out of range block? "

			    "(y/n) "))) {

			return 1;

		} else {

			log_err( _("Directory entry to out of range block remains\n"));

			(*count)++;

			ds->entry_count++;

			/* can't do this because the block is out of range:

			   incr_link_count(entry); */

			return 0;

		}

	}

	if (de->de_rec_len < GFS2_DIRENT_SIZE(de->de_name_len) ||

	    de->de_name_len > GFS2_FNAMESIZE) {

		log_err( _("Dir entry with bad record or name length\n"

			"\tRecord length = %u\n\tName length = %u\n"),

			de->de_rec_len, de->de_name_len);

		if (!query( _("Clear the directory entry? (y/n) "))) {

			log_err( _("Directory entry not fixed.\n"));

			return 0;

		}

		/* Don't be tempted to do this:

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

				_("corrupt directory entry"),

				GFS2_BLKST_FREE);

		We can't free it because another dir may have a valid reference

		to it. Just return 1 so we can delete the bad dirent. */

		log_err( _("Bad directory entry deleted.\n"));

		return 1;

	}

	calculated_hash = gfs2_disk_hash(tmp_name, de->de_name_len);

	if (de->de_hash != calculated_hash){

	        log_err( _("Dir entry with bad hash or name length\n"

			   "\tHash found         = %u (0x%x)\n"

			   "\tFilename           = %s\n"),

			 de->de_hash, de->de_hash, tmp_name);

		log_err( _("\tName length found  = %u\n"

			   "\tHash expected      = %u (0x%x)\n"),

			 de->de_name_len, calculated_hash, calculated_hash);

		if (!query( _("Fix directory hash for %s? (y/n) "),

			   tmp_name)) {

			log_err( _("Directory entry hash for %s not "

				   "fixed.\n"), tmp_name);

			return 0;

		}

		de->de_hash = calculated_hash;

		gfs2_dirent_out(de, (char *)dent);

		bmodified(bh);

		log_err( _("Directory entry hash for %s fixed.\n"),

			 tmp_name);

	}

	*q = bitmap_type(sdp, entry->no_addr);

	/* Get the status of the directory inode */

	/**

	 * 1. Blocks marked "invalid" were invalidated due to duplicate

	 * block references.  Pass1b should have already taken care of deleting

	 * their metadata, so here we only need to delete the directory entries

	 * pointing to them.  We delete the metadata in pass1b because we need

	 * to eliminate the inode referencing the duplicate-referenced block

	 * from the list of candidates to keep.  So we have a delete-as-we-go

	 * policy.

	 *

	 * 2. Blocks marked "bad" need to have their entire

	 * metadata tree deleted.

	*/

	if (*q != GFS2_BLKST_DINODE) {

		log_err( _("Directory entry '%s' referencing inode %llu "

			   "(0x%llx) in dir inode %llu (0x%llx) block type "

			   "%d: %s.\n"), tmp_name,

			 (unsigned long long)entry->no_addr,

			 (unsigned long long)entry->no_addr,

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

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

			 *q, *q == GFS2_BLKST_FREE ?

			 _("was previously marked invalid") :

			 _("was deleted or is not an inode"));

		if (!query( _("Clear directory entry to non-inode block? "

			     "(y/n) "))) {

			log_err( _("Directory entry to non-inode block remains\n"));

			return 0;

		}

		/* Don't decrement the link here: Here in pass2, we increment

		   only when we know it's okay.

		   decr_link_count(ip->i_di.di_num.no_addr, blah); */

		/* If it was previously marked invalid (i.e. known

		   to be bad, not just a free block, etc.) then the temptation

		   would be to delete any metadata it holds.  The trouble is:

		   if it's invalid, we may or _may_not_ have traversed its

		   metadata tree, and therefore may or may not have marked the

		   blocks it points to as a metadata type, or as a duplicate.

		   If there is really a duplicate reference, but we didn't

		   process the metadata tree because it's invalid, some other

		   inode has a reference to the metadata block, in which case

		   freeing it would do more harm than good.  IOW we cannot

		   count on "delete_block_if_notdup" knowing whether it's

		   really a duplicate block if we never traversed the metadata

		   tree for the invalid inode. */

		return 1;

	}

	error = check_file_type(entry->no_addr, de->de_type, *q, sdp->gfs1,

				isdir);

	if (error < 0) {

		log_err( _("Error: directory entry type is "

			   "incompatible with block type at block %lld "

			   "(0x%llx) in directory inode %llu (0x%llx).\n"),

			 (unsigned long long)entry->no_addr,

			 (unsigned long long)entry->no_addr,

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

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

		log_err( _("Directory entry type is %d, block type is %d.\n"),

			 de->de_type, *q);

		stack;

		return -1;

	}

	if (error > 0) {

		log_err( _("Type '%s' in dir entry (%s, %llu/0x%llx) conflicts"

			 " with type '%s' in dinode. (Dir entry is stale.)\n"),

			 de_type_string(de->de_type), tmp_name,

			 (unsigned long long)entry->no_addr,

			 (unsigned long long)entry->no_addr,

			 block_type_string(*q));

		if (!query( _("Clear stale directory entry? (y/n) "))) {

			log_err( _("Stale directory entry remains\n"));

			return 0;

		}

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

			entry_ip = ip;

		else

			entry_ip = fsck_load_inode(sdp, entry->no_addr);

		check_inode_eattr(entry_ip, &delete_eattrs);

		if (entry_ip != ip)

			fsck_inode_put(&entry_ip);

		return 1;

	}

	/* We need to verify the formal inode number matches. If it doesn't,

	   it needs to be deleted. */

	ii = inodetree_find(entry->no_addr);

	if (ii)

		inum = ii->di_num;

	else {

		di = dirtree_find(entry->no_addr);

		if (di)

			inum = di->dinode;

		else if (link1_type(&nlink1map, entry->no_addr) == 1) {

			/* Since we don't have ii or di, the only way to

			   validate formal_ino is to read in the inode, which

			   would kill performance. So skip it for now. */

			return 0;

		}

	}

	if (inum.no_formal_ino != entry->no_formal_ino) {

		log_err( _("Directory entry '%s' pointing to block %llu "

			   "(0x%llx) in directory %llu (0x%llx) has the "

			   "wrong 'formal' inode number.\n"), tmp_name,

			 (unsigned long long)entry->no_addr,

			 (unsigned long long)entry->no_addr,

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

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

		log_err( _("The directory entry has %llu (0x%llx) but the "

			   "inode has %llu (0x%llx)\n"),

			 (unsigned long long)entry->no_formal_ino,

			 (unsigned long long)entry->no_formal_ino,

			 (unsigned long long)inum.no_formal_ino,

			 (unsigned long long)inum.no_formal_ino);

		return 1;

	}

	/* Check for a special case where a (bad) GFS1 dirent points to what

	 * is not a known inode. It could be other GFS1 metadata, such as an

	 * eattr or indirect block, but marked "dinode" in the bitmap because

	 * gfs1 marked all gfs1 metadata that way. */

	if (ii == NULL && di == NULL && sdp->gfs1) {

		struct gfs2_buffer_head *tbh;

		tbh = bread(sdp, entry->no_addr);

		if (gfs2_check_meta(tbh, GFS2_METATYPE_DI)) { /* not dinode */

			log_err( _("Directory entry '%s' pointing to block "

				   "%llu (0x%llx) in directory %llu (0x%llx) "

				   "is not really a GFS1 dinode.\n"), tmp_name,

			 (unsigned long long)entry->no_addr,

			 (unsigned long long)entry->no_addr,

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

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

			brelse(tbh);

			return 1;

		}

		brelse(tbh);

	}

	return 0;

}

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

		       struct gfs2_dirent *prev, struct gfs2_buffer_head *bh,

		       char *filename, uint32_t *count, int *lindex,

		       void *private)

{

	/* the metawalk_fxn's private field must be set to the dentry

	 * block we want to clear */

	struct gfs2_inum *entry = (struct gfs2_inum *)private;

	struct gfs2_dirent dentry, *de;

	char fn[MAX_FILENAME];

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

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

	de = &dentry;

	if (de->de_inum.no_addr != entry->no_addr) {

		(*count)++;

		return 0;

	}

	if (de->de_inum.no_formal_ino == dent->de_inum.no_formal_ino) {

		log_debug("Formal inode number matches; must be a hard "

			  "link.\n");

		goto out;

	}

	log_err(_("The original reference to inode %lld (0x%llx) from "

		  "directory %lld (0x%llx) has the wrong 'formal' inode "

		  "number.\n"), (unsigned long long)entry->no_addr,

		(unsigned long long)entry->no_addr,

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

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

	memset(fn, 0, sizeof(fn));

	if (de->de_name_len < MAX_FILENAME)

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

	else

		strncpy(fn, filename, MAX_FILENAME - 1);

	log_err(_("The bad reference '%s' had formal inode number: %lld "

		  "(0x%llx) but the correct value is: %lld (0x%llx)\n"),

		fn, (unsigned long long)de->de_inum.no_formal_ino,

		(unsigned long long)de->de_inum.no_formal_ino,

		(unsigned long long)entry->no_formal_ino,

		(unsigned long long)entry->no_formal_ino);

	if (!query(_("Delete the bad directory entry? (y/n) "))) {

		log_err(_("The corrupt directory entry was not fixed.\n"));

		goto out;

	}

	decr_link_count(entry->no_addr, ip->i_di.di_num.no_addr,

			ip->i_sbd->gfs1, _("bad original reference"));

	dirent2_del(ip, bh, prev, dent);

	log_err(_("The corrupt directory entry '%s' was deleted.\n"), fn);

out:

	return -1; /* force check_dir to stop; don't waste time. */

}

/**

 * check_suspicious_dirref - double-check a questionable first dentry ref

 *

 * This function is called when a dentry has caused us to increment the

 * link count to a file from 1 to 2, and we know the object pointed to is

 * not a directory. (Most likely, it'a a file). The second directory to

 * reference the dinode has the correct formal inode number, but when we

 * created the original reference in the counted links bitmap (clink1map),

 * we had no way to check the formal inode number. (Well, we could have read

 * in the dinode, but that would kill fsck.gfs2 performance.)

 * So now we have to walk through the directory tree and find that original

 * reference so make sure it's a valid reference. If the formal inode number

 * is the same, it's a hard link (which is unlikely for gfs2). If it's not

 * the same, that's an error, and we need to delete the damaged original

 * dentry, since we failed to detect the problem earlier.

 */

static int check_suspicious_dirref(struct gfs2_sbd *sdp,

				   struct gfs2_inum *entry)

{

	struct osi_node *tmp, *next = NULL;

	struct dir_info *dt;

	struct gfs2_inode *ip;

	uint64_t dirblk;

	int error = FSCK_OK;

	struct metawalk_fxns dirref_hunt = {

		.private = (void *)entry,

		.check_dentry = dirref_find,

	};

	log_debug("This dentry is good, but since this is a second "

		  "reference to block 0x%llx, we need to check the "

		  "original.\n", (unsigned long long)entry->no_addr);

	for (tmp = osi_first(&dirtree); tmp; tmp = next) {

		next = osi_next(tmp);

		dt = (struct dir_info *)tmp;

		dirblk = dt->dinode.no_addr;

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

			break;

		ip = fsck_load_inode(sdp, dirblk);

		if (ip == NULL) {

			stack;

			return FSCK_ERROR;

		}

		error = check_dir(sdp, ip, &dirref_hunt);

		fsck_inode_put(&ip);

		/* Error just means we found the dentry and dealt with it. */

		if (error)

			break;

	}

	log_debug("Original reference check complete. Found = %d.\n",

		  error ? 1 : 0);

	return 0;

}

/* FIXME: should maybe refactor this a bit - but need to deal with

 * FIXMEs internally first */

static int check_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;

	int q = 0;

	char tmp_name[MAX_FILENAME];

	struct gfs2_inum entry;

	struct dir_status *ds = (struct dir_status *) priv;

	int error;

	struct gfs2_inode *entry_ip = NULL;

	struct gfs2_dirent dentry, *de;

	int hash_index; /* index into the hash table based on the hash */

	int lindex_max; /* largest acceptable hash table index for hash */

	int isdir;

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

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

	de = &dentry;

	entry.no_addr = de->de_inum.no_addr;

	entry.no_formal_ino = de->de_inum.no_formal_ino;

	/* Start of checks */

	memset(tmp_name, 0, MAX_FILENAME);

	if (de->de_name_len < MAX_FILENAME)

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

	else

		strncpy(tmp_name, filename, MAX_FILENAME - 1);

	error = basic_dentry_checks(ip, dent, &entry, tmp_name, count, de,

				    ds, &q, bh, &isdir);

	if (error)

		goto nuke_dentry;

	if (!strcmp(".", tmp_name)) {

		log_debug( _("Found . dentry in directory %lld (0x%llx)\n"),

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

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

		if (ds->dotdir) {

			log_err( _("Already found '.' entry in directory %llu"

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

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

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

			if (!query( _("Clear duplicate '.' entry? (y/n) "))) {

				log_err( _("Duplicate '.' entry remains\n"));

				/* FIXME: Should we continue on here

				 * and check the rest of the '.' entry? */

				goto dentry_is_valid;

			}

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

				entry_ip = ip;

			else

				entry_ip = fsck_load_inode(sdp, entry.no_addr);

			check_inode_eattr(entry_ip, &delete_eattrs);

			if (entry_ip != ip)

				fsck_inode_put(&entry_ip);

			goto nuke_dentry;

		}

		/* GFS2 does not rely on '.' being in a certain

		 * location */

		/* check that '.' refers to this inode */

		if (entry.no_addr != ip->i_di.di_num.no_addr) {

			log_err( _("'.' entry's value incorrect in directory %llu"

				" (0x%llx).  Points to %llu"

				" (0x%llx) when it should point to %llu"

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

				(unsigned long long)entry.no_addr,

				(unsigned long long)entry.no_addr,

				(unsigned long long)entry.no_addr,

				(unsigned long long)entry.no_addr,

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

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

			if (!query( _("Remove '.' reference? (y/n) "))) {

				log_err( _("Invalid '.' reference remains\n"));

				/* Not setting ds->dotdir here since

				 * this '.' entry is invalid */

				goto dentry_is_valid;

			}

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

				entry_ip = ip;

			else

				entry_ip = fsck_load_inode(sdp, entry.no_addr);

			check_inode_eattr(entry_ip, &delete_eattrs);

			if (entry_ip != ip)

				fsck_inode_put(&entry_ip);

			goto nuke_dentry;

		}

		ds->dotdir = 1;

		goto dentry_is_valid;

	}

	if (!strcmp("..", tmp_name)) {

		log_debug( _("Found '..' dentry in directory %lld (0x%llx)\n"),

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

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

		if (ds->dotdotdir) {

			log_err( _("Already had a '..' entry in directory %llu"