tventi.h - plan9port - [fork] Plan 9 from user space
HTML git clone git://src.adamsgaard.dk/plan9port
DIR Log
DIR Files
DIR Refs
DIR README
DIR LICENSE
---
tventi.h (10082B)
---
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