Subversion Repositories planix.SVN

#pragma lib "libventi.a"

#pragma src "/sys/src/libventi"

/* XXX should be own library? */

/*

 * Packets

 */

enum

{

	MaxFragSize = 9*1024

};

typedef struct Packet Packet;

#pragma incomplete Packet

Packet*	packetalloc(void);

void	packetappend(Packet*, uchar *buf, int n);

uint	packetasize(Packet*);

int	packetcmp(Packet*, Packet*);

int	packetcompact(Packet*);

void	packetconcat(Packet*, Packet*);

int	packetconsume(Packet*, uchar *buf, int n);

int	packetcopy(Packet*, uchar *buf, int offset, int n);

Packet*	packetdup(Packet*, int offset, int n);

Packet*	packetforeign(uchar *buf, int n, void (*free)(void *a), void *a);

int	packetfragments(Packet*, IOchunk*, int nio, int offset);

void	packetfree(Packet*);

uchar*	packetheader(Packet*, int n);

uchar*	packetpeek(Packet*, uchar *buf, int offset, int n);

void	packetprefix(Packet*, uchar *buf, int n);

void	packetsha1(Packet*, uchar sha1[20]);

uint	packetsize(Packet*);

Packet*	packetsplit(Packet*, int n);

void	packetstats(void);

uchar*	packettrailer(Packet*, int n);

int	packettrim(Packet*, int offset, int n);

/* XXX should be own library? */

/*

 * Logging

 */

typedef struct VtLog VtLog;

typedef struct VtLogChunk VtLogChunk;

struct VtLog

{

	VtLog	*next;		/* in hash table */

	char	*name;

	VtLogChunk *chunk;

	uint	nchunk;

	VtLogChunk *w;

	QLock	lk;

	int	ref;

};

struct VtLogChunk

{

	char	*p;

	char	*ep;

	char	*wp;

};

VtLog*	vtlogopen(char *name, uint size);

void	vtlogprint(VtLog *log, char *fmt, ...);

void	vtlog(char *name, char *fmt, ...);

void	vtlogclose(VtLog*);

void	vtlogremove(char *name);

char**	vtlognames(int*);

void	vtlogdump(int fd, VtLog*);

/* XXX begin actual venti.h */

typedef struct VtFcall VtFcall;

typedef struct VtConn VtConn;

typedef struct VtEntry VtEntry;

typedef struct VtRoot VtRoot;

/*

 * Fundamental constants.

 */

enum

{

	VtScoreSize	= 20,

	VtMaxStringSize = 1024,

	VtMaxLumpSize	= 56*1024,

	VtPointerDepth	= 7

};

#define VtMaxFileSize ((1ULL<<48)-1)

/* 

 * Strings in packets.

 */

int vtputstring(Packet*, char*);

int vtgetstring(Packet*, char**);

/*

 * Block types.

 * 

 * The initial Venti protocol had a much

 * less regular list of block types.

 * VtToDiskType converts from new to old.

 */

enum

{

	VtDataType	= 0<<3,

	/* VtDataType+1, ... */

	VtDirType	= 1<<3,

	/* VtDirType+1, ... */

	VtRootType	= 2<<3,

	VtMaxType,

	VtCorruptType = 0xFF,

	VtTypeDepthMask = 7,

	VtTypeBaseMask = ~VtTypeDepthMask

};

/* convert to/from on-disk type numbers */

uint vttodisktype(uint);

uint vtfromdisktype(uint);

/*

 * VtEntry describes a Venti stream

 *

 * The _ enums are only used on the wire.

 * They are not present in the VtEntry structure

 * and should not be used by client programs.

 * (The info is in the type field.)

 */

enum

{

	VtEntryActive = 1<<0,		/* entry is in use */

	_VtEntryDir = 1<<1,		/* a directory */

	_VtEntryDepthShift = 2,		/* shift for pointer depth */

	_VtEntryDepthMask = 7<<2,	/* mask for pointer depth */

	VtEntryLocal = 1<<5		/* for local storage only */

};

enum

{

	VtEntrySize = 40

};

struct VtEntry

{

	ulong	gen;			/* generation number */

	ushort	psize;			/* pointer block size */

	ushort	dsize;			/* data block size */

	uchar	type;

	uchar	flags;

	uvlong	size;

	uchar	score[VtScoreSize];

};

void vtentrypack(VtEntry*, uchar*, int index);

int vtentryunpack(VtEntry*, uchar*, int index);

struct VtRoot

{

	char	name[128];

	char	type[128];

	uchar	score[VtScoreSize];	/* to a Dir block */

	ushort	blocksize;		/* maximum block size */

	uchar	prev[VtScoreSize];	/* last root block */

};

enum

{

	VtRootSize = 300,

