tfs.c - 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
---
tfs.c (21701B)
---
1 #include "stdinc.h"
2 #include "dat.h"
3 #include "fns.h"
4 #include "error.h"
5
6 static void fsMetaFlush(void *a);
7 static Snap *snapInit(Fs*);
8 static void snapClose(Snap*);
9
10 Fs *
11 fsOpen(char *file, VtConn *z, long ncache, int mode)
12 {
13 int fd, m;
14 uchar oscore[VtScoreSize];
15 Block *b, *bs;
16 Disk *disk;
17 Fs *fs;
18 Super super;
19 char e[ERRMAX];
20
21 switch(mode){
22 default:
23 werrstr(EBadMode);
24 return nil;
25 case OReadOnly:
26 m = OREAD;
27 break;
28 case OReadWrite:
29 m = ORDWR;
30 break;
31 }
32 fd = open(file, m);
33 if(fd < 0){
34 werrstr("open %s: %r", file);
35 return nil;
36 }
37
38 bwatchInit();
39 disk = diskAlloc(fd);
40 if(disk == nil){
41 werrstr("diskAlloc: %r");
42 close(fd);
43 return nil;
44 }
45
46 fs = vtmallocz(sizeof(Fs));
47 fs->mode = mode;
48 fs->name = vtstrdup(file);
49 fs->blockSize = diskBlockSize(disk);
50 fs->cache = cacheAlloc(disk, z, ncache, mode);
51 if(mode == OReadWrite && z)
52 fs->arch = archInit(fs->cache, disk, fs, z);
53 fs->z = z;
54
55 b = cacheLocal(fs->cache, PartSuper, 0, mode);
56 if(b == nil)
57 goto Err;
58 if(!superUnpack(&super, b->data)){
59 blockPut(b);
60 werrstr("bad super block");
61 goto Err;
62 }
63 blockPut(b);
64
65 fs->ehi = super.epochHigh;
66 fs->elo = super.epochLow;
67
68 //fprint(2, "%s: fs->ehi %d fs->elo %d active=%d\n", argv0, fs->ehi, fs->elo, super.active);
69
70 fs->source = sourceRoot(fs, super.active, mode);
71 if(fs->source == nil){
72 /*
73 * Perhaps it failed because the block is copy-on-write.
74 * Do the copy and try again.
75 */
76 rerrstr(e, sizeof e);
77 if(mode == OReadOnly || strcmp(e, EBadRoot) != 0)
78 goto Err;
79 b = cacheLocalData(fs->cache, super.active, BtDir, RootTag,
80 OReadWrite, 0);
81 if(b == nil){
82 werrstr("cacheLocalData: %r");
83 goto Err;
84 }
85 if(b->l.epoch == fs->ehi){
86 blockPut(b);
87 werrstr("bad root source block");
88 goto Err;
89 }
90 b = blockCopy(b, RootTag, fs->ehi, fs->elo);
91 if(b == nil)
92 goto Err;
93 localToGlobal(super.active, oscore);
94 super.active = b->addr;
95 bs = cacheLocal(fs->cache, PartSuper, 0, OReadWrite);
96 if(bs == nil){
97 blockPut(b);
98 werrstr("cacheLocal: %r");
99 goto Err;
100 }
101 superPack(&super, bs->data);
102 blockDependency(bs, b, 0, oscore, nil);
103 blockPut(b);
104 blockDirty(bs);
105 blockRemoveLink(bs, globalToLocal(oscore), BtDir, RootTag, 0);
106 blockPut(bs);
107 fs->source = sourceRoot(fs, super.active, mode);
108 if(fs->source == nil){
109 werrstr("sourceRoot: %r");
110 goto Err;
111 }
112 }
113
114 //fprint(2, "%s: got fs source\n", argv0);
115
116 rlock(&fs->elk);
117 fs->file = fileRoot(fs->source);
118 fs->source->file = fs->file; /* point back */
119 runlock(&fs->elk);
120 if(fs->file == nil){
121 werrstr("fileRoot: %r");
122 goto Err;
123 }
124
125 //fprint(2, "%s: got file root\n", argv0);
126
127 if(mode == OReadWrite){
128 fs->metaFlush = periodicAlloc(fsMetaFlush, fs, 1000);
129 fs->snap = snapInit(fs);
130 }
131 return fs;
132
133 Err:
134 fprint(2, "%s: fsOpen error\n", argv0);
135 fsClose(fs);
136 return nil;
137 }
138
139 void
140 fsClose(Fs *fs)
141 {
142 rlock(&fs->elk);
143 periodicKill(fs->metaFlush);
144 snapClose(fs->snap);
145 if(fs->file){
146 fileMetaFlush(fs->file, 0);
147 if(!fileDecRef(fs->file))
148 sysfatal("fsClose: files still in use: %r");
149 }
150 fs->file = nil;
151 sourceClose(fs->source);
152 cacheFree(fs->cache);
153 if(fs->arch)
154 archFree(fs->arch);
155 vtfree(fs->name);
156 runlock(&fs->elk);
157 memset(fs, ~0, sizeof(Fs));
158 vtfree(fs);
159 }
160
161 int
162 fsRedial(Fs *fs, char *host)
163 {
164 if(vtredial(fs->z, host) < 0)
165 return 0;
166 if(vtconnect(fs->z) < 0)
167 return 0;
168 return 1;
169 }
170
171 File *
172 fsGetRoot(Fs *fs)
173 {
174 return fileIncRef(fs->file);
175 }
176
177 int
178 fsGetBlockSize(Fs *fs)
179 {
180 return fs->blockSize;
181 }
182
183 Block*
184 superGet(Cache *c, Super* super)
185 {
186 Block *b;
187
188 if((b = cacheLocal(c, PartSuper, 0, OReadWrite)) == nil){
189 fprint(2, "%s: superGet: cacheLocal failed: %r\n", argv0);
190 return nil;
191 }
192 if(!superUnpack(super, b->data)){
193 fprint(2, "%s: superGet: superUnpack failed: %r\n", argv0);
194 blockPut(b);
195 return nil;
196 }
197
198 return b;
199 }
200
201 void
202 superWrite(Block* b, Super* super, int forceWrite)
203 {
204 superPack(super, b->data);
205 blockDirty(b);
206 if(forceWrite){
207 while(!blockWrite(b, Waitlock)){
208 /* this should no longer happen */
209 fprint(2, "%s: could not write super block; "
210 "waiting 10 seconds\n", argv0);
211 sleep(10*1000);
212 }
213 while(b->iostate != BioClean && b->iostate != BioDirty){
214 assert(b->iostate == BioWriting);
215 rsleep(&b->ioready);
216 }
217 /*
218 * it's okay that b might still be dirty.
219 * that means it got written out but with an old root pointer,
220 * but the other fields went out, and those are the ones
221 * we really care about. (specifically, epochHigh; see fsSnapshot).
222 */
223 }
224 }
225
226 /*
227 * Prepare the directory to store a snapshot.
228 * Temporary snapshots go into /snapshot/yyyy/mmdd/hhmm[.#]
229 * Archival snapshots go into /archive/yyyy/mmdd[.#].
230 *
231 * TODO This should be rewritten to eliminate most of the duplication.
232 */
233 static File*
234 fileOpenSnapshot(Fs *fs, char *dstpath, int doarchive)
235 {
236 int n;
237 char buf[30], *s, *p, *elem;
238 File *dir, *f;
239 Tm now;
240
241 if(dstpath){
242 if((p = strrchr(dstpath, '/')) != nil){
243 *p++ = '\0';
244 elem = p;
245 p = dstpath;
246 if(*p == '\0')
247 p = "/";
248 }else{
249 p = "/";
250 elem = dstpath;
251 }
252 if((dir = fileOpen(fs, p)) == nil)
253 return nil;
254 f = fileCreate(dir, elem, ModeDir|ModeSnapshot|0555, "adm");
255 fileDecRef(dir);
256 return f;
257 }else if(doarchive){
258 /*
259 * a snapshot intended to be archived to venti.
260 */
261 dir = fileOpen(fs, "/archive");
262 if(dir == nil)
263 return nil;
264 now = *localtime(time(0));
265
266 /* yyyy */
267 snprint(buf, sizeof(buf), "%d", now.year+1900);
268 f = fileWalk(dir, buf);
269 if(f == nil)
270 f = fileCreate(dir, buf, ModeDir|0555, "adm");
271 fileDecRef(dir);
272 if(f == nil)
273 return nil;
274 dir = f;
275
276 /* mmdd[#] */
277 snprint(buf, sizeof(buf), "%02d%02d", now.mon+1, now.mday);
278 s = buf+strlen(buf);
279 for(n=0;; n++){
280 if(n)
281 seprint(s, buf+sizeof(buf), ".%d", n);
282 f = fileWalk(dir, buf);
283 if(f != nil){
284 fileDecRef(f);
285 continue;
286 }
287 f = fileCreate(dir, buf, ModeDir|ModeSnapshot|0555, "adm");
288 break;
289 }
290 fileDecRef(dir);
291 return f;
292 }else{
293 /*
294 * Just a temporary snapshot
295 * We'll use /snapshot/yyyy/mmdd/hhmm.
296 * There may well be a better naming scheme.
297 * (I'd have used hh:mm but ':' is reserved in Microsoft file systems.)
298 */
299 dir = fileOpen(fs, "/snapshot");
300 if(dir == nil)
301 return nil;
302
303 now = *localtime(time(0));
304
305 /* yyyy */
306 snprint(buf, sizeof(buf), "%d", now.year+1900);
307 f = fileWalk(dir, buf);
308 if(f == nil)
309 f = fileCreate(dir, buf, ModeDir|0555, "adm");
310 fileDecRef(dir);
311 if(f == nil)
312 return nil;
313 dir = f;
314
315 /* mmdd */
316 snprint(buf, sizeof(buf), "%02d%02d", now.mon+1, now.mday);
317 f = fileWalk(dir, buf);
318 if(f == nil)
319 f = fileCreate(dir, buf, ModeDir|0555, "adm");
320 fileDecRef(dir);
321 if(f == nil)
322 return nil;
323 dir = f;
324
325 /* hhmm[.#] */
326 snprint(buf, sizeof buf, "%02d%02d", now.hour, now.min);
327 s = buf+strlen(buf);
328 for(n=0;; n++){
329 if(n)
330 seprint(s, buf+sizeof(buf), ".%d", n);
331 f = fileWalk(dir, buf);
332 if(f != nil){
333 fileDecRef(f);
334 continue;
335 }
336 f = fileCreate(dir, buf, ModeDir|ModeSnapshot|0555, "adm");
337 break;
338 }
339 fileDecRef(dir);
340 return f;
341 }
342 }
343
344 static int
345 fsNeedArch(Fs *fs, uint archMinute)
346 {
347 int need;
348 File *f;
349 char buf[100];
350 Tm now;
351 ulong then;
352
353 then = time(0);
354 now = *localtime(then);
355
356 /* back up to yesterday if necessary */
357 if(now.hour < archMinute/60
358 || now.hour == archMinute/60 && now.min < archMinute%60)
359 now = *localtime(then-86400);
360
361 snprint(buf, sizeof buf, "/archive/%d/%02d%02d",
362 now.year+1900, now.mon+1, now.mday);
363 need = 1;
364 rlock(&fs->elk);
365 f = fileOpen(fs, buf);
366 if(f){
367 need = 0;
368 fileDecRef(f);
369 }
370 runlock(&fs->elk);
371 return need;
372 }
373
374 int
375 fsEpochLow(Fs *fs, u32int low)
376 {
377 Block *bs;
378 Super super;
379
380 wlock(&fs->elk);
381 if(low > fs->ehi){
382 werrstr("bad low epoch (must be <= %ud)", fs->ehi);
383 wunlock(&fs->elk);
384 return 0;
385 }
386
387 if((bs = superGet(fs->cache, &super)) == nil){
388 wunlock(&fs->elk);
389 return 0;
390 }
391
392 super.epochLow = low;
393 fs->elo = low;
394 superWrite(bs, &super, 1);
395 blockPut(bs);
396 wunlock(&fs->elk);
397
398 return 1;
399 }
400
401 static int
402 bumpEpoch(Fs *fs, int doarchive)
403 {
404 uchar oscore[VtScoreSize];
405 u32int oldaddr;
406 Block *b, *bs;
407 Entry e;
408 Source *r;
409 Super super;
410
411 /*
412 * Duplicate the root block.
413 *
414 * As a hint to flchk, the garbage collector,
415 * and any (human) debuggers, store a pointer
416 * to the old root block in entry 1 of the new root block.
417 */
418 r = fs->source;
419 b = cacheGlobal(fs->cache, r->score, BtDir, RootTag, OReadOnly);
420 if(b == nil)
421 return 0;
422
423 memset(&e, 0, sizeof e);
424 e.flags = VtEntryActive | VtEntryLocal | _VtEntryDir;
425 memmove(e.score, b->score, VtScoreSize);
426 e.tag = RootTag;
427 e.snap = b->l.epoch;
428
429 b = blockCopy(b, RootTag, fs->ehi+1, fs->elo);
430 if(b == nil){
431 fprint(2, "%s: bumpEpoch: blockCopy: %r\n", argv0);
432 return 0;
433 }
434
435 if(0) fprint(2, "%s: snapshot root from %d to %d\n", argv0, oldaddr, b->addr);
436 entryPack(&e, b->data, 1);
437 blockDirty(b);
438
439 /*
440 * Update the superblock with the new root and epoch.
441 */
442 if((bs = superGet(fs->cache, &super)) == nil)
443 return 0;
444
445 fs->ehi++;
446 memmove(r->score, b->score, VtScoreSize);
447 r->epoch = fs->ehi;
448
449 super.epochHigh = fs->ehi;
450 oldaddr = super.active;
451 super.active = b->addr;
452 if(doarchive)
453 super.next = oldaddr;
454
455 /*
456 * Record that the new super.active can't get written out until
457 * the new b gets written out. Until then, use the old value.
458 */
459 localToGlobal(oldaddr, oscore);
460 blockDependency(bs, b, 0, oscore, nil);
461 blockPut(b);
462
463 /*
464 * We force the super block to disk so that super.epochHigh gets updated.
465 * Otherwise, if we crash and come back, we might incorrectly treat as active
466 * some of the blocks that making up the snapshot we just created.
467 * Basically every block in the active file system and all the blocks in
468 * the recently-created snapshot depend on the super block now.
469 * Rather than record all those dependencies, we just force the block to disk.
470 *
471 * Note that blockWrite might actually (will probably) send a slightly outdated
472 * super.active to disk. It will be the address of the most recent root that has
473 * gone to disk.
474 */
475 superWrite(bs, &super, 1);
476 blockRemoveLink(bs, globalToLocal(oscore), BtDir, RootTag, 0);
477 blockPut(bs);
478
479 return 1;
480 }
481
482 int
483 saveQid(Fs *fs)
484 {
485 Block *b;
486 Super super;
487 u64int qidMax;
488
489 if((b = superGet(fs->cache, &super)) == nil)
490 return 0;
491 qidMax = super.qid;
492 blockPut(b);
493
494 if(!fileSetQidSpace(fs->file, 0, qidMax))
495 return 0;
496
497 return 1;
498 }
499
500 int
501 fsSnapshot(Fs *fs, char *srcpath, char *dstpath, int doarchive)
502 {
503 File *src, *dst;
504
505 assert(fs->mode == OReadWrite);
506
507 dst = nil;
508
509 if(fs->halted){
510 werrstr("file system is halted");
511 return 0;
512 }
513
514 /*
515 * Freeze file system activity.
516 */
517 wlock(&fs->elk);
518
519 /*
520 * Get the root of the directory we're going to save.
521 */
522 if(srcpath == nil)
523 srcpath = "/active";
524 src = fileOpen(fs, srcpath);
525 if(src == nil)
526 goto Err;
527
528 /*
529 * It is important that we maintain the invariant that:
530 * if both b and bb are marked as Active with start epoch e
531 * and b points at bb, then no other pointers to bb exist.
532 *
533 * When bb is unlinked from b, its close epoch is set to b's epoch.
534 * A block with epoch == close epoch is
535 * treated as free by cacheAllocBlock; this aggressively
536 * reclaims blocks after they have been stored to Venti.
537 *
538 * Let's say src->source is block sb, and src->msource is block
539 * mb. Let's also say that block b holds the Entry structures for
540 * both src->source and src->msource (their Entry structures might
541 * be in different blocks, but the argument is the same).
542 * That is, right now we have:
543 *
544 * b Active w/ epoch e, holds ptrs to sb and mb.
545 * sb Active w/ epoch e.
546 * mb Active w/ epoch e.
547 *
548 * With things as they are now, the invariant requires that
549 * b holds the only pointers to sb and mb. We want to record
550 * pointers to sb and mb in new Entries corresponding to dst,
551 * which breaks the invariant. Thus we need to do something
552 * about b. Specifically, we bump the file system's epoch and
553 * then rewalk the path from the root down to and including b.
554 * This will copy-on-write as we walk, so now the state will be:
555 *
556 * b Snap w/ epoch e, holds ptrs to sb and mb.
557 * new-b Active w/ epoch e+1, holds ptrs to sb and mb.
558 * sb Active w/ epoch e.
559 * mb Active w/ epoch e.
560 *
561 * In this state, it's perfectly okay to make more pointers to sb and mb.
562 */
563 if(!bumpEpoch(fs, 0) || !fileWalkSources(src))
564 goto Err;
565
566 /*
567 * Sync to disk. I'm not sure this is necessary, but better safe than sorry.
568 */
569 cacheFlush(fs->cache, 1);
570
571 /*
572 * Create the directory where we will store the copy of src.
573 */
574 dst = fileOpenSnapshot(fs, dstpath, doarchive);
575 if(dst == nil)
576 goto Err;
577
578 /*
579 * Actually make the copy by setting dst's source and msource
580 * to be src's.
581 */
582 if(!fileSnapshot(dst, src, fs->ehi-1, doarchive))
583 goto Err;
584
585 fileDecRef(src);
586 fileDecRef(dst);
587 src = nil;
588 dst = nil;
589
590 /*
591 * Make another copy of the file system. This one is for the
592 * archiver, so that the file system we archive has the recently
593 * added snapshot both in /active and in /archive/yyyy/mmdd[.#].
594 */
595 if(doarchive){
596 if(!saveQid(fs))
597 goto Err;
598 if(!bumpEpoch(fs, 1))
599 goto Err;
600 }
601
602 wunlock(&fs->elk);
603
604 /* BUG? can fs->arch fall out from under us here? */
605 if(doarchive && fs->arch)
606 archKick(fs->arch);
607
608 return 1;
609
610 Err:
611 fprint(2, "%s: fsSnapshot: %r\n", argv0);
612 if(src)
613 fileDecRef(src);
614 if(dst)
615 fileDecRef(dst);
616 wunlock(&fs->elk);
617 return 0;
618 }
619
620 int
621 fsVac(Fs *fs, char *name, uchar score[VtScoreSize])
622 {
623 int r;
624 DirEntry de;
625 Entry e, ee;
626 File *f;
627
628 rlock(&fs->elk);
629 f = fileOpen(fs, name);
630 if(f == nil){
631 runlock(&fs->elk);
632 return 0;
633 }
634
635 if(!fileGetSources(f, &e, &ee) || !fileGetDir(f, &de)){
636 fileDecRef(f);
637 runlock(&fs->elk);
638 return 0;
639 }
640 fileDecRef(f);
641
642 r = mkVac(fs->z, fs->blockSize, &e, &ee, &de, score);
643 runlock(&fs->elk);
644 return r;
645 }
646
647 static int
648 vtWriteBlock(VtConn *z, uchar *buf, uint n, uint type, uchar score[VtScoreSize])
649 {
650 if(vtwrite(z, score, type, buf, n) < 0)
651 return 0;
652 if(vtsha1check(score, buf, n) < 0)
653 return 0;
654 return 1;
655 }
656
657 int
658 mkVac(VtConn *z, uint blockSize, Entry *pe, Entry *pee, DirEntry *pde, uchar score[VtScoreSize])
659 {
660 uchar buf[8192];
661 int i;
662 uchar *p;
663 uint n;
664 DirEntry de;
665 Entry e, ee, eee;
666 MetaBlock mb;
667 MetaEntry me;
668 VtRoot root;
669
670 e = *pe;
671 ee = *pee;
672 de = *pde;
673
674 if(globalToLocal(e.score) != NilBlock
675 || (ee.flags&VtEntryActive && globalToLocal(ee.score) != NilBlock)){
676 werrstr("can only vac paths already stored on venti");
677 return 0;
678 }
679
680 /*
681 * Build metadata source for root.
682 */
683 n = deSize(&de);
684 if(n+MetaHeaderSize+MetaIndexSize > sizeof buf){
685 werrstr("DirEntry too big");
686 return 0;
687 }
688 memset(buf, 0, sizeof buf);
689 mbInit(&mb, buf, n+MetaHeaderSize+MetaIndexSize, 1);
690 p = mbAlloc(&mb, n);
691 if(p == nil)
692 abort();
693 mbSearch(&mb, de.elem, &i, &me);
694 assert(me.p == nil);
695 me.p = p;
696 me.size = n;
697 dePack(&de, &me);
698 mbInsert(&mb, i, &me);
699 mbPack(&mb);
700
701 eee.size = n+MetaHeaderSize+MetaIndexSize;
702 if(!vtWriteBlock(z, buf, eee.size, VtDataType, eee.score))
703 return 0;
704 eee.psize = 8192;
705 eee.dsize = 8192;
706 eee.depth = 0;
707 eee.flags = VtEntryActive;
708
709 /*
710 * Build root source with three entries in it.
711 */
712 entryPack(&e, buf, 0);
713 entryPack(&ee, buf, 1);
714 entryPack(&eee, buf, 2);
715
716 n = VtEntrySize*3;
717 memset(&root, 0, sizeof root);
718 if(!vtWriteBlock(z, buf, n, VtDirType, root.score))
719 return 0;
720
721 /*
722 * Save root.
723 */
724 strecpy(root.type, root.type+sizeof root.type, "vac");
725 strecpy(root.name, root.name+sizeof root.name, de.elem);
726 root.blocksize = blockSize;
727 vtrootpack(&root, buf);
728 if(!vtWriteBlock(z, buf, VtRootSize, VtRootType, score))
729 return 0;
730
731 return 1;
732 }
733
734 int
735 fsSync(Fs *fs)
736 {
737 wlock(&fs->elk);
738 fileMetaFlush(fs->file, 1);
739 cacheFlush(fs->cache, 1);
740 wunlock(&fs->elk);
741 return 1;
742 }
743
744 int
745 fsHalt(Fs *fs)
746 {
747 wlock(&fs->elk);
748 fs->halted = 1;
749 fileMetaFlush(fs->file, 1);
750 cacheFlush(fs->cache, 1);
751 return 1;
752 }
753
754 int
755 fsUnhalt(Fs *fs)
756 {
757 if(!fs->halted)
758 return 0;
759 fs->halted = 0;
760 wunlock(&fs->elk);
761 return 1;
762 }
763
764 int
765 fsNextQid(Fs *fs, u64int *qid)
766 {
767 Block *b;
768 Super super;
769
770 if((b = superGet(fs->cache, &super)) == nil)
771 return 0;
772
773 *qid = super.qid++;
774
775 /*
776 * It's okay if the super block doesn't go to disk immediately,
777 * since fileMetaAlloc will record a dependency between the
778 * block holding this qid and the super block. See file.c:/^fileMetaAlloc.
779 */
780 superWrite(b, &super, 0);
781 blockPut(b);
782 return 1;
783 }
784
785 static void
786 fsMetaFlush(void *a)
787 {
788 int rv;
789 Fs *fs = a;
790
791 rlock(&fs->elk);
792 rv = fileMetaFlush(fs->file, 1);
793 runlock(&fs->elk);
794 if(rv > 0)
795 cacheFlush(fs->cache, 0);
796 }
797
798 static int
799 fsEsearch1(File *f, char *path, u32int savetime, u32int *plo)
800 {
801 int n, r;
802 DirEntry de;
803 DirEntryEnum *dee;
804 File *ff;
805 Entry e, ee;
806 char *t;
807
808 dee = deeOpen(f);
809 if(dee == nil)
810 return 0;
811
812 n = 0;
813 for(;;){
814 r = deeRead(dee, &de);
815 if(r <= 0)
816 break;
817 if(de.mode & ModeSnapshot){
818 if((ff = fileWalk(f, de.elem)) != nil){
819 if(fileGetSources(ff, &e, &ee))
820 if(de.mtime >= savetime && e.snap != 0)
821 if(e.snap < *plo)
822 *plo = e.snap;
823 fileDecRef(ff);
824 }
825 }
826 else if(de.mode & ModeDir){
827 if((ff = fileWalk(f, de.elem)) != nil){
828 t = smprint("%s/%s", path, de.elem);
829 n += fsEsearch1(ff, t, savetime, plo);
830 vtfree(t);
831 fileDecRef(ff);
832 }
833 }
834 deCleanup(&de);
835 if(r < 0)
836 break;
837 }
838 deeClose(dee);
839
840 return n;
841 }
842
843 static int
844 fsEsearch(Fs *fs, char *path, u32int savetime, u32int *plo)
845 {
846 int n;
847 File *f;
848 DirEntry de;
849
850 f = fileOpen(fs, path);
851 if(f == nil)
852 return 0;
853 if(!fileGetDir(f, &de)){
854 fileDecRef(f);
855 return 0;
856 }
857 if((de.mode & ModeDir) == 0){
858 fileDecRef(f);
859 deCleanup(&de);
860 return 0;
861 }
862 deCleanup(&de);
863 n = fsEsearch1(f, path, savetime, plo);
864 fileDecRef(f);
865 return n;
866 }
867
868 void
869 fsSnapshotCleanup(Fs *fs, u32int age)
870 {
871 u32int lo;
872
873 /*
874 * Find the best low epoch we can use,
875 * given that we need to save all the unventied archives
876 * and all the snapshots younger than age.
877 */
878 rlock(&fs->elk);
879 lo = fs->ehi;
880 fsEsearch(fs, "/archive", 0, &lo);
881 fsEsearch(fs, "/snapshot", time(0)-age*60, &lo);
882 runlock(&fs->elk);
883
884 fsEpochLow(fs, lo);
885 fsSnapshotRemove(fs);
886 }
887
888 /* remove all snapshots that have expired */
889 /* return number of directory entries remaining */
890 static int
891 fsRsearch1(File *f, char *s)
892 {
893 int n, r;
894 DirEntry de;
895 DirEntryEnum *dee;
896 File *ff;
897 char *t, e[ERRMAX];
898
899 dee = deeOpen(f);
900 if(dee == nil)
901 return 0;
902
903 n = 0;
904 for(;;){
905 r = deeRead(dee, &de);
906 if(r <= 0)
907 break;
908 n++;
909 if(de.mode & ModeSnapshot){
910 rerrstr(e, sizeof e);
911 if((ff = fileWalk(f, de.elem)) != nil)
912 fileDecRef(ff);
913 else if(strcmp(e, ESnapOld) == 0){
914 if(fileClri(f, de.elem, "adm"))
915 n--;
916 }
917 }
918 else if(de.mode & ModeDir){
919 if((ff = fileWalk(f, de.elem)) != nil){
920 t = smprint("%s/%s", s, de.elem);
921 if(fsRsearch1(ff, t) == 0)
922 if(fileRemove(ff, "adm"))
923 n--;
924 vtfree(t);
925 fileDecRef(ff);
926 }
927 }
928 deCleanup(&de);
929 if(r < 0)
930 break;
931 }
932 deeClose(dee);
933
934 return n;
935 }
936
937 static int
938 fsRsearch(Fs *fs, char *path)
939 {
940 File *f;
941 DirEntry de;
942
943 f = fileOpen(fs, path);
944 if(f == nil)
945 return 0;
946 if(!fileGetDir(f, &de)){
947 fileDecRef(f);
948 return 0;
949 }
950 if((de.mode & ModeDir) == 0){
951 fileDecRef(f);
952 deCleanup(&de);
953 return 0;
954 }
955 deCleanup(&de);
956 fsRsearch1(f, path);
957 fileDecRef(f);
958 return 1;
959 }
960
961 void
962 fsSnapshotRemove(Fs *fs)
963 {
964 rlock(&fs->elk);
965 fsRsearch(fs, "/snapshot");
966 runlock(&fs->elk);
967 }
968
969 struct Snap
970 {
971 Fs *fs;
972 Periodic*tick;
973 QLock lk;
974 uint snapMinutes;
975 uint archMinute;
976 uint snapLife;
977 u32int lastSnap;
978 u32int lastArch;
979 u32int lastCleanup;
980 uint ignore;
981 };
982
983 static void
984 snapEvent(void *v)
985 {
986 Snap *s;
987 u32int now, min;
988 Tm tm;
989 int need;
990 u32int snaplife;
991
992 s = v;
993
994 now = time(0)/60;
995 qlock(&s->lk);
996
997 /*
998 * Snapshots happen every snapMinutes minutes.
999 * If we miss a snapshot (for example, because we
1000 * were down), we wait for the next one.
1001 */
1002 if(s->snapMinutes != ~0 && s->snapMinutes != 0
1003 && now%s->snapMinutes==0 && now != s->lastSnap){
1004 if(!fsSnapshot(s->fs, nil, nil, 0))
1005 fprint(2, "%s: fsSnapshot snap: %r\n", argv0);
1006 s->lastSnap = now;
1007 }
1008
1009 /*
1010 * Archival snapshots happen at archMinute.
1011 * If we miss an archive (for example, because we
1012 * were down), we do it as soon as possible.
1013 */
1014 tm = *localtime(now*60);
1015 min = tm.hour*60+tm.min;
1016 if(s->archMinute != ~0){
1017 need = 0;
1018 if(min == s->archMinute && now != s->lastArch)
1019 need = 1;
1020 if(s->lastArch == 0){
1021 s->lastArch = 1;
1022 if(fsNeedArch(s->fs, s->archMinute))
1023 need = 1;
1024 }
1025 if(need){
1026 fsSnapshot(s->fs, nil, nil, 1);
1027 s->lastArch = now;
1028 }
1029 }
1030
1031 /*
1032 * Snapshot cleanup happens every snaplife or every day.
1033 */
1034 snaplife = s->snapLife;
1035 if(snaplife == ~0)
1036 snaplife = 24*60;
1037 if(s->lastCleanup+snaplife < now){
1038 fsSnapshotCleanup(s->fs, s->snapLife);
1039 s->lastCleanup = now;
1040 }
1041 qunlock(&s->lk);
1042 }
1043
1044 static Snap*
1045 snapInit(Fs *fs)
1046 {
1047 Snap *s;
1048
1049 s = vtmallocz(sizeof(Snap));
1050 s->fs = fs;
1051 s->tick = periodicAlloc(snapEvent, s, 10*1000);
1052 s->snapMinutes = -1;
1053 s->archMinute = -1;
1054 s->snapLife = -1;
1055 s->ignore = 5*2; /* wait five minutes for clock to stabilize */
1056 return s;
1057 }
1058
1059 void
1060 snapGetTimes(Snap *s, u32int *arch, u32int *snap, u32int *snaplen)
1061 {
1062 if(s == nil){
1063 *snap = -1;
1064 *arch = -1;
1065 *snaplen = -1;
1066 return;
1067 }
1068
1069 qlock(&s->lk);
1070 *snap = s->snapMinutes;
1071 *arch = s->archMinute;
1072 *snaplen = s->snapLife;
1073 qunlock(&s->lk);
1074 }
1075
1076 void
1077 snapSetTimes(Snap *s, u32int arch, u32int snap, u32int snaplen)
1078 {
1079 if(s == nil)
1080 return;
1081
1082 qlock(&s->lk);
1083 s->snapMinutes = snap;
1084 s->archMinute = arch;
1085 s->snapLife = snaplen;
1086 qunlock(&s->lk);
1087 }
1088
1089 static void
1090 snapClose(Snap *s)
1091 {
1092 if(s == nil)
1093 return;
1094
1095 periodicKill(s->tick);
1096 vtfree(s);
1097 }