Import sources from 2011-03-30 iso image

1 files changed, 262 insertions, 0 deletions

diff --git a/sys/src/cmd/venti/copy.c b/sys/src/cmd/venti/copy.c
new file mode 100755
index 000000000..db07dcb9d
--- /dev/null
+++ b/sys/src/cmd/venti/copy.c
@@ -0,0 +1,262 @@
+#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<n/VtEntrySize; 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);
+}