10 char* name; /* copy here & Fs to ease error reporting */
25 int mempcnt; /* from fossil.c */
27 int fsGetBlockSize(Fs *fs);
40 static char FsysAll[] = "all";
42 static char EFsysBusy[] = "fsys: '%s' busy";
43 static char EFsysExists[] = "fsys: '%s' already exists";
44 static char EFsysNoCurrent[] = "fsys: no current fsys";
45 static char EFsysNotFound[] = "fsys: '%s' not found";
46 static char EFsysNotOpen[] = "fsys: '%s' not open";
52 return vtstrdup(host);
53 host = getenv("venti");
55 host = vtstrdup("$venti");
60 prventihost(char *host)
65 fprint(2, "%s: dialing venti at %s\n",
66 argv0, netmkaddr(vh, 0, "venti"));
78 myRedial(VtConn *z, char *host)
81 return vtredial(z, host);
89 if(name == nil || name[0] == '\0')
93 for(fsys = sbox.head; fsys != nil; fsys = fsys->next){
94 if(strcmp(name, fsys->name) == 0){
101 werrstr(EFsysNotFound, name);
106 cmdPrintConfig(int argc, char* argv[])
109 char *usage = "usage: printconfig";
113 return cliError(usage);
117 return cliError(usage);
120 for(fsys = sbox.head; fsys != nil; fsys = fsys->next){
121 consPrint("\tfsys %s config %s\n", fsys->name, fsys->dev);
122 if(fsys->venti && fsys->venti[0])
123 consPrint("\tfsys %s venti %q\n", fsys->name,
135 if((fsys = _fsysGet(name)) == nil)
140 werrstr(EFsysNotOpen, fsys->name);
141 qunlock(&fsys->lock);
145 qunlock(&fsys->lock);
151 fsysGetName(Fsys* fsys)
157 fsysIncRef(Fsys* fsys)
170 assert(fsys->ref > 0);
176 fsysGetFs(Fsys* fsys)
178 assert(fsys != nil && fsys->fs != nil);
184 fsysFsRlock(Fsys* fsys)
186 rlock(&fsys->fs->elk);
190 fsysFsRUnlock(Fsys* fsys)
192 runlock(&fsys->fs->elk);
196 fsysNoAuthCheck(Fsys* fsys)
202 fsysNoPermCheck(Fsys* fsys)
208 fsysWstatAllow(Fsys* fsys)
210 return fsys->wstatallow;
213 static char modechars[] = "YUGalLdHSATs";
214 static ulong modebits[] = {
231 fsysModeString(ulong mode, char *buf)
237 for(i=0; modebits[i]; i++)
238 if(mode & modebits[i])
240 sprint(p, "%luo", mode&0777);
245 fsysParseMode(char* s, ulong* mode)
251 for(; *s < '0' || *s > '9'; s++){
254 p = strchr(modechars, *s);
257 x |= modebits[p-modechars];
259 y = strtoul(s, &p, 8);
260 if(*p != '\0' || y > 0777)
267 fsysGetRoot(Fsys* fsys, char* name)
271 assert(fsys != nil && fsys->fs != nil);
273 root = fsGetRoot(fsys->fs);
274 if(name == nil || strcmp(name, "") == 0)
277 sub = fileWalk(root, name);
284 fsysAlloc(char* name, char* dev)
289 for(fsys = sbox.head; fsys != nil; fsys = fsys->next){
290 if(strcmp(fsys->name, name) != 0)
292 werrstr(EFsysExists, name);
297 fsys = vtmallocz(sizeof(Fsys));
298 fsys->name = vtstrdup(name);
299 fsys->dev = vtstrdup(dev);
304 sbox.tail->next = fsys;
314 fsysClose(Fsys* fsys, int argc, char* argv[])
316 char *usage = "usage: [fsys name] close";
320 return cliError(usage);
323 return cliError(usage);
325 return cliError("close isn't working yet; halt %s and then kill fossil",
329 * Oooh. This could be hard. What if fsys->ref != 1?
330 * Also, fsClose() either does the job or panics, can we
331 * gracefully detect it's still busy?
333 * More thought and care needed here.
336 vtfreeconn(fsys->session);
339 if(sbox.curfsys != nil && strcmp(fsys->name, sbox.curfsys) == 0){
349 fsysVac(Fsys* fsys, int argc, char* argv[])
351 uchar score[VtScoreSize];
352 char *usage = "usage: [fsys name] vac path";
356 return cliError(usage);
359 return cliError(usage);
361 if(!fsVac(fsys->fs, argv[0], score))
364 consPrint("vac:%V\n", score);
369 fsysSnap(Fsys* fsys, int argc, char* argv[])
372 char *usage = "usage: [fsys name] snap [-a] [-s /active] [-d /archive/yyyy/mmmm]";
380 return cliError(usage);
385 if((dst = ARGF()) == nil)
386 return cliError(usage);
389 if((src = ARGF()) == nil)
390 return cliError(usage);
394 return cliError(usage);
396 if(!fsSnapshot(fsys->fs, src, dst, doarchive))
403 fsysSnapClean(Fsys *fsys, int argc, char* argv[])
405 u32int arch, snap, life;
406 char *usage = "usage: [fsys name] snapclean [maxminutes]\n";
410 return cliError(usage);
414 return cliError(usage);
416 life = atoi(argv[0]);
418 snapGetTimes(fsys->fs->snap, &arch, &snap, &life);
420 fsSnapshotCleanup(fsys->fs, life);
425 fsysSnapTime(Fsys* fsys, int argc, char* argv[])
429 u32int arch, snap, life;
430 char *usage = "usage: [fsys name] snaptime [-a hhmm] [-s snapminutes] [-t maxminutes]";
433 snapGetTimes(fsys->fs->snap, &arch, &snap, &life);
439 return cliError(usage);
440 if(strcmp(x, "none") == 0){
444 if(strlen(x) != 4 || strspn(x, "0123456789") != 4)
445 return cliError(usage);
446 hh = (x[0]-'0')*10 + x[1]-'0';
447 mm = (x[2]-'0')*10 + x[3]-'0';
448 if(hh >= 24 || mm >= 60)
449 return cliError(usage);
456 return cliError(usage);
457 if(strcmp(x, "none") == 0){
467 return cliError(usage);
468 if(strcmp(x, "none") == 0){
475 return cliError(usage);
478 return cliError(usage);
481 snapSetTimes(fsys->fs->snap, arch, snap, life);
484 snapGetTimes(fsys->fs->snap, &arch, &snap, &life);
485 if(arch != ~(u32int)0)
486 sprint(buf, "-a %02d%02d", arch/60, arch%60);
488 sprint(buf, "-a none");
489 if(snap != ~(u32int)0)
490 sprint(buf+strlen(buf), " -s %d", snap);
492 sprint(buf+strlen(buf), " -s none");
493 if(life != ~(u32int)0)
494 sprint(buf+strlen(buf), " -t %ud", life);
496 sprint(buf+strlen(buf), " -t none");
497 consPrint("\tsnaptime %s\n", buf);
502 fsysSync(Fsys* fsys, int argc, char* argv[])
504 char *usage = "usage: [fsys name] sync";
509 return cliError(usage);
512 return cliError(usage);
514 n = cacheDirty(fsys->fs->cache);
516 consPrint("\t%s sync: wrote %d blocks\n", fsys->name, n);
521 fsysHalt(Fsys *fsys, int argc, char* argv[])
523 char *usage = "usage: [fsys name] halt";
527 return cliError(usage);
530 return cliError(usage);
537 fsysUnhalt(Fsys *fsys, int argc, char* argv[])
539 char *usage = "usage: [fsys name] unhalt";
543 return cliError(usage);
546 return cliError(usage);
548 if(!fsys->fs->halted)
549 return cliError("file system %s not halted", fsys->name);
556 fsysRemove(Fsys* fsys, int argc, char* argv[])
559 char *usage = "usage: [fsys name] remove path ...";
563 return cliError(usage);
566 return cliError(usage);
568 rlock(&fsys->fs->elk);
570 if((file = fileOpen(fsys->fs, argv[0])) == nil)
571 consPrint("%s: %r\n", argv[0]);
573 if(!fileRemove(file, uidadm))
574 consPrint("%s: %r\n", argv[0]);
580 runlock(&fsys->fs->elk);
586 fsysClri(Fsys* fsys, int argc, char* argv[])
588 char *usage = "usage: [fsys name] clri path ...";
592 return cliError(usage);
595 return cliError(usage);
597 rlock(&fsys->fs->elk);
599 if(!fileClriPath(fsys->fs, argv[0], uidadm))
600 consPrint("clri %s: %r\n", argv[0]);
604 runlock(&fsys->fs->elk);
610 * Inspect and edit the labels for blocks on disk.
613 fsysLabel(Fsys* fsys, int argc, char* argv[])
620 char *usage = "usage: [fsys name] label addr [type state epoch epochClose tag]";
624 return cliError(usage);
626 if(argc != 1 && argc != 6)
627 return cliError(usage);
630 rlock(&fsys->fs->elk);
633 addr = strtoul(argv[0], 0, 0);
634 b = cacheLocal(fs->cache, PartData, addr, OReadOnly);
639 consPrint("%slabel %#ux %ud %ud %ud %ud %#x\n",
640 argc==6 ? "old: " : "", addr, l.type, l.state,
641 l.epoch, l.epochClose, l.tag);
644 if(strcmp(argv[1], "-") != 0)
645 l.type = atoi(argv[1]);
646 if(strcmp(argv[2], "-") != 0)
647 l.state = atoi(argv[2]);
648 if(strcmp(argv[3], "-") != 0)
649 l.epoch = strtoul(argv[3], 0, 0);
650 if(strcmp(argv[4], "-") != 0)
651 l.epochClose = strtoul(argv[4], 0, 0);
652 if(strcmp(argv[5], "-") != 0)
653 l.tag = strtoul(argv[5], 0, 0);
655 consPrint("new: label %#ux %ud %ud %ud %ud %#x\n",
656 addr, l.type, l.state, l.epoch, l.epochClose, l.tag);
657 bb = _blockSetLabel(b, &l);
662 if(blockWrite(bb, Waitlock)){
663 while(bb->iostate != BioClean){
664 assert(bb->iostate == BioWriting);
665 rsleep(&bb->ioready);
669 consPrint("blockWrite: %r\n");
671 consPrint("giving up\n");
688 * Inspect and edit the blocks on disk.
691 fsysBlock(Fsys* fsys, int argc, char* argv[])
698 int c, count, i, offset;
699 char *usage = "usage: [fsys name] block addr offset [count [data]]";
703 return cliError(usage);
705 if(argc < 2 || argc > 4)
706 return cliError(usage);
709 addr = strtoul(argv[0], 0, 0);
710 offset = strtoul(argv[1], 0, 0);
711 if(offset < 0 || offset >= fs->blockSize){
712 werrstr("bad offset");
716 count = strtoul(argv[2], 0, 0);
719 if(offset+count > fs->blockSize)
720 count = fs->blockSize - count;
724 b = cacheLocal(fs->cache, PartData, addr, argc==4 ? OReadWrite : OReadOnly);
726 werrstr("cacheLocal %#ux: %r", addr);
731 consPrint("\t%sblock %#ux %ud %ud %.*H\n",
732 argc==4 ? "old: " : "", addr, offset, count, count, b->data+offset);
736 if(strlen(s) != 2*count){
737 werrstr("bad data count");
740 buf = vtmallocz(count);
741 for(i = 0; i < count*2; i++){
742 if(s[i] >= '0' && s[i] <= '9')
744 else if(s[i] >= 'a' && s[i] <= 'f')
746 else if(s[i] >= 'A' && s[i] <= 'F')
757 memmove(b->data+offset, buf, count);
758 consPrint("\tnew: block %#ux %ud %ud %.*H\n",
759 addr, offset, count, count, b->data+offset);
774 fsysBfree(Fsys* fsys, int argc, char* argv[])
781 char *usage = "usage: [fsys name] bfree addr ...";
785 return cliError(usage);
788 return cliError(usage);
793 addr = strtoul(argv[0], &p, 0);
795 consPrint("bad address - '%ud'\n", addr);
796 /* syntax error; let's stop */
800 b = cacheLocal(fs->cache, PartData, addr, OReadOnly);
802 consPrint("loading %#ux: %r\n", addr);
806 if(l.state == BsFree)
807 consPrint("%#ux is already free\n", addr);
809 consPrint("label %#ux %ud %ud %ud %ud %#x\n",
810 addr, l.type, l.state, l.epoch, l.epochClose, l.tag);
816 if(!blockSetLabel(b, &l, 0))
817 consPrint("freeing %#ux: %r\n", addr);
829 fsysDf(Fsys *fsys, int argc, char* argv[])
831 char *usage = "usage: [fsys name] df";
832 u32int used, tot, bsize;
837 return cliError(usage);
840 return cliError(usage);
843 cacheCountUsed(fs->cache, fs->elo, &used, &tot, &bsize);
844 consPrint("\t%s: %,llud used + %,llud free = %,llud (%.1f%% used)\n",
845 fsys->name, used*(vlong)bsize, (tot-used)*(vlong)bsize,
846 tot*(vlong)bsize, used*100.0/tot);
851 * Zero an entry or a pointer.
854 fsysClrep(Fsys* fsys, int argc, char* argv[], int ch)
860 int i, max, offset, sz;
861 uchar zero[VtEntrySize];
862 char *usage = "usage: [fsys name] clr%c addr offset ...";
866 return cliError(usage, ch);
869 return cliError(usage, ch);
872 rlock(&fsys->fs->elk);
874 addr = strtoul(argv[0], 0, 0);
875 b = cacheLocal(fs->cache, PartData, addr, argc==4 ? OReadWrite : OReadOnly);
877 werrstr("cacheLocal %#ux: %r", addr);
879 runlock(&fsys->fs->elk);
888 if(b->l.type != BtDir){
889 werrstr("wrong block type");
893 memset(&e, 0, sizeof e);
894 entryPack(&e, zero, 0);
897 if(b->l.type == BtDir || b->l.type == BtData){
898 werrstr("wrong block type");
902 memmove(zero, vtzeroscore, VtScoreSize);
905 max = fs->blockSize/sz;
907 for(i = 1; i < argc; i++){
908 offset = atoi(argv[i]);
910 consPrint("\toffset %d too large (>= %d)\n", i, max);
913 consPrint("\tblock %#ux %d %d %.*H\n", addr, offset*sz, sz, sz, b->data+offset*sz);
914 memmove(b->data+offset*sz, zero, sz);
918 runlock(&fsys->fs->elk);
924 fsysClre(Fsys* fsys, int argc, char* argv[])
926 return fsysClrep(fsys, argc, argv, 'e');
930 fsysClrp(Fsys* fsys, int argc, char* argv[])
932 return fsysClrep(fsys, argc, argv, 'p');
936 fsysEsearch1(File* f, char* s, u32int elo)
951 r = deeRead(dee, &de);
953 consPrint("\tdeeRead %s/%s: %r\n", s, de.elem);
958 if(de.mode & ModeSnapshot){
959 if((ff = fileWalk(f, de.elem)) == nil)
960 consPrint("\tcannot walk %s/%s: %r\n", s, de.elem);
962 if(!fileGetSources(ff, &e, &ee))
963 consPrint("\tcannot get sources for %s/%s: %r\n", s, de.elem);
964 else if(e.snap != 0 && e.snap < elo){
965 consPrint("\t%ud\tclri %s/%s\n", e.snap, s, de.elem);
971 else if(de.mode & ModeDir){
972 if((ff = fileWalk(f, de.elem)) == nil)
973 consPrint("\tcannot walk %s/%s: %r\n", s, de.elem);
975 t = smprint("%s/%s", s, de.elem);
976 n += fsysEsearch1(ff, t, elo);
991 fsysEsearch(Fs* fs, char* path, u32int elo)
997 f = fileOpen(fs, path);
1000 if(!fileGetDir(f, &de)){
1001 consPrint("\tfileGetDir %s failed: %r\n", path);
1005 if((de.mode & ModeDir) == 0){
1011 n = fsysEsearch1(f, path, elo);
1017 fsysEpoch(Fsys* fsys, int argc, char* argv[])
1020 int force, n, remove;
1022 char *usage = "usage: [fsys name] epoch [[-ry] low]";
1034 return cliError(usage);
1037 return cliError(usage);
1039 low = strtoul(argv[0], 0, 0);
1044 return cliError("low epoch cannot be zero");
1049 consPrint("\tlow %ud hi %ud\n", fs->elo, fs->ehi);
1050 if(low == ~(u32int)0){
1054 n = fsysEsearch(fsys->fs, "/archive", low);
1055 n += fsysEsearch(fsys->fs, "/snapshot", low);
1056 consPrint("\t%d snapshot%s found with epoch < %ud\n", n, n==1 ? "" : "s", low);
1060 * There's a small race here -- a new snapshot with epoch < low might
1061 * get introduced now that we unlocked fs->elk. Low has to
1062 * be <= fs->ehi. Of course, in order for this to happen low has
1063 * to be equal to the current fs->ehi _and_ a snapshot has to
1064 * run right now. This is a small enough window that I don't care.
1066 if(n != 0 && !force){
1067 consPrint("\tnot setting low epoch\n");
1071 if(!fsEpochLow(fs, low))
1072 consPrint("\tfsEpochLow: %r\n");
1074 consPrint("\told: epoch%s %ud\n", force ? " -y" : "", old);
1075 consPrint("\tnew: epoch%s %ud\n", force ? " -y" : "", fs->elo);
1077 consPrint("\twarning: new low epoch < old low epoch\n");
1079 fsSnapshotRemove(fs);
1086 fsysCreate(Fsys* fsys, int argc, char* argv[])
1090 char *elem, *p, *path;
1091 char *usage = "usage: [fsys name] create path uid gid perm";
1093 File *file, *parent;
1097 return cliError(usage);
1100 return cliError(usage);
1102 if(!fsysParseMode(argv[3], &mode))
1103 return cliError(usage);
1104 if(mode&ModeSnapshot)
1105 return cliError("create - cannot create with snapshot bit set");
1107 if(strcmp(argv[1], uidnoworld) == 0)
1108 return cliError("permission denied");
1110 rlock(&fsys->fs->elk);
1111 path = vtstrdup(argv[0]);
1112 if((p = strrchr(path, '/')) != nil){
1125 if((parent = fileOpen(fsys->fs, p)) == nil)
1128 file = fileCreate(parent, elem, mode, argv[1]);
1131 werrstr("create %s/%s: %r", p, elem);
1135 if(!fileGetDir(file, &de)){
1136 werrstr("stat failed after create: %r");
1140 if(strcmp(de.gid, argv[2]) != 0){
1142 de.gid = vtstrdup(argv[2]);
1143 if(!fileSetDir(file, &de, argv[1])){
1144 werrstr("wstat failed after create: %r");
1156 runlock(&fsys->fs->elk);
1162 fsysPrintStat(char *prefix, char *file, DirEntry *de)
1168 consPrint("%sstat %q %q %q %q %s %llud\n", prefix,
1169 file, de->elem, de->uid, de->gid, fsysModeString(de->mode, buf), de->size);
1173 fsysStat(Fsys* fsys, int argc, char* argv[])
1178 char *usage = "usage: [fsys name] stat files...";
1182 return cliError(usage);
1186 return cliError(usage);
1188 rlock(&fsys->fs->elk);
1189 for(i=0; i<argc; i++){
1190 if((f = fileOpen(fsys->fs, argv[i])) == nil){
1191 consPrint("%s: %r\n", argv[i]);
1194 if(!fileGetDir(f, &de)){
1195 consPrint("%s: %r\n", argv[i]);
1199 fsysPrintStat("\t", argv[i], &de);
1203 runlock(&fsys->fs->elk);
1208 fsysWstat(Fsys *fsys, int argc, char* argv[])
1213 char *usage = "usage: [fsys name] wstat file elem uid gid mode length\n"
1214 "\tuse - for any field to mean don't change";
1218 return cliError(usage);
1222 return cliError(usage);
1224 rlock(&fsys->fs->elk);
1225 if((f = fileOpen(fsys->fs, argv[0])) == nil){
1226 werrstr("console wstat - walk - %r");
1227 runlock(&fsys->fs->elk);
1230 if(!fileGetDir(f, &de)){
1231 werrstr("console wstat - stat - %r");
1233 runlock(&fsys->fs->elk);
1236 fsysPrintStat("\told: w", argv[0], &de);
1238 if(strcmp(argv[1], "-") != 0){
1239 if(!validFileName(argv[1])){
1240 werrstr("console wstat - bad elem");
1244 de.elem = vtstrdup(argv[1]);
1246 if(strcmp(argv[2], "-") != 0){
1247 if(!validUserName(argv[2])){
1248 werrstr("console wstat - bad uid");
1252 de.uid = vtstrdup(argv[2]);
1254 if(strcmp(argv[3], "-") != 0){
1255 if(!validUserName(argv[3])){
1256 werrstr("console wstat - bad gid");
1260 de.gid = vtstrdup(argv[3]);
1262 if(strcmp(argv[4], "-") != 0){
1263 if(!fsysParseMode(argv[4], &de.mode)){
1264 werrstr("console wstat - bad mode");
1268 if(strcmp(argv[5], "-") != 0){
1269 de.size = strtoull(argv[5], &p, 0);
1270 if(argv[5][0] == '\0' || *p != '\0' || (vlong)de.size < 0){
1271 werrstr("console wstat - bad length");
1276 if(!fileSetDir(f, &de, uidadm)){
1277 werrstr("console wstat - %r");
1282 if(!fileGetDir(f, &de)){
1283 werrstr("console wstat - stat2 - %r");
1286 fsysPrintStat("\tnew: w", argv[0], &de);
1289 runlock(&fsys->fs->elk);
1294 deCleanup(&de); /* okay to do this twice */
1296 runlock(&fsys->fs->elk);
1301 fsckClri(Fsck *fsck, char *name, MetaBlock *mb, int i, Block *b)
1305 if((fsck->flags&DoClri) == 0)
1314 fsckClose(Fsck *fsck, Block *b, u32int epoch)
1318 if((fsck->flags&DoClose) == 0)
1321 if(l.state == BsFree || (l.state&BsClosed)){
1322 consPrint("%#ux is already closed\n", b->addr);
1326 l.state |= BsClosed;
1327 l.epochClose = epoch;
1331 if(!blockSetLabel(b, &l, 0))
1332 consPrint("%#ux setlabel: %r\n", b->addr);
1336 fsckClre(Fsck *fsck, Block *b, int offset)
1340 if((fsck->flags&DoClre) == 0)
1342 if(offset<0 || offset*VtEntrySize >= fsck->bsize){
1343 consPrint("bad clre\n");
1346 memset(&e, 0, sizeof e);
1347 entryPack(&e, b->data, offset);
1352 fsckClrp(Fsck *fsck, Block *b, int offset)
1354 if((fsck->flags&DoClrp) == 0)
1356 if(offset<0 || offset*VtScoreSize >= fsck->bsize){
1357 consPrint("bad clre\n");
1360 memmove(b->data+offset*VtScoreSize, vtzeroscore, VtScoreSize);
1365 fsysCheck(Fsys *fsys, int argc, char *argv[])
1368 char *usage = "usage: [fsys name] check [-v] [options]";
1373 memset(&fsck, 0, sizeof fsck);
1375 fsck.clri = fsckClri;
1376 fsck.clre = fsckClre;
1377 fsck.clrp = fsckClrp;
1378 fsck.close = fsckClose;
1379 fsck.print = consPrint;
1383 return cliError(usage);
1386 for(i=0; i<argc; i++){
1387 if(strcmp(argv[i], "pblock") == 0)
1388 fsck.printblocks = 1;
1389 else if(strcmp(argv[i], "pdir") == 0)
1391 else if(strcmp(argv[i], "pfile") == 0)
1392 fsck.printfiles = 1;
1393 else if(strcmp(argv[i], "bclose") == 0)
1394 fsck.flags |= DoClose;
1395 else if(strcmp(argv[i], "clri") == 0)
1396 fsck.flags |= DoClri;
1397 else if(strcmp(argv[i], "clre") == 0)
1398 fsck.flags |= DoClre;
1399 else if(strcmp(argv[i], "clrp") == 0)
1400 fsck.flags |= DoClrp;
1401 else if(strcmp(argv[i], "fix") == 0)
1402 fsck.flags |= DoClose|DoClri|DoClre|DoClrp;
1403 else if(strcmp(argv[i], "venti") == 0)
1405 else if(strcmp(argv[i], "snapshot") == 0)
1406 fsck.walksnapshots = 1;
1408 consPrint("unknown option '%s'\n", argv[i]);
1409 return cliError(usage);
1413 halting = fsys->fs->halted==0;
1417 b = superGet(fsys->fs->cache, &super);
1419 consPrint("could not load super block\n");
1423 if(super.current != NilBlock){
1424 consPrint("cannot check fs while archiver is running; "
1425 "wait for it to finish\n");
1430 consPrint("fsck: %d clri, %d clre, %d clrp, %d bclose\n",
1431 fsck.nclri, fsck.nclre, fsck.nclrp, fsck.nclose);
1439 fsysVenti(char* name, int argc, char* argv[])
1443 char *usage = "usage: [fsys name] venti [address]";
1448 return cliError(usage);
1456 return cliError(usage);
1458 if((fsys = _fsysGet(name)) == nil)
1465 vtfree(fsys->venti);
1467 fsys->venti = vtstrdup(host);
1474 /* already open: do a redial */
1475 if(fsys->fs != nil){
1476 if(fsys->session == nil){
1477 werrstr("file system was opened with -V");
1482 if(myRedial(fsys->session, host) < 0
1483 || vtconnect(fsys->session) < 0)
1488 /* not yet open: try to dial */
1490 vtfreeconn(fsys->session);
1492 if((fsys->session = myDial(host)) == nil
1493 || vtconnect(fsys->session) < 0)
1496 qunlock(&fsys->lock);
1505 uvlong size, userpgs = 0, userused = 0;
1510 size = 64*1024*1024;
1511 bp = Bopen("#c/swap", OREAD);
1513 while ((ln = Brdline(bp, '\n')) != nil) {
1514 ln[Blinelen(bp)-1] = '\0';
1515 nf = tokenize(ln, fields, nelem(fields));
1518 if (strcmp(fields[1], "pagesize") == 0)
1519 pgsize = atoi(fields[0]);
1520 else if (strcmp(fields[1], "user") == 0) {
1521 sl = strchr(fields[0], '/');
1524 userpgs = atoll(sl+1);
1525 userused = atoll(fields[0]);
1529 if (pgsize > 0 && userpgs > 0)
1530 size = (userpgs - userused) * pgsize;
1532 /* cap it to keep the size within 32 bits */
1533 if (size >= 3840UL * 1024 * 1024)
1534 size = 3840UL * 1024 * 1024;
1539 fsysOpen(char* name, int argc, char* argv[])
1543 int noauth, noventi, noperm, rflag, wstatallow, noatimeupd;
1545 char *usage = "usage: fsys name open [-APVWr] [-c ncache]";
1548 noauth = noperm = wstatallow = noventi = noatimeupd = 0;
1553 return cliError(usage);
1572 return cliError(usage);
1573 ncache = strtol(argv[0], &p, 0);
1574 if(ncache <= 0 || p == argv[0] || *p != '\0')
1575 return cliError(usage);
1582 return cliError(usage);
1584 if((fsys = _fsysGet(name)) == nil)
1587 /* automatic memory sizing? */
1589 /* TODO: 8K is a hack; use the actual block size */
1590 ncache = (((vlong)freemem() * mempcnt) / 100) / (8*1024);
1596 if(fsys->fs != nil){
1597 werrstr(EFsysBusy, fsys->name);
1598 qunlock(&fsys->lock);
1605 vtfreeconn(fsys->session);
1606 fsys->session = nil;
1609 else if(fsys->session == nil){
1610 if(fsys->venti && fsys->venti[0])
1615 if((fsys->session = myDial(host)) == nil
1616 || vtconnect(fsys->session) < 0 && !noventi)
1617 fprint(2, "warning: connecting to venti: %r\n");
1619 if((fsys->fs = fsOpen(fsys->dev, fsys->session, ncache, rflag)) == nil){
1620 werrstr("fsOpen: %r");
1621 qunlock(&fsys->lock);
1625 fsys->fs->name = fsys->name; /* for better error messages */
1626 fsys->noauth = noauth;
1627 fsys->noperm = noperm;
1628 fsys->wstatallow = wstatallow;
1629 fsys->fs->noatimeupd = noatimeupd;
1630 qunlock(&fsys->lock);
1633 if(strcmp(name, "main") == 0)
1640 fsysUnconfig(char* name, int argc, char* argv[])
1643 char *usage = "usage: fsys name unconfig";
1647 return cliError(usage);
1650 return cliError(usage);
1654 for(fsys = *fp; fsys != nil; fsys = fsys->next){
1655 if(strcmp(fsys->name, name) == 0)
1660 werrstr(EFsysNotFound, name);
1661 wunlock(&sbox.lock);
1664 if(fsys->ref != 0 || fsys->fs != nil){
1665 werrstr(EFsysBusy, fsys->name);
1666 wunlock(&sbox.lock);
1670 wunlock(&sbox.lock);
1672 if(fsys->session != nil)
1673 vtfreeconn(fsys->session);
1674 if(fsys->venti != nil)
1675 vtfree(fsys->venti);
1676 if(fsys->dev != nil)
1678 if(fsys->name != nil)
1686 fsysConfig(char* name, int argc, char* argv[])
1690 char *usage = "usage: fsys name config [dev]";
1694 return cliError(usage);
1697 return cliError(usage);
1704 if((fsys = _fsysGet(part)) != nil){
1706 if(fsys->fs != nil){
1707 werrstr(EFsysBusy, fsys->name);
1708 qunlock(&fsys->lock);
1713 fsys->dev = vtstrdup(part);
1714 qunlock(&fsys->lock);
1716 else if((fsys = fsysAlloc(name, part)) == nil)
1725 int (*f)(Fsys*, int, char**);
1726 int (*f1)(char*, int, char**);
1728 { "close", fsysClose, },
1729 { "config", nil, fsysConfig, },
1730 { "open", nil, fsysOpen, },
1731 { "unconfig", nil, fsysUnconfig, },
1732 { "venti", nil, fsysVenti, },
1734 { "bfree", fsysBfree, },
1735 { "block", fsysBlock, },
1736 { "check", fsysCheck, },
1737 { "clre", fsysClre, },
1738 { "clri", fsysClri, },
1739 { "clrp", fsysClrp, },
1740 { "create", fsysCreate, },
1742 { "epoch", fsysEpoch, },
1743 { "halt", fsysHalt, },
1744 { "label", fsysLabel, },
1745 { "remove", fsysRemove, },
1746 { "snap", fsysSnap, },
1747 { "snaptime", fsysSnapTime, },
1748 { "snapclean", fsysSnapClean, },
1749 { "stat", fsysStat, },
1750 { "sync", fsysSync, },
1751 { "unhalt", fsysUnhalt, },
1752 { "wstat", fsysWstat, },
1753 { "vac", fsysVac, },
1759 fsysXXX1(Fsys *fsys, int i, int argc, char* argv[])
1764 if(fsys->fs == nil){
1765 qunlock(&fsys->lock);
1766 werrstr(EFsysNotOpen, fsys->name);
1771 && fsyscmd[i].f != fsysUnhalt && fsyscmd[i].f != fsysCheck){
1772 werrstr("file system %s is halted", fsys->name);
1773 qunlock(&fsys->lock);
1777 r = (*fsyscmd[i].f)(fsys, argc, argv);
1778 qunlock(&fsys->lock);
1783 fsysXXX(char* name, int argc, char* argv[])
1788 for(i = 0; fsyscmd[i].cmd != nil; i++){
1789 if(strcmp(fsyscmd[i].cmd, argv[0]) == 0)
1793 if(fsyscmd[i].cmd == nil){
1794 werrstr("unknown command - '%s'", argv[0]);
1798 /* some commands want the name... */
1799 if(fsyscmd[i].f1 != nil){
1800 if(strcmp(name, FsysAll) == 0){
1801 werrstr("cannot use fsys %#q with %#q command", FsysAll, argv[0]);
1804 return (*fsyscmd[i].f1)(name, argc, argv);
1807 /* ... but most commands want the Fsys */
1808 if(strcmp(name, FsysAll) == 0){
1811 for(fsys = sbox.head; fsys != nil; fsys = fsys->next){
1813 r = fsysXXX1(fsys, i, argc, argv) && r;
1816 runlock(&sbox.lock);
1818 if((fsys = _fsysGet(name)) == nil)
1820 r = fsysXXX1(fsys, i, argc, argv);
1827 cmdFsysXXX(int argc, char* argv[])
1831 if((name = sbox.curfsys) == nil){
1832 werrstr(EFsysNoCurrent, argv[0]);
1836 return fsysXXX(name, argc, argv);
1840 cmdFsys(int argc, char* argv[])
1843 char *usage = "usage: fsys [name ...]";
1847 return cliError(usage);
1852 currfsysname = sbox.head->name;
1853 for(fsys = sbox.head; fsys != nil; fsys = fsys->next)
1854 consPrint("\t%s\n", fsys->name);
1855 runlock(&sbox.lock);
1860 if(strcmp(argv[0], FsysAll) != 0 && (fsys = fsysGet(argv[0])) == nil)
1862 sbox.curfsys = vtstrdup(argv[0]);
1863 consPrompt(sbox.curfsys);
1869 return fsysXXX(argv[0], argc-1, argv+1);
1877 fmtinstall('H', encodefmt);
1878 fmtinstall('V', scoreFmt);
1879 fmtinstall('L', labelFmt);
1881 cliAddCmd("fsys", cmdFsys);
1882 for(i = 0; fsyscmd[i].cmd != nil; i++){
1883 if(fsyscmd[i].f != nil)
1884 cliAddCmd(fsyscmd[i].cmd, cmdFsysXXX);
1886 /* the venti cmd is special: the fs can be either open or closed */
1887 cliAddCmd("venti", cmdFsysXXX);
1888 cliAddCmd("printconfig", cmdPrintConfig);