	VtRootVersion = 2

};

void vtrootpack(VtRoot*, uchar*);

int vtrootunpack(VtRoot*, uchar*);

/*

 * score of zero length block

 */

extern uchar vtzeroscore[VtScoreSize];

/*

 * zero extend and truncate blocks

 */

void vtzeroextend(int type, uchar *buf, uint n, uint nn);

uint vtzerotruncate(int type, uchar *buf, uint n);

/*

 * parse score: mungs s

 */

int vtparsescore(char *s, char **prefix, uchar[VtScoreSize]);

/*

 * formatting

 * other than noted, these formats all ignore

 * the width and precision arguments, and all flags

 *

 * V	a venti score

 */

#pragma	varargck	type	"V"	uchar*

#pragma	varargck	type	"F"	VtFcall*

#pragma	varargck	type	"T"	void

#pragma	varargck	type	"lT"	void

int vtscorefmt(Fmt*);

/*

 * error-checking malloc et al.

 */

void	vtfree(void *);

void*	vtmalloc(int);

void*	vtmallocz(int);

void*	vtrealloc(void *p, int);

void*	vtbrk(int n);

char*	vtstrdup(char *);

/*

 * Venti protocol

 */

/*

 * Crypto strengths

 */

enum

{

	VtCryptoStrengthNone,

	VtCryptoStrengthAuth,

	VtCryptoStrengthWeak,

	VtCryptoStrengthStrong

};

/*

 * Crypto suites

 */

enum

{

	VtCryptoNone,

	VtCryptoSSL3,

	VtCryptoTLS1,

	VtCryptoMax

};

/* 

 * Codecs

 */

enum

{

	VtCodecNone,

	VtCodecDeflate,

	VtCodecThwack,

	VtCodecMax

};

enum

{

	VtRerror	= 1,

	VtTping		= 2,

	VtRping,

	VtThello	= 4,

	VtRhello,

	VtTgoodbye	= 6,

	VtRgoodbye,	/* not used */

	VtTauth0	= 8,

	VtRauth0,

	VtTauth1	= 10,

	VtRauth1,

	VtTread		= 12,

	VtRread,

	VtTwrite	= 14,

	VtRwrite,

	VtTsync		= 16,

	VtRsync,

	VtTmax

};

struct VtFcall

{

	uchar	msgtype;

	uchar	tag;

	char	*error;		/* Rerror */

	char	*version;	/* Thello */

	char	*uid;		/* Thello */

	uchar	strength;	/* Thello */

	uchar	*crypto;	/* Thello */

	uint	ncrypto;	/* Thello */

	uchar	*codec;		/* Thello */

	uint	ncodec;		/* Thello */

	char	*sid;		/* Rhello */

	uchar	rcrypto;	/* Rhello */

	uchar	rcodec;		/* Rhello */

	uchar	*auth;		/* TauthX, RauthX */

	uint	nauth;		/* TauthX, RauthX */

	uchar	score[VtScoreSize];	/* Tread, Rwrite */

	uchar	blocktype;	/* Tread, Twrite */

	ushort	count;		/* Tread */

	Packet	*data;		/* Rread, Twrite */

};

Packet*	vtfcallpack(VtFcall*);

int	vtfcallunpack(VtFcall*, Packet*);

void	vtfcallclear(VtFcall*);

int	vtfcallfmt(Fmt*);

enum

{

	VtStateAlloc,

	VtStateConnected,

	VtStateClosed

};

struct VtConn

{

	QLock	lk;

	QLock	inlk;

	QLock	outlk;

	int	debug;

	int	infd;

	int	outfd;

	int	muxer;

	void	*writeq;

	void	*readq;

	int	state;

	void	*wait[256];

	uint	ntag;

	uint	nsleep;

	Packet	*part;

	Rendez	tagrend;

	Rendez	rpcfork;

	char	*version;

	char	*uid;

	char	*sid;

	char	addr[256];	/* address of other side */

};

VtConn*	vtconn(int infd, int outfd);

VtConn*	vtdial(char*);

void	vtfreeconn(VtConn*);

int	vtsend(VtConn*, Packet*);

Packet*	vtrecv(VtConn*);

int	vtversion(VtConn* z);

void	vtdebug(VtConn* z, char*, ...);

void	vthangup(VtConn* z);

int	vtgoodbye(VtConn* z);

/* #pragma varargck argpos vtdebug 2 */

/* server */

typedef struct VtSrv VtSrv;

#pragma incomplete VtSrv

typedef struct VtReq VtReq;

struct VtReq

{

	VtFcall	tx;

	VtFcall	rx;

/* private */

	VtSrv	*srv;

	void	*sc;

};

int	vtsrvhello(VtConn*);

VtSrv*	vtlisten(char *addr);

