summaryrefslogtreecommitdiff
path: root/sys/src/cmd/fossil/dat.h
diff options
context:
space:
mode:
authorTaru Karttunen <taruti@taruti.net>2011-03-30 15:46:40 +0300
committerTaru Karttunen <taruti@taruti.net>2011-03-30 15:46:40 +0300
commite5888a1ffdae813d7575f5fb02275c6bb07e5199 (patch)
treed8d51eac403f07814b9e936eed0c9a79195e2450 /sys/src/cmd/fossil/dat.h
Import sources from 2011-03-30 iso image
Diffstat (limited to 'sys/src/cmd/fossil/dat.h')
-rwxr-xr-xsys/src/cmd/fossil/dat.h328
1 files changed, 328 insertions, 0 deletions
diff --git a/sys/src/cmd/fossil/dat.h b/sys/src/cmd/fossil/dat.h
new file mode 100755
index 000000000..b5797c6d7
--- /dev/null
+++ b/sys/src/cmd/fossil/dat.h
@@ -0,0 +1,328 @@
+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 {
+ 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 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];