#include "clusterautoconfig.h"

/*
 * NOTE:
 *
 * This code was pilfered from the gfs2 kernel and adapted to userland.
 * If you change this part, you should evaluate whether the upstream kernel
 * version of recovery.c should be changed as well.  Likewise, if the
 * upstream version changes, this part should be kept in sync.
 * 
 */

#include <errno.h>
#include <string.h>
#include "libgfs2.h"

void gfs2_replay_incr_blk(struct gfs2_inode *ip, unsigned int *blk)
{
	uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;

        if (++*blk == jd_blocks)
                *blk = 0;
}

int gfs2_replay_read_block(struct gfs2_inode *ip, unsigned int blk,
			   struct gfs2_buffer_head **bh)
{
	int new = 0;
	uint64_t dblock;

	block_map(ip, blk, &new, &dblock, NULL, FALSE);
	if (!dblock)
		return -EIO;

	*bh = bread(ip->i_sbd, dblock);
	return 0;
}

/**
 * get_log_header - read the log header for a given segment
 * @ip: the journal incore inode
 * @blk: the block to look at
 * @lh: the log header to return
 *
 * Read the log header for a given segement in a given journal.  Do a few
 * sanity checks on it.
 *
 * Returns: 0 on success,
 *          1 if the header was invalid or incomplete,
 *          errno on error
 */

int get_log_header(struct gfs2_inode *ip, unsigned int blk,
		   struct gfs2_log_header *head)
{
	struct gfs2_buffer_head *bh;
	struct gfs2_log_header lh, *tmp;
	uint32_t hash, saved_hash;
	uint32_t lh_crc = 0;
	uint32_t crc;
	int error;

	error = gfs2_replay_read_block(ip, blk, &bh);
	if (error)
		return error;

	tmp = (struct gfs2_log_header *)bh->b_data;
	saved_hash = tmp->lh_hash;
	tmp->lh_hash = 0;
	hash = lgfs2_log_header_hash(bh->b_data);
	tmp->lh_hash = saved_hash;
	crc = lgfs2_log_header_crc(bh->b_data, ip->i_sbd->bsize);
	gfs2_log_header_in(&lh, bh->b_data);
	brelse(bh);
#ifdef GFS2_HAS_LH_V2
	lh_crc = lh.lh_crc;
#endif
	if (error || lh.lh_blkno != blk || lh.lh_hash != hash)
		return 1;
	/* Don't check the crc if it's zero, as it is in pre-v2 log headers */
	if (lh_crc != 0 && lh_crc != crc)
		return 1;

	*head = lh;

	return 0;
}

/**
 * find_good_lh - find a good log header
 * @ip: the journal incore inode
 * @blk: the segment to start searching from
 * @lh: the log header to fill in
 * @forward: if true search forward in the log, else search backward
 *
 * Call get_log_header() to get a log header for a segment, but if the
 * segment is bad, either scan forward or backward until we find a good one.
 *
 * Returns: errno
 */
static int find_good_lh(struct gfs2_inode *ip, unsigned int *blk, struct gfs2_log_header *head)
{
	unsigned int orig_blk = *blk;
	int error;
	uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;

	for (;;) {
		error = get_log_header(ip, *blk, head);
		if (error <= 0)
			return error;

		if (++*blk == jd_blocks)
			*blk = 0;

		if (*blk == orig_blk)
			return -EIO;
	}
}

/**
 * jhead_scan - make sure we've found the head of the log
 * @jd: the journal
 * @head: this is filled in with the log descriptor of the head
 *
 * At this point, seg and lh should be either the head of the log or just
 * before.  Scan forward until we find the head.
 *
 * Returns: errno
 */

static int jhead_scan(struct gfs2_inode *ip, struct gfs2_log_header *head)
{
	unsigned int blk = head->lh_blkno;
	uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
	struct gfs2_log_header lh;
	int error;

	for (;;) {
		if (++blk == jd_blocks)
			blk = 0;

		error = get_log_header(ip, blk, &lh);
		if (error < 0)
			return error;
		if (error == 1)
			continue;

		if (lh.lh_sequence == head->lh_sequence)
			return -EIO;
		if (lh.lh_sequence < head->lh_sequence)
			break;

		*head = lh;
	}

	return 0;
}

/**
 * gfs2_find_jhead - find the head of a log
 * @jd: the journal
 * @head: the log descriptor for the head of the log is returned here
 *
 * Do a binary search of a journal and find the valid log entry with the
 * highest sequence number.  (i.e. the log head)
 *
 * Returns: errno
 */

int gfs2_find_jhead(struct gfs2_inode *ip, struct gfs2_log_header *head)
{
	struct gfs2_log_header lh_1, lh_m;
	uint32_t blk_1, blk_2, blk_m;
	uint32_t jd_blocks = ip->i_di.di_size / ip->i_sbd->sd_sb.sb_bsize;
	int error;

	blk_1 = 0;
	blk_2 = jd_blocks - 1;

	for (;;) {
		blk_m = (blk_1 + blk_2) / 2;

		error = find_good_lh(ip, &blk_1, &lh_1);
		if (error)
			return error;

		error = find_good_lh(ip, &blk_m, &lh_m);
		if (error)
			return error;

		if (blk_1 == blk_m || blk_m == blk_2)
			break;

		if (lh_1.lh_sequence <= lh_m.lh_sequence)
			blk_1 = blk_m;
		else
			blk_2 = blk_m;
	}

	error = jhead_scan(ip, &lh_1);
	if (error)
		return error;

	*head = lh_1;

	return error;
}

/**
 * clean_journal - mark a dirty journal as being clean
 * @sdp: the filesystem
 * @jd: the journal
 * @head: the head journal to start from
 *
 * Returns: errno
 */

int clean_journal(struct gfs2_inode *ip, struct gfs2_log_header *head)
{
	unsigned int lblock;
	struct gfs2_log_header *lh;
	uint32_t hash;
	struct gfs2_buffer_head *bh;
	int new = 0;
	uint64_t dblock;

	lblock = head->lh_blkno;
	gfs2_replay_incr_blk(ip, &lblock);
	block_map(ip, lblock, &new, &dblock, NULL, 0);
	if (!dblock)
		return -EIO;

	bh = bread(ip->i_sbd, dblock);
	memset(bh->b_data, 0, ip->i_sbd->bsize);

	lh = (struct gfs2_log_header *)bh->b_data;
	memset(lh, 0, sizeof(struct gfs2_log_header));
	lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
	lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
	lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
	lh->lh_sequence = cpu_to_be64(head->lh_sequence + 1);
	lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT);
	lh->lh_blkno = cpu_to_be32(lblock);
	hash = gfs2_disk_hash((const char *)lh, sizeof(struct gfs2_log_header));
	lh->lh_hash = cpu_to_be32(hash);
	bmodified(bh);
	brelse(bh);

	return 0;
}