#include "clusterautoconfig.h"

#include <inttypes.h>

#include <stdlib.h>

#include <stdint.h>

#include <string.h>

#include <unistd.h>

#include <libintl.h>

#define _(String) gettext(String)

#include <logging.h>

#include "libgfs2.h"

#include "fsck.h"

#include "inode_hash.h"

#include "link.h"

#include "util.h"

struct gfs2_bmap nlink1map = { 0 }; /* map of dinodes with nlink == 1 */

struct gfs2_bmap clink1map = { 0 }; /* map of dinodes w/counted links == 1 */

int link1_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_SIZE1(bblock);

	b = BLOCKMAP_BYTE_OFFSET1(bblock);

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

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

	return 0;

}

int set_di_nlink(struct gfs2_inode *ip)

{

	struct inode_info *ii;

	struct dir_info *di;

	if (is_dir(&ip->i_di, ip->i_sbd->gfs1)) {

		di = dirtree_find(ip->i_di.di_num.no_addr);

		if (di == NULL) {

			log_err(_("Error: directory %lld (0x%llx) is not "

				  "in the dir_tree (set).\n"),

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

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

			return -1;

		}

		di->di_nlink = ip->i_di.di_nlink;

		return 0;

	}

	if (ip->i_di.di_nlink == 1) {

		link1_set(&nlink1map, ip->i_di.di_num.no_addr, 1);

		return 0;

	}

	/*log_debug( _("Setting link count to %u for %" PRIu64

	  " (0x%" PRIx64 ")\n"), count, inode_no, inode_no);*/

	/* If the list has entries, look for one that matches inode_no */

	ii = inodetree_find(ip->i_di.di_num.no_addr);

	if (!ii)

		ii = inodetree_insert(ip->i_di.di_num);

	if (ii)

		ii->di_nlink = ip->i_di.di_nlink;

	else

		return -1;

	return 0;

}

/* I'm making whyincr a macro rather than function so that the debug output

 * matches older versions. */

#define whyincr(no_addr, why, referenced_from, counted_links)		\

	log_debug(_("Dir (0x%llx) incremented counted links to %u "	\

		    "for (0x%llx) via %s\n"),				\

		  (unsigned long long)referenced_from, counted_links,	\

		  (unsigned long long)no_addr, why);

int incr_link_count(struct gfs2_inum no, struct gfs2_inode *ip,

		    const char *why)

{

	struct inode_info *ii = NULL;

	uint64_t referenced_from = ip ? ip->i_di.di_num.no_addr : 0;

	struct dir_info *di;

	struct gfs2_inode *link_ip;

	di = dirtree_find(no.no_addr);

	if (di) {

		if (di->dinode.no_formal_ino != no.no_formal_ino)

			return incr_link_ino_mismatch;

		di->counted_links++;

		whyincr(no.no_addr, why, referenced_from, di->counted_links);

		return incr_link_good;

	}

	ii = inodetree_find(no.no_addr);

	/* If the list has entries, look for one that matches inode_no */

	if (ii) {

		if (ii->di_num.no_formal_ino != no.no_formal_ino)

			return incr_link_ino_mismatch;

		ii->counted_links++;

		whyincr(no.no_addr, why, referenced_from, ii->counted_links);

		return incr_link_good;

	}

	if (link1_type(&clink1map, no.no_addr) != 1) {

		link1_set(&clink1map, no.no_addr, 1);

		whyincr(no.no_addr, why, referenced_from, 1);

		return incr_link_good;

	}

	link_ip = fsck_load_inode(ip->i_sbd, no.no_addr);

	/* Check formal ino against dinode before adding to inode tree. */

	if (no.no_formal_ino != link_ip->i_di.di_num.no_formal_ino) {

		fsck_inode_put(&link_ip);

		return incr_link_ino_mismatch; /* inode mismatch */

	}

	/* Move it from the link1 maps to a real inode tree entry */

	link1_set(&nlink1map, no.no_addr, 0);

	link1_set(&clink1map, no.no_addr, 0);

	/* If no match was found, it must be a hard link. In theory, it can't

	   be a duplicate because those were resolved in pass1b. Add a new

	   inodetree entry and set its counted links to 2 */

	ii = inodetree_insert(no);

	if (!ii) {

		log_debug( _("Ref: (0x%llx) Error incrementing link for "

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

			   (unsigned long long)referenced_from,

			   (unsigned long long)no.no_addr);

		fsck_inode_put(&link_ip);

		return incr_link_bad;

	}

	ii->di_num = link_ip->i_di.di_num;

	fsck_inode_put(&link_ip);

	ii->di_nlink = 1; /* Must be 1 or it wouldn't have gotten into the

			     nlink1map */

	ii->counted_links = 2;

	whyincr(no.no_addr, why, referenced_from, ii->counted_links);

	/* We transitioned a dentry link count from 1 to 2, and we know it's

	   not a directory. But the new reference has the correct formal

	   inode number, so the first reference is suspect: we need to

	   check it in case it's a bad reference, and not just a hard link. */

	return incr_link_check_orig;

}

#define whydecr(no_addr, why, referenced_from, counted_links)		\

	log_debug(_("Dir (0x%llx) decremented counted links to %u "	\

		    "for (0x%llx) via %s\n"),				\

		  (unsigned long long)referenced_from, counted_links,	\

		  (unsigned long long)no_addr, why);

int decr_link_count(uint64_t inode_no, uint64_t referenced_from, int gfs1,

		    const char *why)

{

	struct inode_info *ii = NULL;

	struct dir_info *di;

	di = dirtree_find(inode_no);

	if (di) {

		if (!di->counted_links) {

			log_debug( _("Dir (0x%llx)'s link to "

				     "(0x%llx) via %s is zero!\n"),

				   (unsigned long long)referenced_from,

				   (unsigned long long)inode_no, why);

			return 0;

		}

		di->counted_links--;

		whydecr(inode_no, why, referenced_from, di->counted_links);

		return 0;

	}

	ii = inodetree_find(inode_no);

	/* If the list has entries, look for one that matches

	 * inode_no */

	if (ii) {

		if (!ii->counted_links) {

			log_debug( _("Dir (0x%llx)'s link to "

			     "(0x%llx) via %s is zero!\n"),

			   (unsigned long long)referenced_from,

			   (unsigned long long)inode_no, why);

			return 0;

		}

		ii->counted_links--;

		whydecr(inode_no, why, referenced_from, ii->counted_links);

		return 0;

	}

	if (link1_type(&clink1map, inode_no) == 1) { /* 1 -> 0 */

		link1_set(&clink1map, inode_no, 0);

		whydecr(inode_no, why, referenced_from, 0);

		return 0;

	}

	log_debug( _("No match found when decrementing link for (0x%llx)!\n"),

		   (unsigned long long)inode_no);

	return -1;

}