5 typedef struct ASum ASum;
13 static void sealarena(Arena *arena);
14 static int okarena(Arena *arena);
15 static int loadarena(Arena *arena);
16 static CIBlock *getcib(Arena *arena, int clump, int writing, CIBlock *rock);
17 static void putcib(Arena *arena, CIBlock *cib);
18 static void sumproc(void *);
21 static Rendez sumwait;
29 if(vtproc(sumproc, nil) < 0){
30 seterr(EOk, "can't start arena checksum slave: %r");
37 * make an Arena, and initialize it based upon the disk header and trailer.
40 initarena(Part *part, u64int base, u64int size, u32int blocksize)
46 arena->blocksize = blocksize;
47 arena->clumpmax = arena->blocksize / ClumpInfoSize;
48 arena->base = base + blocksize;
49 arena->size = size - 2 * blocksize;
51 if(loadarena(arena) < 0){
52 seterr(ECorrupt, "arena header or trailer corrupted");
56 if(okarena(arena) < 0){
61 if(arena->sealed && scorecmp(zeroscore, arena->score)==0)
68 freearena(Arena *arena)
72 if(arena->cib.data != nil){
73 putdblock(arena->cib.data);
74 arena->cib.data = nil;
80 newarena(Part *part, char *name, u64int base, u64int size, u32int blocksize)
85 seterr(EOk, "illegal arena name", name);
90 arena->version = ArenaVersion;
91 arena->blocksize = blocksize;
92 arena->clumpmax = arena->blocksize / ClumpInfoSize;
93 arena->base = base + blocksize;
94 arena->size = size - 2 * blocksize;
96 namecp(arena->name, name);
98 if(wbarena(arena)<0 || wbarenahead(arena)<0){
107 readclumpinfo(Arena *arena, int clump, ClumpInfo *ci)
111 cib = getcib(arena, clump, 0, &r);
114 unpackclumpinfo(ci, &cib->data->data[cib->offset]);
120 readclumpinfos(Arena *arena, int clump, ClumpInfo *cis, int n)
125 for(i = 0; i < n; i++){
126 cib = getcib(arena, clump + i, 0, &r);
129 unpackclumpinfo(&cis[i], &cib->data->data[cib->offset]);
136 * write directory information for one clump
137 * must be called the arena locked
140 writeclumpinfo(Arena *arena, int clump, ClumpInfo *ci)
144 cib = getcib(arena, clump, 1, &r);
147 dirtydblock(cib->data, DirtyArenaCib);
148 packclumpinfo(ci, &cib->data->data[cib->offset]);
154 arenadirsize(Arena *arena, u32int clumps)
156 return ((clumps / arena->clumpmax) + 1) * arena->blocksize;
160 * read a clump of data
161 * n is a hint of the size of the data, not including the header
162 * make sure it won't run off the end, then return the number of bytes actually read
165 readarena(Arena *arena, u64int aa, u8int *buf, long n)
169 u32int blocksize, off, m;
176 a = arena->size - arenadirsize(arena, arena->clumps);
177 qunlock(&arena->lock);
179 seterr(EOk, "reading beyond arena clump storage: clumps=%d aa=%lld a=%lld -1 clumps=%lld\n", arena->clumps, aa, a, arena->size - arenadirsize(arena, arena->clumps - 1));
185 blocksize = arena->blocksize;
186 a = arena->base + aa;
187 off = a & (blocksize - 1);
191 b = getdblock(arena->part, a, 1);
197 memmove(&buf[nn], &b->data[off], m);
209 * write some data to the clump section at a given offset
210 * used to fix up corrupted arenas.
213 writearena(Arena *arena, u64int aa, u8int *clbuf, u32int n)
217 u32int blocksize, off, m;
225 a = arena->size - arenadirsize(arena, arena->clumps);
226 if(aa >= a || aa + n > a){
227 qunlock(&arena->lock);
228 seterr(EOk, "writing beyond arena clump storage");
232 blocksize = arena->blocksize;
233 a = arena->base + aa;
234 off = a & (blocksize - 1);
238 b = getdblock(arena->part, a, off != 0 || off + n < blocksize);
240 qunlock(&arena->lock);
243 dirtydblock(b, DirtyArena);
247 memmove(&b->data[off], &clbuf[nn], m);
248 // ok = writepart(arena->part, a, b->data, blocksize);
252 qunlock(&arena->lock);
261 qunlock(&arena->lock);
266 * allocate space for the clump and write it,
267 * updating the arena directory
268 ZZZ question: should this distinguish between an arena
269 filling up and real errors writing the clump?
272 writeaclump(Arena *arena, Clump *c, u8int *clbuf)
276 u32int clump, n, nn, m, off, blocksize;
279 n = c->info.size + ClumpSize;
283 || aa + n + U32Size + arenadirsize(arena, arena->clumps + 1) > arena->size){
286 qunlock(&arena->lock);
289 if(packclump(c, &clbuf[0]) < 0){
290 qunlock(&arena->lock);
295 * write the data out one block at a time
297 blocksize = arena->blocksize;
298 a = arena->base + aa;
299 off = a & (blocksize - 1);
303 b = getdblock(arena->part, a, off != 0);
305 qunlock(&arena->lock);
308 dirtydblock(b, DirtyArena);
312 memmove(&b->data[off], &clbuf[nn], m);
313 // ok = writepart(arena->part, a, b->data, blocksize);
317 qunlock(&arena->lock);
327 arena->used += c->info.size + ClumpSize;
328 arena->uncsize += c->info.uncsize;
329 if(c->info.size < c->info.uncsize)
332 clump = arena->clumps++;
333 if(arena->clumps == 0)
334 sysfatal("clumps wrapped\n");
335 arena->wtime = now();
336 if(arena->ctime == 0)
337 arena->ctime = arena->wtime;
339 writeclumpinfo(arena, clump, &c->info);
340 //ZZZ make this an enum param
341 if((clump & 0x1ff) == 0x1ff){
342 flushciblocks(arena);
346 qunlock(&arena->lock);
351 * once sealed, an arena never has any data added to it.
352 * it should only be changed to fix errors.
353 * this also syncs the clump directory.
356 sealarena(Arena *arena)
358 flushciblocks(arena);
366 backsumarena(Arena *arena)
382 sumproc(void *unused)
404 sumarena(Arena *arena)
410 u8int score[VtScoreSize];
413 if(bs < arena->blocksize)
414 bs = arena->blocksize;
417 * read & sum all blocks except the last one
419 memset(&s, 0, sizeof s);
420 b = alloczblock(bs, 0);
421 e = arena->base + arena->size;
422 for(a = arena->base - arena->blocksize; a + arena->blocksize <= e; a += bs){
424 bs = arena->blocksize;
425 if(readpart(arena->part, a, b->data, bs) < 0)
427 sha1(b->data, bs, nil, &s);
431 * the last one is special, since it may already have the checksum included
433 bs = arena->blocksize;
434 if(readpart(arena->part, e, b->data, bs) < 0){
436 logerr(EOk, "sumarena can't sum %s, read at %lld failed: %r", arena->name, a);
441 sha1(b->data, bs-VtScoreSize, nil, &s);
442 sha1(zeroscore, VtScoreSize, nil, &s);
443 sha1(nil, 0, score, &s);
446 * check for no checksum or the same
448 * the writepart is okay because we flushed the dcache in sealarena
450 if(scorecmp(score, &b->data[bs - VtScoreSize]) != 0){
451 if(scorecmp(zeroscore, &b->data[bs - VtScoreSize]) != 0)
452 logerr(EOk, "overwriting mismatched checksums for arena=%s, found=%V calculated=%V",
453 arena->name, &b->data[bs - VtScoreSize], score);
454 scorecp(&b->data[bs - VtScoreSize], score);
455 if(writepart(arena->part, e, b->data, bs) < 0)
456 logerr(EOk, "sumarena can't write sum for %s: %r", arena->name);
461 scorecp(arena->score, score);
462 qunlock(&arena->lock);
466 * write the arena trailer block to the partition
469 wbarena(Arena *arena)
474 if((b = getdblock(arena->part, arena->base + arena->size, 0)) == nil){
475 logerr(EAdmin, "can't write arena trailer: %r");
478 dirtydblock(b, DirtyArenaTrailer);
479 bad = okarena(arena)<0 || packarena(arena, b->data)<0;
487 wbarenahead(Arena *arena)
493 namecp(head.name, arena->name);
494 head.version = arena->version;
495 head.size = arena->size + 2 * arena->blocksize;
496 head.blocksize = arena->blocksize;
497 b = alloczblock(arena->blocksize, 1);
499 logerr(EAdmin, "can't write arena header: %r");
500 ///ZZZ add error message?
504 * this writepart is okay because it only happens
505 * during initialization.
507 bad = packarenahead(&head, b->data)<0 ||
508 writepart(arena->part, arena->base - arena->blocksize, b->data, arena->blocksize)<0;
516 * read the arena header and trailer blocks from disk
519 loadarena(Arena *arena)
524 b = alloczblock(arena->blocksize, 0);
527 if(readpart(arena->part, arena->base + arena->size, b->data, arena->blocksize) < 0){
531 if(unpackarena(arena, b->data) < 0){
535 if(arena->version != ArenaVersion){
536 seterr(EAdmin, "unknown arena version %d", arena->version);
540 scorecp(arena->score, &b->data[arena->blocksize - VtScoreSize]);
542 if(readpart(arena->part, arena->base - arena->blocksize, b->data, arena->blocksize) < 0){
543 logerr(EAdmin, "can't read arena header: %r");
547 if(unpackarenahead(&head, b->data) < 0)
548 logerr(ECorrupt, "corrupted arena header: %r");
549 else if(namecmp(arena->name, head.name)!=0
550 || arena->version != head.version
551 || arena->blocksize != head.blocksize
552 || arena->size + 2 * arena->blocksize != head.size)
553 logerr(ECorrupt, "arena header inconsistent with arena data");
560 okarena(Arena *arena)
566 dsize = arenadirsize(arena, arena->clumps);
567 if(arena->used + dsize > arena->size){
568 seterr(ECorrupt, "arena used > size");
572 if(arena->cclumps > arena->clumps)
573 logerr(ECorrupt, "arena has more compressed clumps than total clumps");
575 if(arena->uncsize + arena->clumps * ClumpSize + arena->blocksize < arena->used)
576 logerr(ECorrupt, "arena uncompressed size inconsistent with used space %lld %d %lld", arena->uncsize, arena->clumps, arena->used);
578 if(arena->ctime > arena->wtime)
579 logerr(ECorrupt, "arena creation time after last write time");
585 getcib(Arena *arena, int clump, int writing, CIBlock *rock)
591 if(clump >= arena->clumps){
592 seterr(EOk, "clump directory access out of range");
595 block = clump / arena->clumpmax;
596 off = (clump - block * arena->clumpmax) * ClumpInfoSize;
599 if(arena->cib.block == block
600 && arena->cib.data != nil){
601 arena->cib.offset = off;
606 flushciblocks(arena);
615 qunlock(&stats.lock);
621 if(writing && off == 0 && clump == arena->clumps-1)
624 cib->data = getdblock(arena->part, arena->base + arena->size - (block + 1) * arena->blocksize, read);
631 putcib(Arena *arena, CIBlock *cib)
633 if(cib != &arena->cib){
634 putdblock(cib->data);
640 * must be called with arena locked
642 * cache turned off now that dcache does write caching too.
645 flushciblocks(Arena *arena)
649 if(arena->cib.data == nil)
653 qunlock(&stats.lock);
654 // ok = writepart(arena->part, arena->base + arena->size - (arena->cib.block + 1) * arena->blocksize, arena->cib.data->data, arena->blocksize);
657 seterr(EAdmin, "failed writing arena directory block");
658 putdblock(arena->cib.data);
659 arena->cib.data = nil;