VtReq*	vtgetreq(VtSrv*);

void	vtrespond(VtReq*);

/* client */

Packet*	vtrpc(VtConn*, Packet*);

Packet*	_vtrpc(VtConn*, Packet*, VtFcall*);

void	vtrecvproc(void*);	/* VtConn */

void	vtsendproc(void*);	/* VtConn */

int	vtconnect(VtConn*);

int	vthello(VtConn*);

int	vtread(VtConn*, uchar score[VtScoreSize], uint type, uchar *buf, int n);

int	vtwrite(VtConn*, uchar score[VtScoreSize], uint type, uchar *buf, int n);

Packet*	vtreadpacket(VtConn*, uchar score[VtScoreSize], uint type, int n);

int	vtwritepacket(VtConn*, uchar score[VtScoreSize], uint type, Packet *p);

int	vtsync(VtConn*);

int	vtping(VtConn*);

/*

 * Data blocks and block cache.

 */

enum

{

	NilBlock = ~0

};

typedef struct VtBlock VtBlock;

typedef struct VtCache VtCache;

#pragma incomplete VtCache

struct VtBlock

{

	VtCache	*c;

	QLock	lk;

	uchar	*data;

	uchar	score[VtScoreSize];

	uchar	type;			/* BtXXX */

	/* internal to cache */

	int	nlock;

	int	iostate;

	int	ref;

	u32int	heap;

	VtBlock	*next;

	VtBlock	**prev;

	u32int	used;

	u32int	used2;

	u32int	addr;

	uintptr	pc;

};

u32int	vtglobaltolocal(uchar[VtScoreSize]);

void	vtlocaltoglobal(u32int, uchar[VtScoreSize]);

VtCache*vtcachealloc(VtConn*, int blocksize, ulong nblocks);

void	vtcachefree(VtCache*);

VtBlock*vtcachelocal(VtCache*, u32int addr, int type);

VtBlock*vtcacheglobal(VtCache*, uchar[VtScoreSize], int type);

VtBlock*vtcacheallocblock(VtCache*, int type);

void	vtcachesetwrite(VtCache*,

	int(*)(VtConn*, uchar[VtScoreSize], uint, uchar*, int));

void	vtblockput(VtBlock*);

u32int	vtcacheblocksize(VtCache*);

int	vtblockwrite(VtBlock*);

VtBlock*vtblockcopy(VtBlock*);

void	vtblockduplock(VtBlock*);

extern int vtcachencopy, vtcachenread, vtcachenwrite;

extern int vttracelevel;

/*

 * Hash tree file tree.

 */

typedef struct VtFile VtFile;

struct VtFile

{

	QLock	lk;

	int	ref;

	int	local;

	VtBlock	*b;			/* block containing this file */

	uchar	score[VtScoreSize];	/* score of block containing this file */

/* immutable */

	VtCache	*c;

	int	mode;

	u32int	gen;

	int	dsize;

	int	psize;

	int	dir;

	VtFile	*parent;

	int	epb;			/* entries per block in parent */

	u32int	offset; 		/* entry offset in parent */

};

enum

{

	VtOREAD,

	VtOWRITE,

	VtORDWR

};

VtBlock*vtfileblock(VtFile*, u32int, int mode);

int	vtfileblockscore(VtFile*, u32int, uchar[VtScoreSize]);

void	vtfileclose(VtFile*);

VtFile*	_vtfilecreate(VtFile*, int offset, int psize, int dsize, int dir);

VtFile*	vtfilecreate(VtFile*, int psize, int dsize, int dir);

VtFile*	vtfilecreateroot(VtCache*, int psize, int dsize, int type);

int	vtfileflush(VtFile*);

int	vtfileflushbefore(VtFile*, u64int);

u32int	vtfilegetdirsize(VtFile*);

int	vtfilegetentry(VtFile*, VtEntry*);

uvlong	vtfilegetsize(VtFile*);

void	vtfileincref(VtFile*);

int	vtfilelock2(VtFile*, VtFile*, int);

int	vtfilelock(VtFile*, int);

VtFile*	vtfileopen(VtFile*, u32int, int);

VtFile*	vtfileopenroot(VtCache*, VtEntry*);

long	vtfileread(VtFile*, void*, long, vlong);

int	vtfileremove(VtFile*);

int	vtfilesetdirsize(VtFile*, u32int);

int	vtfilesetentry(VtFile*, VtEntry*);

int	vtfilesetsize(VtFile*, u64int);

int	vtfiletruncate(VtFile*);

void	vtfileunlock(VtFile*);

long	vtfilewrite(VtFile*, void*, long, vlong);

int	vttimefmt(Fmt*);

extern int chattyventi;

extern int ventidoublechecksha1;

extern int ventilogging;

extern char *VtServerLog;