/*
 * checkhammer.c
 *
 * checkhammer blockmapdump btreedump
 */

#include <sys/types.h>
#include <sys/tree.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

struct rbmap_tree;
struct rbmap;

static void parseBlockMap(FILE *fp);
static void parseBTree(FILE *fp);
static void dumpResults(void);
static int rbmap_cmp(struct rbmap *, struct rbmap *);

typedef u_int64_t hammer_off_t;
typedef struct rbmap *rbmap_t;

RB_HEAD(rbmap_tree, rbmap);
RB_PROTOTYPE2(rbmap_tree, rbmap, rbentry, rbmap_cmp, hammer_off_t);

struct rbmap {
	RB_ENTRY(rbmap) rbentry;
	hammer_off_t	base;
	long		app;
	long		free;
	long		bytes;
	int		zone;
};

RB_GENERATE2(rbmap_tree, rbmap, rbentry, rbmap_cmp, hammer_off_t, base);

struct rbmap_tree rbroot;

static
int
rbmap_cmp(struct rbmap *rb1, struct rbmap *rb2)
{
	if (rb1->base < rb2->base)
		return(-1);
	if (rb1->base > rb2->base)
		return(1);
	return(0);
}

int
main(int ac, char **av)
{
	FILE *fp;

	if (ac != 3) {
		fprintf(stderr, "checkhammer blockmapdump btreedump\n");
		exit(1);
	}
	if ((fp = fopen(av[1], "r")) == NULL) {
		fprintf(stderr, "Unable to open %s\n", av[1]);
		exit(1);
	}

	RB_INIT(&rbroot);
	parseBlockMap(fp);
	fclose(fp);
	if ((fp = fopen(av[2], "r")) == NULL) {
		fprintf(stderr, "Unable to open %s\n", av[1]);
		exit(1);
	}
	parseBTree(fp);
	fclose(fp);

	dumpResults();
	return(0);
}

static void
parseBlockMap(FILE *fp)
{
	char buf[1024];
	rbmap_t map;
	int zone;
	long long base;
	long long app;
	long long free;

	while (fgets(buf, sizeof(buf), fp) != NULL) {
		if (sscanf(buf, "        4%llx zone=%d app=%lld free=%lld",
			   &base, &zone, &app, &free) != 4)
			continue;
		if (RB_LOOKUP(rbmap_tree, &rbroot, (hammer_off_t)base))
			continue;
		map = malloc(sizeof(*map));
		map->base = (hammer_off_t)base;
		map->app = (long)app;
		map->free = (long)free;
		map->zone = zone;
		map->bytes = 0;
		RB_INSERT(rbmap_tree, &rbroot, map);
	}
}

static void
parseBTree(FILE *fp)
{
	char buf[1024];
	rbmap_t map;
	long long base;
	long long bytes;

	while (fgets(buf, sizeof(buf), fp) != NULL) {
		if (sscanf(buf, "     NODE 8%llx", &base) == 1) {
			base &= 0x0FFFFFFFFF800000LLU;
			map = RB_LOOKUP(rbmap_tree, &rbroot, base);
			if (map == NULL) {
				printf("(not in blockmap): %s", buf);
				continue;
			}
			map->bytes += 4096;
		}
		if (sscanf(buf, "                 dataoff=%llx/%lld",
			   &base, &bytes) == 2) {
			base &= 0x0FFFFFFFFF800000LLU;
			map = RB_LOOKUP(rbmap_tree, &rbroot, base);
			if (map == NULL) {
				printf("(not in blockmap): %s", buf);
				continue;
			}
			map->bytes += (bytes + 15) & ~15;
		}
	}
}

static void
dumpResults(void)
{
	rbmap_t map;
	hammer_off_t bfree;

	printf("mismatches: (blockmap, actual)\n");
	RB_FOREACH(map, rbmap_tree, &rbroot) {
		bfree = 8192 * 1024 - (int64_t)map->bytes;

		/*
		 * Ignore matches
		 */
		if (map->free == bfree)
			continue;

		/*
		 * If the block is completely allocated but our calculations
		 * show nobody is referencing it it is probably an undo,
		 * blockmap, or unavailable reserved area.
		 */
		if (map->free == 0 && bfree == 8192 * 1024) {
			if (map->zone == 3 || map->zone == 4 ||
			    map->zone == 15)
				continue;
		}

		printf(" bmap %016jx %jd %jd\n",
			map->base,
			(intmax_t)(int64_t)map->free,
			(intmax_t)(int64_t)bfree);
	}
}