tventi.h - plan9port - [fork] Plan 9 from user space | |
git clone git://src.adamsgaard.dk/plan9port | |
Log | |
Files | |
Refs | |
README | |
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), v… | |
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 dept… | |
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 *b… | |
378 int vtwrite(VtConn*, uchar score[VtScoreSize], uint type, uchar *… | |
379 Packet* vtreadpacket(VtConn*, uchar score[VtScoreSize], uint type… | |
380 int vtwritepacket(VtConn*, uchar score[VtScoreSize], uint type, 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 th… | |
450 uchar score[VtScoreSize]; /* score of block contai… | |
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 p… | |
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, … | |
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 |