Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <venti.h>

#include <libsec.h>

#include <avl.h>

#include <bin.h>

int changes;

int rewrite;

int ignoreerrors;

int fast;

int verbose;

int nskip;

int nwrite;

VtConn *zsrc, *zdst;

uchar zeroscore[VtScoreSize];	/* all zeros */

typedef struct ScoreTree ScoreTree;

struct ScoreTree

{

	Avl avl;

	uchar score[VtScoreSize];

	int type;

};

Avltree *scoretree;

Bin *scorebin;

static int

scoretreecmp(Avl *va, Avl *vb)

{

	ScoreTree *a, *b;

	int i;

	a = (ScoreTree*)va;

	b = (ScoreTree*)vb;

	i = memcmp(a->score, b->score, VtScoreSize);

	if(i != 0)

		return i;

	return a->type - b->type;

}

static int

havevisited(uchar score[VtScoreSize], int type)

{

	ScoreTree a;

	if(scoretree == nil)

		return 0;

	memmove(a.score, score, VtScoreSize);

	a.type = type;

	return lookupavl(scoretree, &a.avl) != nil;

}

static void

markvisited(uchar score[VtScoreSize], int type)

{

	ScoreTree *a;

	Avl *old;

	if(scoretree == nil)

		return;

	a = binalloc(&scorebin, sizeof *a, 1);

	memmove(a->score, score, VtScoreSize);

	a->type = type;

	insertavl(scoretree, &a->avl, &old);

}

void

usage(void)

{

	fprint(2, "usage: %s [-fimrv] [-t type] srchost dsthost score\n", argv0);

	exits("usage");

}

void

walk(uchar score[VtScoreSize], uint type, int base)

{

	int i, n;

	uchar *buf;

	uchar nscore[VtScoreSize];

	VtEntry e;

	VtRoot root;

	if(memcmp(score, vtzeroscore, VtScoreSize) == 0 || memcmp(score, zeroscore, VtScoreSize) == 0)

		return;

	if(havevisited(score, type)){

		nskip++;

		return;

	}

	buf = vtmallocz(VtMaxLumpSize);

	if(fast && vtread(zdst, score, type, buf, VtMaxLumpSize) >= 0){

		if(verbose)

			fprint(2, "skip %V\n", score);

		free(buf);

		return;

	}

	n = vtread(zsrc, score, type, buf, VtMaxLumpSize);

	if(n < 0){

		if(rewrite){

			changes++;

			memmove(score, vtzeroscore, VtScoreSize);

		}else if(!ignoreerrors)

			sysfatal("reading block %V (type %d): %r", score, type);

		return;

	}

	switch(type){

	case VtRootType:

		if(vtrootunpack(&root, buf) < 0){

			fprint(2, "warning: could not unpack root in %V %d\n", score, type);

			break;

		}

		walk(root.prev, VtRootType, 0);

		walk(root.score, VtDirType, 0);

		if(rewrite)

			vtrootpack(&root, buf);	/* walk might have changed score */

		break;

	case VtDirType:

		for(i=0; i*VtEntrySize<n; i++){

			if(vtentryunpack(&e, buf, i) < 0){

				fprint(2, "warning: could not unpack entry #%d in %V %d\n", i, score, type);

				continue;

			}

			if(!(e.flags & VtEntryActive))

				continue;

			walk(e.score, e.type, e.type&VtTypeBaseMask);

			/*

			 * Don't repack unless we're rewriting -- some old 

			 * vac files have psize==0 and dsize==0, and these

			 * get rewritten by vtentryunpack to have less strange

			 * block sizes.  So vtentryunpack; vtentrypack does not

			 * guarantee to preserve the exact bytes in buf.

			 */

			if(rewrite)

				vtentrypack(&e, buf, i);

		}

		break;

	case VtDataType:

		break;

	default:	/* pointers */

		for(i=0; i<n; i+=VtScoreSize)

			if(memcmp(buf+i, vtzeroscore, VtScoreSize) != 0)

				walk(buf+i, type-1, base);

		break;

	}

	nwrite++;

	if(vtwrite(zdst, nscore, type, buf, n) < 0){

		/* figure out score for better error message */

		/* can't use input argument - might have changed contents */

		n = vtzerotruncate(type, buf, n);

		sha1(buf, n, score, nil);

		sysfatal("writing block %V (type %d): %r", score, type);

	}

	if(!rewrite && memcmp(score, nscore, VtScoreSize) != 0){

		fprint(2, "not rewriting: wrote %V got %V\n", score, nscore);

		abort();

		sysfatal("not rewriting: wrote %V got %V", score, nscore);

	}

	markvisited(score, type);

	free(buf);

}

void

main(int argc, char *argv[])

{

	int type, n;

	uchar score[VtScoreSize];

	uchar *buf;

	char *prefix;

	fmtinstall('F', vtfcallfmt);

	fmtinstall('V', vtscorefmt);

	type = -1;

	ARGBEGIN{

	case 'V':

		chattyventi++;

		break;

	case 'f':

		fast = 1;

		break;

	case 'i':

		if(rewrite)

			usage();

		ignoreerrors = 1;

		break;

	case 'm':

		scoretree = mkavltree(scoretreecmp);

		break;

	case 'r':

		if(ignoreerrors)

			usage();

		rewrite = 1;

		break;

	case 't':

		type = atoi(EARGF(usage()));

		break;

	case 'v':

		verbose = 1;

		break;

	default:

		usage();

		break;

	}ARGEND

	if(argc != 3)

		usage();

	if(vtparsescore(argv[2], &prefix, score) < 0)

		sysfatal("could not parse score: %r");

	buf = vtmallocz(VtMaxLumpSize);

	zsrc = vtdial(argv[0]);

	if(zsrc == nil)

		sysfatal("could not dial src server: %r");

	if(vtconnect(zsrc) < 0)

		sysfatal("vtconnect src: %r");

	zdst = vtdial(argv[1]);

	if(zdst == nil)

		sysfatal("could not dial dst server: %r");

	if(vtconnect(zdst) < 0)

		sysfatal("vtconnect dst: %r");

	if(type != -1){

		n = vtread(zsrc, score, type, buf, VtMaxLumpSize);

		if(n < 0)

			sysfatal("could not read block: %r");

	}else{

		for(type=0; type<VtMaxType; type++){

			n = vtread(zsrc, score, type, buf, VtMaxLumpSize);

			if(n >= 0)

				break;

		}

		if(type == VtMaxType)

			sysfatal("could not find block %V of any type", score);

	}

	walk(score, type, VtDirType);

	if(changes)

		print("%s:%V (%d pointers rewritten)\n", prefix, score, changes);

	if(verbose)

		print("%d skipped, %d written\n", nskip, nwrite);

	if(vtsync(zdst) < 0)

		sysfatal("could not sync dst server: %r");

	exits(0);

}