1 files changed, 156 insertions, 0 deletions
diff --git a/src/cmd/vac/dat.h b/src/cmd/vac/dat.h
new file mode 100644
index 00000000..a468668d
--- /dev/null
+++ b/src/cmd/vac/dat.h
@@ -0,0 +1,156 @@
+typedef struct Source Source;
+typedef struct VacFile VacFile;
+typedef struct MetaBlock MetaBlock;
+typedef struct MetaEntry MetaEntry;
+typedef struct Lump Lump;
+typedef struct Cache Cache;
+typedef struct Super Super;
+
+enum {
+	NilBlock	= (~0UL),
+	MaxBlock	= (1UL<<31),
+};
+
+
+struct VacFS {
+	int ref;
+	
+	/* need a read write lock? */
+
+	uchar score[VtScoreSize];
+	VacFile *root;
+	
+	VtSession *z;
+	int readOnly;
+	int bsize;		/* maximum block size */
+	uvlong qid;		/* next qid */
+	Cache *cache;
+};
+
+
+struct Source {
+	VtLock *lk;
+
+	Cache *cache;	/* immutable */
+	int readOnly;	/* immutable */
+
+	Lump *lump;	/* lump containing venti dir entry */
+	ulong block;	/* block number within parent: immutable */
+	int entry;	/* which entry in the block: immutable */
+
+	/* most of a VtEntry, except the score */
+	ulong gen;	/* generation: immutable */
+	int dir;	/* dir flags: immutable */
+	int depth;	/* number of levels of pointer blocks */
+	int psize;	/* pointer block size: immutable */
+	int dsize;	/* data block size: immutable */
+	uvlong size;	/* size in bytes of file */
+
+	int epb;	/* dir entries per block = dize/VtEntrySize: immutable */
+};
+
+struct MetaEntry {
+	uchar *p;
+	ushort size;
+};
+
+struct MetaBlock {
+	int maxsize;		/* size of block */
+	int size;		/* size used */
+	int free;		/* free space within used size */
+	int maxindex;		/* entries allocated for table */
+	int nindex;		/* amount of table used */
+	int unbotch;
+	uchar *buf;
+};
+
+/*
+ * contains a one block buffer
+ * to avoid problems of the block changing underfoot
+ * and to enable an interface that supports unget.
+ */
+struct VacDirEnum {
+	VacFile *file;
+	
+	ulong block;	/* current block */
+	MetaBlock mb;	/* parsed version of block */
+	int index;	/* index in block */
+};
+
+/* Lump states */
+enum {
+	LumpFree,
+	LumpVenti,	/* on venti server: score > 2^32: just a cached copy */
+	LumpActive,	/* active */
+	LumpActiveRO,	/* active: read only block */
+	LumpActiveA,	/* active: achrived */
+	LumpSnap,	/* snapshot: */
+	LumpSnapRO,	/* snapshot: read only */
+	LumpSnapA,	/* snapshot: achived */
+	LumpZombie,	/* block with no pointer to it: waiting to be freed */
+	
+	LumpMax
+};
+
+/*
+ * Each lump has a state and generation
+ * The following invariants are maintained
+ * 	Each lump has no more than than one parent per generation
+ * 	For Active*, no child has a parent of a greater generation
+ *	For Snap*, there is a snap parent of given generation and there are
+ *		no parents of greater gen - implies no children of a greater gen
+ *	For *RO, the lump is fixed - no change ca be made - all pointers
+ *		are valid venti addresses
+ *	For *A, the lump is on the venti server
+ *	There are no pointers to Zombie lumps
+ *
+ * Transitions
+ *	Archiver at generation g
+ *	Mutator at generation h
+ *	
+ *	Want to modify a lump
+ *		Venti: create new Active(h)
+ *		Active(x): x == h: do nothing
+ *		Acitve(x): x < h: change to Snap(h-1) + add Active(h)
+ *		ActiveRO(x): change to SnapRO(h-1) + add Active(h)
+ *		ActiveA(x): add Active(h)
+ *		Snap*(x): should not occur
+ *		Zombie(x): should not occur
+ *	Want to archive
+ *		Active(x): x != g: should never happen
+ *		Active(x): x == g fix children and free them: move to ActoveRO(g);
+ *		ActiveRO(x): x != g: should never happen
+ *		ActiveRO(x): x == g: wait until it hits ActiveA or SnapA
+ *		ActiveA(x): done
+ *		Active(x): x < g: should never happen
+ *		Snap(x): x >= g: fix children, freeing all SnapA(y) x == y;
+ *		SnapRO(x): wait until it hits SnapA
+ *
+ */
+
+
+struct Lump {
+	int ref;
+
+	Cache *c;
+
+	VtLock *lk;
+	
+	int state;
+	ulong gen;
+
+	uchar 	*data;
+	uchar	score[VtScoreSize];	/* score of packet */
+	uchar	vscore[VtScoreSize];	/* venti score - when archived */
+	u8int	type;			/* type of packet */
+	int	dir;			/* part of a directory - extension of type */
+	u16int	asize;			/* allocated size of block */
+	Lump	*next;			/* doubly linked hash chains */
+	Lump	*prev;
+	u32int	heap;			/* index in heap table */
+	u32int	used;			/* last reference times */
+	u32int	used2;
+
+	u32int	addr;			/* mutable block address */
+};
+