typedef struct Arch Arch;typedef struct BList BList;typedef struct Block Block;typedef struct Cache Cache;typedef struct Disk Disk;typedef struct Entry Entry;typedef struct Fsck Fsck;typedef struct Header Header;typedef struct Label Label;typedef struct Periodic Periodic;typedef struct Snap Snap;typedef struct Source Source;typedef struct Super Super;typedef struct WalkPtr WalkPtr; #pragma incomplete Arch#pragma incomplete BList#pragma incomplete Cache#pragma incomplete Disk#pragma incomplete Periodic#pragma incomplete Snap /* tunable parameters - probably should not be constants */enum {	/*	 * estimate of bytes per dir entries - determines number	 * of index entries in the block	 */	BytesPerEntry = 100,	/* don't allocate in block if more than this percentage full */	FullPercentage = 80,	FlushSize = 200,	/* number of blocks to flush */	DirtyPercentage = 50,	/* maximum percentage of dirty blocks */}; enum {	Nowaitlock,	Waitlock, 	NilBlock	= (~0UL),	MaxBlock	= (1UL<<31),}; enum {	HeaderMagic = 0x3776ae89,	HeaderVersion = 1,	HeaderOffset = 128*1024,	HeaderSize = 512,	SuperMagic = 0x2340a3b1,	SuperSize = 512,	SuperVersion = 1,	LabelSize = 14,}; /* well known tags */enum {	BadTag = 0,		/* this tag should not be used */	RootTag = 1,		/* root of fs */	EnumTag,		/* root of a dir listing */	UserTag = 32,		/* all other tags should be >= UserTag */}; struct Super {	u16int version;	u32int epochLow;	u32int epochHigh;	u64int qid;			/* next qid */	u32int active;			/* root of active file system */	u32int next;			/* root of next snapshot to archive */	u32int current;			/* root of snapshot currently archiving */	uchar last[VtScoreSize];	/* last snapshot successfully archived */	char name[128];			/* label */};  struct Fs {	Arch	*arch;		/* immutable */	Cache	*cache;		/* immutable */	int	mode;		/* immutable */	int	noatimeupd;	/* immutable */	int	blockSize;	/* immutable */	VtSession *z;		/* immutable */	Snap	*snap;		/* immutable */	/* immutable; copy here & Fsys to ease error reporting */	char	*name; 	Periodic *metaFlush; /* periodically flushes metadata cached in files */ 	/*	 * epoch lock.	 * Most operations on the fs require a read lock of elk, ensuring that	 * the current high and low epochs do not change under foot.	 * This lock is mostly acquired via a call to fileLock or fileRlock.	 * Deletion and creation of snapshots occurs under a write lock of elk,	 * ensuring no file operations are occurring concurrently.	 */	VtLock	*elk;		/* epoch lock */	u32int	ehi;		/* epoch high */	u32int	elo;		/* epoch low */ 	int	halted;	/* epoch lock is held to halt (console initiated) */ 	Source	*source;	/* immutable: root of sources */	File	*file;		/* immutable: root of files */}; /* * variant on VtEntry * there are extra fields when stored locally */struct Entry {	u32int	gen;			/* generation number */	ushort	psize;			/* pointer block size */	ushort	dsize;			/* data block size */	uchar	depth;			/* unpacked from flags */	uchar	flags;	uvlong	size;	uchar	score[VtScoreSize];	u32int	tag;	/* tag for local blocks: zero if stored on Venti */	u32int	snap;	/* non-zero -> entering snapshot of given epoch */	uchar	archive; /* archive this snapshot: only valid for snap != 0 */}; /* * This is called a `stream' in the fossil paper.  There used to be Sinks too. * We believe that Sources and Files are one-to-one. */struct Source {	Fs	*fs;		/* immutable */	int	mode;		/* immutable */	int	issnapshot;	/* immutable */	u32int	gen;		/* immutable */	int	dsize;		/* immutable */	int	dir;		/* immutable */ 	Source	*parent;	/* immutable */	File	*file;		/* immutable; point back */ 	VtLock	*lk;	int	ref;	/*	 * epoch for the source	 * for ReadWrite sources, epoch is used to lazily notice	 * sources that must be split from the snapshots.	 * for ReadOnly sources, the epoch represents the minimum epoch	 * along the chain from the root, and is used to lazily notice	 * sources that have become invalid because they belong to an old	 * snapshot.	 */	u32int	epoch;	Block	*b;		/* block containing this source */	uchar	score[VtScoreSize]; /* score of block containing this source */	u32int	scoreEpoch;	/* epoch of block containing this source */	int	epb;		/* immutable: entries per block in parent */	u32int	tag;		/* immutable: tag of parent */	u32int	offset; 	/* immutable: entry offset in parent */};  struct Header {	ushort version;	ushort blockSize;	ulong super;	/* super blocks */	ulong label;	/* start of labels */	ulong data;	/* end of labels - start of data blocks */	ulong end;	/* end of data blocks */}; /* * contains a one block buffer * to avoid problems of the block changing underfoot * and to enable an interface that supports unget. */struct DirEntryEnum {	File	*file; 	u32int	boff; 		/* block offset */ 	int	i, n;	DirEntry *buf;}; /* Block states */enum {	BsFree = 0,		/* available for allocation */	BsBad = 0xFF,		/* something is wrong with this block */ 	/* bit fields */	BsAlloc = 1<<0,	/* block is in use */	BsCopied = 1<<1,/* block has been copied (usually in preparation for unlink) */	BsVenti = 1<<2,	/* block has been stored on Venti */	BsClosed = 1<<3,/* block has been unlinked on disk from active file system */	BsMask = BsAlloc|BsCopied|BsVenti|BsClosed,}; /* * block types * more regular than Venti block types * bit 3 -> block or data block * bits 2-0 -> level of block */enum {	BtData,	BtDir = 1<<3,	BtLevelMask = 7,	BtMax = 1<<4,}; /* io states */enum {	BioEmpty,	/* label & data are not valid */	BioLabel,	/* label is good */	BioClean,	/* data is on the disk */	BioDirty,	/* data is not yet on the disk */	BioReading,	/* in process of reading data */	BioWriting,	/* in process of writing data */	BioReadError,	/* error reading: assume disk always handles write errors */	BioVentiError,	/* error reading from venti (probably disconnected) */	BioMax}; struct Label {	uchar type;	uchar state;	u32int tag;	u32int epoch;	u32int epochClose;}; struct Block {	Cache	*c;	int	ref;	int	nlock;	uintptr	pc;		/* pc that fetched this block from the cache */ 	VtLock	*lk; 	int 	part;	u32int	addr;	uchar	score[VtScoreSize];	/* score */	Label	l; 	uchar	*dmap; 	uchar 	*data; 	/* the following is private; used by cache */ 	Block	*next;			/* doubly linked hash chains */	Block	**prev;	u32int	heap;			/* index in heap table */	u32int	used;			/* last reference times */ 	u32int	vers;			/* version of dirty flag */ 	BList	*uhead;	/* blocks to unlink when this block is written */	BList	*utail; 	/* block ordering for cache -> disk */	BList	*prior;			/* list of blocks before this one */ 	Block	*ionext;	int	iostate;	VtRendez *ioready;}; /* tree walker, for gc and archiver */struct WalkPtr{	uchar	*data;	int	isEntry;	int	n;	int	m;	Entry	e;	uchar	type;	u32int	tag;}; enum{	DoClose = 1<<0,	DoClre = 1<<1,	DoClri = 1<<2,	DoClrp = 1<<3,}; struct Fsck{	/* filled in by caller */	int	printblocks;	int	useventi;	int	flags;	int	printdirs;	int	printfiles;	int	walksnapshots;	int	walkfs;	Fs	*fs;	int	(*print)(char*, ...);	void	(*clre)(Fsck*, Block*, int);	void	(*clrp)(Fsck*, Block*, int);	void	(*close)(Fsck*, Block*, u32int);	void	(*clri)(Fsck*, char*, MetaBlock*, int, Block*); 	/* used internally */	Cache	*cache;	uchar	*amap;	/* all blocks seen so far */	uchar	*emap;	/* all blocks seen in this epoch */	uchar	*xmap;	/* all blocks in this epoch with parents in this epoch */	uchar	*errmap;	/* blocks with errors */	uchar	*smap;		/* walked sources */	int	nblocks;	int	bsize;	int	walkdepth;	u32int	hint;		/* where the next root probably is */	int	nseen;	int	quantum;	int	nclre;	int	nclrp;	int	nclose;	int	nclri;}; /* disk partitions; keep in sync with partname[] in disk.c */enum {	PartError,	PartSuper,	PartLabel,	PartData,	PartVenti,	/* fake partition */}; extern vtType[BtMax];