1 #ifndef _VENTI_H_
2 #define _VENTI_H_ 1
3 #ifdef __cplusplus
4 extern "C" { 
5 #endif
6 
7 
8 AUTOLIB(venti)
9 
10 /* XXX should be own library? */
11 /*
12  * Packets
13  */
14 enum
15 {
16 	MaxFragSize = 9*1024
17 };
18 
19 typedef struct Packet Packet;
20 
21 Packet*	packetalloc(void);
22 void	packetappend(Packet*, uchar *buf, int n);
23 uint	packetasize(Packet*);
24 int	packetcmp(Packet*, Packet*);
25 int	packetcompact(Packet*);
26 void	packetconcat(Packet*, Packet*);
27 int	packetconsume(Packet*, uchar *buf, int n);
28 int	packetcopy(Packet*, uchar *buf, int offset, int n);
29 Packet*	packetdup(Packet*, int offset, int n);
30 Packet*	packetforeign(uchar *buf, int n, void (*free)(void *a), void *a);
31 int	packetfragments(Packet*, IOchunk*, int nio, int offset);
32 void	packetfree(Packet*);
33 uchar*	packetheader(Packet*, int n);
34 uchar*	packetpeek(Packet*, uchar *buf, int offset, int n);
35 void	packetprefix(Packet*, uchar *buf, int n);
36 void	packetsha1(Packet*, uchar sha1[20]);
37 uint	packetsize(Packet*);
38 Packet*	packetsplit(Packet*, int n);
39 void	packetstats(void);
40 uchar*	packettrailer(Packet*, int n);
41 int	packettrim(Packet*, int offset, int n);
42 
43 /* XXX should be own library? */
44 /*
45  * Logging
46  */
47 typedef struct VtLog VtLog;
48 typedef struct VtLogChunk VtLogChunk;
49 
50 struct VtLog
51 {
52 	VtLog	*next;		/* in hash table */
53 	char	*name;
54 	VtLogChunk *chunk;
55 	uint	nchunk;
56 	VtLogChunk *w;
57 	QLock	lk;
58 	int	ref;
59 };
60 
61 struct VtLogChunk
62 {
63 	char	*p;
64 	char	*ep;
65 	char	*wp;
66 };
67 
68 VtLog*	vtlogopen(char *name, uint size);
69 void	vtlogprint(VtLog *log, char *fmt, ...);
70 void	vtlog(char *name, char *fmt, ...);
71 void	vtlogclose(VtLog*);
72 void	vtlogremove(char *name);
73 char**	vtlognames(int*);
74 void	vtlogdump(int fd, VtLog*);
75 
76 /* XXX begin actual venti.h */
77 
78 typedef struct VtFcall VtFcall;
79 typedef struct VtConn VtConn;
80 typedef struct VtEntry VtEntry;
81 typedef struct VtRoot VtRoot;
82 
83 /*
84  * Fundamental constants.
85  */
86 enum
87 {
88 	VtScoreSize	= 20,
89 	VtMaxStringSize = 1024,
90 	VtPointerDepth	= 7
91 };
92 #define VtMaxFileSize ((1ULL<<48)-1)
93 
94 
95 /* 
96  * Strings in packets.
97  */
98 int vtputstring(Packet*, char*);
99 int vtgetstring(Packet*, char**);
100 
101 /*
102  * Block types.
103  * 
104  * The initial Venti protocol had a much
105  * less regular list of block types.
106  * VtToDiskType converts from new to old.
107  */
108 enum
109 {
110 	VtDataType	= 0<<3,
111 	/* VtDataType+1, ... */
112 	VtDirType	= 1<<3,
113 	/* VtDirType+1, ... */
114 	VtRootType	= 2<<3,
115 	VtMaxType,
116 	VtCorruptType = 0xFF,
117 
118 	VtTypeDepthMask = 7,
119 	VtTypeBaseMask = ~VtTypeDepthMask
120 };
121 
122 /* convert to/from on-disk type numbers */
123 uint vttodisktype(uint);
124 uint vtfromdisktype(uint);
125 
126 /*
127  * VtEntry describes a Venti stream
128  *
129  * The _ enums are only used on the wire.
130  * They are not present in the VtEntry structure
131  * and should not be used by client programs.
132  * (The info is in the type field.)
133  */
134 enum
135 {
136 	VtEntryActive = 1<<0,		/* entry is in use */
137 	_VtEntryDir = 1<<1,		/* a directory */
138 	_VtEntryDepthShift = 2,		/* shift for pointer depth */
139 	_VtEntryDepthMask = 7<<2,	/* mask for pointer depth */
140 	VtEntryLocal = 1<<5,		/* for local storage only */
141 	_VtEntryBig = 1<<6,
142 };
143 enum
144 {
145 	VtEntrySize = 40
146 };
147 struct VtEntry
148 {
149 	ulong	gen;			/* generation number */
150 	ulong	psize;			/* pointer block size */
151 	ulong	dsize;			/* data block size */
152 	uchar	type;
153 	uchar	flags;
154 	uvlong	size;
155 	uchar	score[VtScoreSize];
156 };
157 
158 void vtentrypack(VtEntry*, uchar*, int index);
159 int vtentryunpack(VtEntry*, uchar*, int index);
160 
161 struct VtRoot
162 {
163 	char	name[128];
164 	char	type[128];
165 	uchar	score[VtScoreSize];	/* to a Dir block */
166 	ulong	blocksize;		/* maximum block size */
167 	uchar	prev[VtScoreSize];	/* last root block */
168 };
169 
170 enum
171 {
172 	VtRootSize = 300,
173 	VtRootVersion = 2,
174 	_VtRootVersionBig = 1<<15,
175 };
176 
177 void vtrootpack(VtRoot*, uchar*);
178 int vtrootunpack(VtRoot*, uchar*);
179 
180 /*
181  * score of zero length block
182  */
183 extern uchar vtzeroscore[VtScoreSize];
184 
185 /*
186  * zero extend and truncate blocks
187  */
188 void vtzeroextend(int type, uchar *buf, uint n, uint nn);
189 uint vtzerotruncate(int type, uchar *buf, uint n);
190 
191 /*
192  * parse score: mungs s
193  */
194 int vtparsescore(char *s, char **prefix, uchar[VtScoreSize]);
195 
196 /*
197  * formatting
198  * other than noted, these formats all ignore
199  * the width and precision arguments, and all flags
200  *
201  * V	a venti score
202  */
203 
204 int vtscorefmt(Fmt*);
205 
206 /*
207  * error-checking malloc et al.
208  */
209 void	vtfree(void *);
210 void*	vtmalloc(int);
211 void*	vtmallocz(int);
212 void*	vtrealloc(void *p, int);
213 void*	vtbrk(int n);
214 char*	vtstrdup(char *);
215 
216 /*
217  * Venti protocol
218  */
219 
220 /*
221  * Crypto strengths
222  */
223 enum
224 {
225 	VtCryptoStrengthNone,
226 	VtCryptoStrengthAuth,
227 	VtCryptoStrengthWeak,
228 	VtCryptoStrengthStrong
229 };
230 
231 /*
232  * Crypto suites
233  */
234 enum
235 {
236 	VtCryptoNone,
237 	VtCryptoSSL3,
238 	VtCryptoTLS1,
239 	VtCryptoMax
240 };
241 
242 /* 
243  * Codecs
244  */
245 enum
246 {
247 	VtCodecNone,
248 	VtCodecDeflate,
249 	VtCodecThwack,
250 	VtCodecMax
251 };
252 
253 enum
254 {
255 	VtRerror	= 1,
256 	VtTping		= 2,
257 	VtRping,
258 	VtThello	= 4,
259 	VtRhello,
260 	VtTgoodbye	= 6,
261 	VtRgoodbye,	/* not used */
262 	VtTauth0	= 8,
263 	VtRauth0,
264 	VtTauth1	= 10,
265 	VtRauth1,
266 	VtTread		= 12,
267 	VtRread,
268 	VtTwrite	= 14,
269 	VtRwrite,
270 	VtTsync		= 16,
271 	VtRsync,
272 
273 	VtTmax
274 };
275 
276 struct VtFcall
277 {
278 	uchar	msgtype;
279 	uchar	tag;
280 
281 	char	*error;		/* Rerror */
282 
283 	char	*version;	/* Thello */
284 	char	*uid;		/* Thello */
285 	uchar	strength;	/* Thello */
286 	uchar	*crypto;	/* Thello */
287 	uint	ncrypto;	/* Thello */
288 	uchar	*codec;		/* Thello */
289 	uint	ncodec;		/* Thello */
290 	char	*sid;		/* Rhello */
291 	uchar	rcrypto;	/* Rhello */
292 	uchar	rcodec;		/* Rhello */
293 	uchar	*auth;		/* TauthX, RauthX */
294 	uint	nauth;		/* TauthX, RauthX */
295 	uchar	score[VtScoreSize];	/* Tread, Rwrite */
296 	uchar	blocktype;	/* Tread, Twrite */
297 	uint	count;		/* Tread */
298 	Packet	*data;		/* Rread, Twrite */
299 };
300 
301 Packet*	vtfcallpack(VtFcall*);
302 int	vtfcallunpack(VtFcall*, Packet*);
303 void	vtfcallclear(VtFcall*);
304 int	vtfcallfmt(Fmt*);
305 
306 enum
307 {
308 	VtStateAlloc,
309 	VtStateConnected,
310 	VtStateClosed
311 };
312 
313 struct VtConn
314 {
315 	QLock	lk;
316 	QLock	inlk;
317 	QLock	outlk;
318 	int	debug;
319 	int	infd;
320 	int	outfd;
321 	int	muxer;
322 	void	*writeq;
323 	void	*readq;
324 	int	state;
325 	void	*wait[256];
326 	uint	ntag;
327 	uint	nsleep;
328 	Packet	*part;
329 	Rendez	tagrend;
330 	Rendez	rpcfork;
331 	char	*version;
332 	char	*uid;
333 	char	*sid;
334 	char	addr[256];	/* address of other side */
335 };
336 
337 VtConn*	vtconn(int infd, int outfd);
338 VtConn*	vtdial(char*);
339 void	vtfreeconn(VtConn*);
340 int	vtsend(VtConn*, Packet*);
341 Packet*	vtrecv(VtConn*);
342 int	vtversion(VtConn* z);
343 void	vtdebug(VtConn* z, char*, ...);
344 void	vthangup(VtConn* z);
345 int	vtgoodbye(VtConn* z);
346 
347 /* #pragma varargck argpos vtdebug 2 */
348 
349 /* server */
350 typedef struct VtSrv VtSrv;
351 typedef struct VtReq VtReq;
352 struct VtReq
353 {
354 	VtFcall	tx;
355 	VtFcall	rx;
356 /* private */
357 	VtSrv	*srv;
358 	void	*sc;
359 };
360 
361 int	vtsrvhello(VtConn*);
362 VtSrv*	vtlisten(char *addr);
363 VtReq*	vtgetreq(VtSrv*);
364 void	vtrespond(VtReq*);
365 
366 /* client */
367 Packet*	vtrpc(VtConn*, Packet*);
368 Packet*	_vtrpc(VtConn*, Packet*, VtFcall*);
369 void	vtrecvproc(void*);	/* VtConn */
370 void	vtsendproc(void*);	/* VtConn */
371 
372 int	vtconnect(VtConn*);
373 int	vthello(VtConn*);
374 int	vtread(VtConn*, uchar score[VtScoreSize], uint type, uchar *buf, int n);
375 int	vtwrite(VtConn*, uchar score[VtScoreSize], uint type, uchar *buf, int n);
376 Packet*	vtreadpacket(VtConn*, uchar score[VtScoreSize], uint type, int n);
377 int	vtwritepacket(VtConn*, uchar score[VtScoreSize], uint type, Packet *p);
378 int	vtsync(VtConn*);
379 int	vtping(VtConn*);
380 
381 /*
382  * Data blocks and block cache.
383  */
384 enum
385 {
386 	NilBlock = ~0
387 };
388 
389 typedef struct VtBlock VtBlock;
390 typedef struct VtCache VtCache;
391 
392 struct VtBlock
393 {
394 	VtCache	*c;
395 	QLock	lk;
396 
397 	uchar	*data;
398 	uchar	score[VtScoreSize];
399 	uchar	type;	/* VtXXX */
400 	ulong	size;
401 
402 	/* internal to cache */
403 	int	nlock;
404 	int	iostate;
405 	int	ref;
406 	u32int	heap;
407 	VtBlock	*next;
408 	VtBlock	**prev;
409 	u32int	used;
410 	u32int	used2;
411 	u32int	addr;
412 	uintptr	pc;
413 };
414 
415 u32int	vtglobaltolocal(uchar[VtScoreSize]);
416 void	vtlocaltoglobal(u32int, uchar[VtScoreSize]);
417 
418 VtCache*vtcachealloc(VtConn*, ulong maxmem);
419 void	vtcachefree(VtCache*);
420 VtBlock*vtcachelocal(VtCache*, u32int addr, int type);
421 VtBlock*vtcacheglobal(VtCache*, uchar[VtScoreSize], int type, ulong size);
422 VtBlock*vtcacheallocblock(VtCache*, int type, ulong size);
423 void	vtcachesetwrite(VtCache*,
424 	int(*)(VtConn*, uchar[VtScoreSize], uint, uchar*, int));
425 void	vtblockput(VtBlock*);
426 int	vtblockwrite(VtBlock*);
427 VtBlock*vtblockcopy(VtBlock*);
428 void	vtblockduplock(VtBlock*);
429 
430 extern int vtcachencopy, vtcachenread, vtcachenwrite;
431 extern int vttracelevel;
432 
433 /*
434  * Hash tree file tree.
435  */
436 typedef struct VtFile VtFile;
437 struct VtFile
438 {
439 	QLock	lk;
440 	int	ref;
441 	int	local;
442 	VtBlock	*b;			/* block containing this file */
443 	uchar	score[VtScoreSize];	/* score of block containing this file */
444 	int	bsize;			/* size of block */
445 
446 /* immutable */
447 	VtCache	*c;
448 	int	mode;
449 	u32int	gen;
450 	int	dsize;
451 	int	psize;
452 	int	dir;
453 	VtFile	*parent;
454 	int	epb;			/* entries per block in parent */
455 	u32int	offset; 		/* entry offset in parent */
456 };
457 
458 enum
459 {
460 	VtOREAD,
461 	VtOWRITE,
462 	VtORDWR
463 };
464 
465 VtBlock*vtfileblock(VtFile*, u32int, int mode);
466 int	vtfileblockscore(VtFile*, u32int, uchar[VtScoreSize]);
467 void	vtfileclose(VtFile*);
468 VtFile*	_vtfilecreate(VtFile*, int offset, int psize, int dsize, int dir);
469 VtFile*	vtfilecreate(VtFile*, int psize, int dsize, int dir);
470 VtFile*	vtfilecreateroot(VtCache*, int psize, int dsize, int type);
471 int	vtfileflush(VtFile*);
472 int	vtfileflushbefore(VtFile*, u64int);
473 u32int	vtfilegetdirsize(VtFile*);
474 int	vtfilegetentry(VtFile*, VtEntry*);
475 uvlong	vtfilegetsize(VtFile*);
476 void	vtfileincref(VtFile*);
477 int	vtfilelock2(VtFile*, VtFile*, int);
478 int	vtfilelock(VtFile*, int);
479 VtFile*	vtfileopen(VtFile*, u32int, int);
480 VtFile*	vtfileopenroot(VtCache*, VtEntry*);
481 long	vtfileread(VtFile*, void*, long, vlong);
482 int	vtfileremove(VtFile*);
483 int	vtfilesetdirsize(VtFile*, u32int);
484 int	vtfilesetentry(VtFile*, VtEntry*);
485 int	vtfilesetsize(VtFile*, u64int);
486 int	vtfiletruncate(VtFile*);
487 void	vtfileunlock(VtFile*);
488 long	vtfilewrite(VtFile*, void*, long, vlong);
489 
490 int	vttimefmt(Fmt*);
491 
492 extern int chattyventi;
493 extern int ventidoublechecksha1;
494 extern int ventilogging;
495 
496 extern char *VtServerLog;
497 
498 #ifdef __cplusplus
499 }
500 #endif
501 #endif