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 	VtEntryNoArchive = 1<<7,	/* for local storage only */
143 };
144 enum
145 {
146 	VtEntrySize = 40
147 };
148 struct VtEntry
149 {
150 	ulong	gen;			/* generation number */
151 	ulong	psize;			/* pointer block size */
152 	ulong	dsize;			/* data block size */
153 	uchar	type;
154 	uchar	flags;
155 	uvlong	size;
156 	uchar	score[VtScoreSize];
157 };
158 
159 void vtentrypack(VtEntry*, uchar*, int index);
160 int vtentryunpack(VtEntry*, uchar*, int index);
161 
162 struct VtRoot
163 {
164 	char	name[128];
165 	char	type[128];
166 	uchar	score[VtScoreSize];	/* to a Dir block */
167 	ulong	blocksize;		/* maximum block size */
168 	uchar	prev[VtScoreSize];	/* last root block */
169 };
170 
171 enum
172 {
173 	VtRootSize = 300,
174 	VtRootVersion = 2,
175 	_VtRootVersionBig = 1<<15,
176 };
177 
178 void vtrootpack(VtRoot*, uchar*);
179 int vtrootunpack(VtRoot*, uchar*);
180 
181 /*
182  * score of zero length block
183  */
184 extern uchar vtzeroscore[VtScoreSize];
185 
186 /*
187  * zero extend and truncate blocks
188  */
189 void vtzeroextend(int type, uchar *buf, uint n, uint nn);
190 uint vtzerotruncate(int type, uchar *buf, uint n);
191 
192 /*
193  * parse score: mungs s
194  */
195 int vtparsescore(char *s, char **prefix, uchar[VtScoreSize]);
196 
197 /*
198  * formatting
199  * other than noted, these formats all ignore
200  * the width and precision arguments, and all flags
201  *
202  * V	a venti score
203  */
204 
205 int vtscorefmt(Fmt*);
206 
207 /*
208  * error-checking malloc et al.
209  */
210 void	vtfree(void *);
211 void*	vtmalloc(int);
212 void*	vtmallocz(int);
213 void*	vtrealloc(void *p, int);
214 void*	vtbrk(int n);
215 char*	vtstrdup(char *);
216 
217 /*
218  * Venti protocol
219  */
220 
221 /*
222  * Crypto strengths
223  */
224 enum
225 {
226 	VtCryptoStrengthNone,
227 	VtCryptoStrengthAuth,
228 	VtCryptoStrengthWeak,
229 	VtCryptoStrengthStrong
230 };
231 
232 /*
233  * Crypto suites
234  */
235 enum
236 {
237 	VtCryptoNone,
238 	VtCryptoSSL3,
239 	VtCryptoTLS1,
240 	VtCryptoMax
241 };
242 
243 /* 
244  * Codecs
245  */
246 enum
247 {
248 	VtCodecNone,
249 	VtCodecDeflate,
250 	VtCodecThwack,
251 	VtCodecMax
252 };
253 
254 enum
255 {
256 	VtRerror	= 1,
257 	VtTping		= 2,
258 	VtRping,
259 	VtThello	= 4,
260 	VtRhello,
261 	VtTgoodbye	= 6,
262 	VtRgoodbye,	/* not used */
263 	VtTauth0	= 8,
264 	VtRauth0,
265 	VtTauth1	= 10,
266 	VtRauth1,
267 	VtTread		= 12,
268 	VtRread,
269 	VtTwrite	= 14,
270 	VtRwrite,
271 	VtTsync		= 16,
272 	VtRsync,
273 
274 	VtTmax
275 };
276 
277 struct VtFcall
278 {
279 	uchar	msgtype;
280 	uchar	tag;
281 
282 	char	*error;		/* Rerror */
283 
284 	char	*version;	/* Thello */
285 	char	*uid;		/* Thello */
286 	uchar	strength;	/* Thello */
287 	uchar	*crypto;	/* Thello */
288 	uint	ncrypto;	/* Thello */
289 	uchar	*codec;		/* Thello */
290 	uint	ncodec;		/* Thello */
291 	char	*sid;		/* Rhello */
292 	uchar	rcrypto;	/* Rhello */
293 	uchar	rcodec;		/* Rhello */
294 	uchar	*auth;		/* TauthX, RauthX */
295 	uint	nauth;		/* TauthX, RauthX */
296 	uchar	score[VtScoreSize];	/* Tread, Rwrite */
297 	uchar	blocktype;	/* Tread, Twrite */
298 	uint	count;		/* Tread */
299 	Packet	*data;		/* Rread, Twrite */
300 };
301 
302 Packet*	vtfcallpack(VtFcall*);
303 int	vtfcallunpack(VtFcall*, Packet*);
304 void	vtfcallclear(VtFcall*);
305 int	vtfcallfmt(Fmt*);
306 
307 enum
308 {
309 	VtStateAlloc,
310 	VtStateConnected,
311 	VtStateClosed
312 };
313 
314 struct VtConn
315 {
316 	QLock	lk;
317 	QLock	inlk;
318 	QLock	outlk;
319 	int	debug;
320 	int	infd;
321 	int	outfd;
322 	int	muxer;
323 	void	*writeq;
324 	void	*readq;
325 	int	state;
326 	void	*wait[256];
327 	uint	ntag;
328 	uint	nsleep;
329 	Packet	*part;
330 	Rendez	tagrend;
331 	Rendez	rpcfork;
332 	char	*version;
333 	char	*uid;
334 	char	*sid;
335 	char	addr[256];	/* address of other side */
336 };
337 
338 VtConn*	vtconn(int infd, int outfd);
339 int	vtreconn(VtConn*, int, int);
340 VtConn*	vtdial(char*);
341 int	vtredial(VtConn*, char *);
342 void	vtfreeconn(VtConn*);
343 int	vtsend(VtConn*, Packet*);
344 Packet*	vtrecv(VtConn*);
345 int	vtversion(VtConn* z);
346 void	vtdebug(VtConn* z, char*, ...);
347 void	vthangup(VtConn* z);
348 int	vtgoodbye(VtConn* z);
349 
350 /* #pragma varargck argpos vtdebug 2 */
351 
352 /* server */
353 typedef struct VtSrv VtSrv;
354 typedef struct VtReq VtReq;
355 struct VtReq
356 {
357 	VtFcall	tx;
358 	VtFcall	rx;
359 /* private */
360 	VtSrv	*srv;
361 	void	*sc;
362 };
363 
364 int	vtsrvhello(VtConn*);
365 VtSrv*	vtlisten(char *addr);
366 VtReq*	vtgetreq(VtSrv*);
367 void	vtrespond(VtReq*);
368 
369 /* client */
370 Packet*	vtrpc(VtConn*, Packet*);
371 Packet*	_vtrpc(VtConn*, Packet*, VtFcall*);
372 void	vtrecvproc(void*);	/* VtConn */
373 void	vtsendproc(void*);	/* VtConn */
374 
375 int	vtconnect(VtConn*);
376 int	vthello(VtConn*);
377 int	vtread(VtConn*, uchar score[VtScoreSize], uint type, uchar *buf, int n);
378 int	vtwrite(VtConn*, uchar score[VtScoreSize], uint type, uchar *buf, int n);
379 Packet*	vtreadpacket(VtConn*, uchar score[VtScoreSize], uint type, int n);
380 int	vtwritepacket(VtConn*, uchar score[VtScoreSize], uint type, Packet *p);
381 int	vtsync(VtConn*);
382 int	vtping(VtConn*);
383 
384 /* sha1 */
385 void	vtsha1(uchar score[VtScoreSize], uchar*, int);
386 int	vtsha1check(uchar score[VtScoreSize], uchar*, int);
387 
388 /*
389  * Data blocks and block cache.
390  */
391 enum
392 {
393 	NilBlock = ~0
394 };
395 
396 typedef struct VtBlock VtBlock;
397 typedef struct VtCache VtCache;
398 
399 struct VtBlock
400 {
401 	VtCache	*c;
402 	QLock	lk;
403 
404 	uchar	*data;
405 	uchar	score[VtScoreSize];
406 	uchar	type;	/* VtXXX */
407 	ulong	size;
408 
409 	/* internal to cache */
410 	int	nlock;
411 	int	iostate;
412 	int	ref;
413 	u32int	heap;
414 	VtBlock	*next;
415 	VtBlock	**prev;
416 	u32int	used;
417 	u32int	used2;
418 	u32int	addr;
419 	uintptr	pc;
420 };
421 
422 u32int	vtglobaltolocal(uchar[VtScoreSize]);
423 void	vtlocaltoglobal(u32int, uchar[VtScoreSize]);
424 
425 VtCache*vtcachealloc(VtConn*, ulong maxmem);
426 void	vtcachefree(VtCache*);
427 VtBlock*vtcachelocal(VtCache*, u32int addr, int type);
428 VtBlock*vtcacheglobal(VtCache*, uchar[VtScoreSize], int type, ulong size);
429 VtBlock*vtcacheallocblock(VtCache*, int type, ulong size);
430 void	vtcachesetwrite(VtCache*,
431 	int(*)(VtConn*, uchar[VtScoreSize], uint, uchar*, int));
432 void	vtblockput(VtBlock*);
433 int	vtblockwrite(VtBlock*);
434 VtBlock*vtblockcopy(VtBlock*);
435 void	vtblockduplock(VtBlock*);
436 
437 extern int vtcachencopy, vtcachenread, vtcachenwrite;
438 extern int vttracelevel;
439 
440 /*
441  * Hash tree file tree.
442  */
443 typedef struct VtFile VtFile;
444 struct VtFile
445 {
446 	QLock	lk;
447 	int	ref;
448 	int	local;
449 	VtBlock	*b;			/* block containing this file */
450 	uchar	score[VtScoreSize];	/* score of block containing this file */
451 	int	bsize;			/* size of block */
452 
453 /* immutable */
454 	VtCache	*c;
455 	int	mode;
456 	u32int	gen;
457 	int	dsize;
458 	int	psize;
459 	int	dir;
460 	VtFile	*parent;
461 	int	epb;			/* entries per block in parent */
462 	u32int	offset; 		/* entry offset in parent */
463 };
464 
465 enum
466 {
467 	VtOREAD,
468 	VtOWRITE,
469 	VtORDWR
470 };
471 
472 VtBlock*vtfileblock(VtFile*, u32int, int mode);
473 int	vtfileblockscore(VtFile*, u32int, uchar[VtScoreSize]);
474 void	vtfileclose(VtFile*);
475 VtFile*	_vtfilecreate(VtFile*, int offset, int psize, int dsize, int dir);
476 VtFile*	vtfilecreate(VtFile*, int psize, int dsize, int dir);
477 VtFile*	vtfilecreateroot(VtCache*, int psize, int dsize, int type);
478 int	vtfileflush(VtFile*);
479 int	vtfileflushbefore(VtFile*, u64int);
480 u32int	vtfilegetdirsize(VtFile*);
481 int	vtfilegetentry(VtFile*, VtEntry*);
482 uvlong	vtfilegetsize(VtFile*);
483 void	vtfileincref(VtFile*);
484 int	vtfilelock2(VtFile*, VtFile*, int);
485 int	vtfilelock(VtFile*, int);
486 VtFile*	vtfileopen(VtFile*, u32int, int);
487 VtFile*	vtfileopenroot(VtCache*, VtEntry*);
488 long	vtfileread(VtFile*, void*, long, vlong);
489 int	vtfileremove(VtFile*);
490 int	vtfilesetdirsize(VtFile*, u32int);
491 int	vtfilesetentry(VtFile*, VtEntry*);
492 int	vtfilesetsize(VtFile*, u64int);
493 int	vtfiletruncate(VtFile*);
494 void	vtfileunlock(VtFile*);
495 long	vtfilewrite(VtFile*, void*, long, vlong);
496 
497 int	vttimefmt(Fmt*);
498 
499 extern int chattyventi;
500 extern int ventidoublechecksha1;
501 extern int ventilogging;
502 
503 extern char *VtServerLog;
504 
505 #ifdef __cplusplus
506 }
507 #endif
508 #endif