9fsys.c 33 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793
  1. #include "stdinc.h"
  2. #include "dat.h"
  3. #include "fns.h"
  4. #include "9.h"
  5. typedef struct Fsys Fsys;
  6. struct Fsys {
  7. VtLock* lock;
  8. char* name;
  9. char* dev;
  10. char* venti;
  11. Fs* fs;
  12. VtSession* session;
  13. int ref;
  14. int noauth;
  15. int noperm;
  16. int wstatallow;
  17. Fsys* next;
  18. };
  19. static struct {
  20. VtLock* lock;
  21. Fsys* head;
  22. Fsys* tail;
  23. char* curfsys;
  24. } sbox;
  25. static char *_argv0;
  26. #define argv0 _argv0
  27. static char FsysAll[] = "all";
  28. static char EFsysBusy[] = "fsys: '%s' busy";
  29. static char EFsysExists[] = "fsys: '%s' already exists";
  30. static char EFsysNoCurrent[] = "fsys: no current fsys";
  31. static char EFsysNotFound[] = "fsys: '%s' not found";
  32. static char EFsysNotOpen[] = "fsys: '%s' not open";
  33. static Fsys*
  34. _fsysGet(char* name)
  35. {
  36. Fsys *fsys;
  37. if(name == nil || name[0] == '\0')
  38. name = "main";
  39. vtRLock(sbox.lock);
  40. for(fsys = sbox.head; fsys != nil; fsys = fsys->next){
  41. if(strcmp(name, fsys->name) == 0){
  42. fsys->ref++;
  43. break;
  44. }
  45. }
  46. vtRUnlock(sbox.lock);
  47. if(fsys == nil)
  48. vtSetError(EFsysNotFound, name);
  49. return fsys;
  50. }
  51. static int
  52. cmdPrintConfig(int argc, char* argv[])
  53. {
  54. Fsys *fsys;
  55. char *usage = "usage: printconfig";
  56. ARGBEGIN{
  57. default:
  58. return cliError(usage);
  59. }ARGEND
  60. if(argc)
  61. return cliError(usage);
  62. vtRLock(sbox.lock);
  63. for(fsys = sbox.head; fsys != nil; fsys = fsys->next){
  64. consPrint("\tfsys %s config %s\n", fsys->name, fsys->dev);
  65. if(fsys->venti && fsys->venti[0])
  66. consPrint("\tfsys %s venti %q\n", fsys->name, fsys->venti);
  67. }
  68. vtRUnlock(sbox.lock);
  69. return 1;
  70. }
  71. Fsys*
  72. fsysGet(char* name)
  73. {
  74. Fsys *fsys;
  75. if((fsys = _fsysGet(name)) == nil)
  76. return nil;
  77. vtLock(fsys->lock);
  78. if(fsys->fs == nil){
  79. vtSetError(EFsysNotOpen, fsys->name);
  80. vtUnlock(fsys->lock);
  81. fsysPut(fsys);
  82. return nil;
  83. }
  84. vtUnlock(fsys->lock);
  85. return fsys;
  86. }
  87. char*
  88. fsysGetName(Fsys* fsys)
  89. {
  90. return fsys->name;
  91. }
  92. Fsys*
  93. fsysIncRef(Fsys* fsys)
  94. {
  95. vtLock(sbox.lock);
  96. fsys->ref++;
  97. vtUnlock(sbox.lock);
  98. return fsys;
  99. }
  100. void
  101. fsysPut(Fsys* fsys)
  102. {
  103. vtLock(sbox.lock);
  104. assert(fsys->ref > 0);
  105. fsys->ref--;
  106. vtUnlock(sbox.lock);
  107. }
  108. Fs*
  109. fsysGetFs(Fsys* fsys)
  110. {
  111. assert(fsys != nil && fsys->fs != nil);
  112. return fsys->fs;
  113. }
  114. void
  115. fsysFsRlock(Fsys* fsys)
  116. {
  117. vtRLock(fsys->fs->elk);
  118. }
  119. void
  120. fsysFsRUnlock(Fsys* fsys)
  121. {
  122. vtRUnlock(fsys->fs->elk);
  123. }
  124. int
  125. fsysNoAuthCheck(Fsys* fsys)
  126. {
  127. return fsys->noauth;
  128. }
  129. int
  130. fsysNoPermCheck(Fsys* fsys)
  131. {
  132. return fsys->noperm;
  133. }
  134. int
  135. fsysWstatAllow(Fsys* fsys)
  136. {
  137. return fsys->wstatallow;
  138. }
  139. static char modechars[] = "YUGalLdHSATs";
  140. static ulong modebits[] = {
  141. ModeSticky,
  142. ModeSetUid,
  143. ModeSetGid,
  144. ModeAppend,
  145. ModeExclusive,
  146. ModeLink,
  147. ModeDir,
  148. ModeHidden,
  149. ModeSystem,
  150. ModeArchive,
  151. ModeTemporary,
  152. ModeSnapshot,
  153. 0
  154. };
  155. char*
  156. fsysModeString(ulong mode, char *buf)
  157. {
  158. int i;
  159. char *p;
  160. p = buf;
  161. for(i=0; modebits[i]; i++)
  162. if(mode & modebits[i])
  163. *p++ = modechars[i];
  164. sprint(p, "%luo", mode&0777);
  165. return buf;
  166. }
  167. int
  168. fsysParseMode(char* s, ulong* mode)
  169. {
  170. ulong x, y;
  171. char *p;
  172. x = 0;
  173. for(; *s < '0' || *s > '9'; s++){
  174. if(*s == 0)
  175. return 0;
  176. p = strchr(modechars, *s);
  177. if(p == nil)
  178. return 0;
  179. x |= modebits[p-modechars];
  180. }
  181. y = strtoul(s, &p, 8);
  182. if(*p != '\0' || y > 0777)
  183. return 0;
  184. *mode = x|y;
  185. return 1;
  186. }
  187. File*
  188. fsysGetRoot(Fsys* fsys, char* name)
  189. {
  190. File *root, *sub;
  191. assert(fsys != nil && fsys->fs != nil);
  192. root = fsGetRoot(fsys->fs);
  193. if(name == nil || strcmp(name, "") == 0)
  194. return root;
  195. sub = fileWalk(root, name);
  196. fileDecRef(root);
  197. return sub;
  198. }
  199. static Fsys*
  200. fsysAlloc(char* name, char* dev)
  201. {
  202. Fsys *fsys;
  203. vtLock(sbox.lock);
  204. for(fsys = sbox.head; fsys != nil; fsys = fsys->next){
  205. if(strcmp(fsys->name, name) != 0)
  206. continue;
  207. vtSetError(EFsysExists, name);
  208. vtUnlock(sbox.lock);
  209. return nil;
  210. }
  211. fsys = vtMemAllocZ(sizeof(Fsys));
  212. fsys->lock = vtLockAlloc();
  213. fsys->name = vtStrDup(name);
  214. fsys->dev = vtStrDup(dev);
  215. fsys->ref = 1;
  216. if(sbox.tail != nil)
  217. sbox.tail->next = fsys;
  218. else
  219. sbox.head = fsys;
  220. sbox.tail = fsys;
  221. vtUnlock(sbox.lock);
  222. return fsys;
  223. }
  224. static int
  225. fsysClose(Fsys* fsys, int argc, char* argv[])
  226. {
  227. char *usage = "usage: [fsys name] close";
  228. ARGBEGIN{
  229. default:
  230. return cliError(usage);
  231. }ARGEND
  232. if(argc)
  233. return cliError(usage);
  234. return cliError("close isn't working yet; halt %s and then kill fossil",
  235. fsys->name);
  236. /*
  237. * Oooh. This could be hard. What if fsys->ref != 1?
  238. * Also, fsClose() either does the job or panics, can we
  239. * gracefully detect it's still busy?
  240. *
  241. * More thought and care needed here.
  242. fsClose(fsys->fs);
  243. fsys->fs = nil;
  244. vtClose(fsys->session);
  245. fsys->session = nil;
  246. if(sbox.curfsys != nil && strcmp(fsys->name, sbox.curfsys) == 0){
  247. sbox.curfsys = nil;
  248. consPrompt(nil);
  249. }
  250. return 1;
  251. */
  252. }
  253. static int
  254. fsysVac(Fsys* fsys, int argc, char* argv[])
  255. {
  256. uchar score[VtScoreSize];
  257. char *usage = "usage: [fsys name] vac path";
  258. ARGBEGIN{
  259. default:
  260. return cliError(usage);
  261. }ARGEND
  262. if(argc != 1)
  263. return cliError(usage);
  264. if(!fsVac(fsys->fs, argv[0], score))
  265. return 0;
  266. consPrint("vac:%V\n", score);
  267. return 1;
  268. }
  269. static int
  270. fsysSnap(Fsys* fsys, int argc, char* argv[])
  271. {
  272. int doarchive;
  273. char *usage = "usage: [fsys name] snap [-a] [-s /active] [-d /archive/yyyy/mmmm]";
  274. char *src, *dst;
  275. src = nil;
  276. dst = nil;
  277. doarchive = 0;
  278. ARGBEGIN{
  279. default:
  280. return cliError(usage);
  281. case 'a':
  282. doarchive = 1;
  283. break;
  284. case 'd':
  285. if((dst = ARGF()) == nil)
  286. return cliError(usage);
  287. break;
  288. case 's':
  289. if((src = ARGF()) == nil)
  290. return cliError(usage);
  291. break;
  292. }ARGEND
  293. if(argc)
  294. return cliError(usage);
  295. if(!fsSnapshot(fsys->fs, src, dst, doarchive))
  296. return 0;
  297. return 1;
  298. }
  299. static int
  300. fsysSnapClean(Fsys *fsys, int argc, char* argv[])
  301. {
  302. u32int arch, snap, life;
  303. char *usage = "usage: [fsys name] snapclean [maxminutes]\n";
  304. ARGBEGIN{
  305. default:
  306. return cliError(usage);
  307. }ARGEND
  308. if(argc > 1)
  309. return cliError(usage);
  310. if(argc == 1)
  311. life = atoi(argv[0]);
  312. else
  313. snapGetTimes(fsys->fs->snap, &arch, &snap, &life);
  314. fsSnapshotCleanup(fsys->fs, life);
  315. return 1;
  316. }
  317. static int
  318. fsysSnapTime(Fsys* fsys, int argc, char* argv[])
  319. {
  320. char buf[128], *x;
  321. int hh, mm, changed;
  322. u32int arch, snap, life;
  323. char *usage = "usage: [fsys name] snaptime [-a hhmm] [-s snapminutes] [-t maxminutes]";
  324. changed = 0;
  325. snapGetTimes(fsys->fs->snap, &arch, &snap, &life);
  326. ARGBEGIN{
  327. case 'a':
  328. changed = 1;
  329. x = ARGF();
  330. if(x == nil)
  331. return cliError(usage);
  332. if(strcmp(x, "none") == 0){
  333. arch = ~(u32int)0;
  334. break;
  335. }
  336. if(strlen(x) != 4 || strspn(x, "0123456789") != 4)
  337. return cliError(usage);
  338. hh = (x[0]-'0')*10 + x[1]-'0';
  339. mm = (x[2]-'0')*10 + x[3]-'0';
  340. if(hh >= 24 || mm >= 60)
  341. return cliError(usage);
  342. arch = hh*60+mm;
  343. break;
  344. case 's':
  345. changed = 1;
  346. x = ARGF();
  347. if(x == nil)
  348. return cliError(usage);
  349. if(strcmp(x, "none") == 0){
  350. snap = ~(u32int)0;
  351. break;
  352. }
  353. snap = atoi(x);
  354. break;
  355. case 't':
  356. changed = 1;
  357. x = ARGF();
  358. if(x == nil)
  359. return cliError(usage);
  360. if(strcmp(x, "none") == 0){
  361. life = ~(u32int)0;
  362. break;
  363. }
  364. life = atoi(x);
  365. break;
  366. default:
  367. return cliError(usage);
  368. }ARGEND
  369. if(argc > 0)
  370. return cliError(usage);
  371. if(changed){
  372. snapSetTimes(fsys->fs->snap, arch, snap, life);
  373. return 1;
  374. }
  375. snapGetTimes(fsys->fs->snap, &arch, &snap, &life);
  376. if(arch != ~(u32int)0)
  377. sprint(buf, "-a %02d%02d", arch/60, arch%60);
  378. else
  379. sprint(buf, "-a none");
  380. if(snap != ~(u32int)0)
  381. sprint(buf+strlen(buf), " -s %d", snap);
  382. else
  383. sprint(buf+strlen(buf), " -s none");
  384. if(life != ~(u32int)0)
  385. sprint(buf+strlen(buf), " -t %ud", life);
  386. else
  387. sprint(buf+strlen(buf), " -t none");
  388. consPrint("\tsnaptime %s\n", buf);
  389. return 1;
  390. }
  391. static int
  392. fsysSync(Fsys* fsys, int argc, char* argv[])
  393. {
  394. char *usage = "usage: [fsys name] sync";
  395. ARGBEGIN{
  396. default:
  397. return cliError(usage);
  398. }ARGEND
  399. if(argc > 0)
  400. return cliError(usage);
  401. fsSync(fsys->fs);
  402. return 1;
  403. }
  404. static int
  405. fsysHalt(Fsys *fsys, int argc, char* argv[])
  406. {
  407. char *usage = "usage: [fsys name] halt";
  408. ARGBEGIN{
  409. default:
  410. return cliError(usage);
  411. }ARGEND
  412. if(argc > 0)
  413. return cliError(usage);
  414. fsHalt(fsys->fs);
  415. return 1;
  416. }
  417. static int
  418. fsysUnhalt(Fsys *fsys, int argc, char* argv[])
  419. {
  420. char *usage = "usage: [fsys name] unhalt";
  421. ARGBEGIN{
  422. default:
  423. return cliError(usage);
  424. }ARGEND
  425. if(argc > 0)
  426. return cliError(usage);
  427. if(!fsys->fs->halted)
  428. return cliError("file system %s not halted", fsys->name);
  429. fsUnhalt(fsys->fs);
  430. return 1;
  431. }
  432. static int
  433. fsysRemove(Fsys* fsys, int argc, char* argv[])
  434. {
  435. File *file;
  436. char *usage = "usage: [fsys name] remove path ...";
  437. ARGBEGIN{
  438. default:
  439. return cliError(usage);
  440. }ARGEND
  441. if(argc == 0)
  442. return cliError(usage);
  443. vtRLock(fsys->fs->elk);
  444. while(argc > 0){
  445. if((file = fileOpen(fsys->fs, argv[0])) == nil)
  446. consPrint("%s: %R\n", argv[0]);
  447. else{
  448. if(!fileRemove(file, uidadm))
  449. consPrint("%s: %R\n", argv[0]);
  450. fileDecRef(file);
  451. }
  452. argc--;
  453. argv++;
  454. }
  455. vtRUnlock(fsys->fs->elk);
  456. return 1;
  457. }
  458. static int
  459. fsysClri(Fsys* fsys, int argc, char* argv[])
  460. {
  461. char *usage = "usage: [fsys name] clri path ...";
  462. ARGBEGIN{
  463. default:
  464. return cliError(usage);
  465. }ARGEND
  466. if(argc == 0)
  467. return cliError(usage);
  468. vtRLock(fsys->fs->elk);
  469. while(argc > 0){
  470. if(!fileClriPath(fsys->fs, argv[0], uidadm))
  471. consPrint("clri %s: %R\n", argv[0]);
  472. argc--;
  473. argv++;
  474. }
  475. vtRUnlock(fsys->fs->elk);
  476. return 1;
  477. }
  478. /*
  479. * Inspect and edit the labels for blocks on disk.
  480. */
  481. static int
  482. fsysLabel(Fsys* fsys, int argc, char* argv[])
  483. {
  484. Fs *fs;
  485. Label l;
  486. int n, r;
  487. u32int addr;
  488. Block *b, *bb;
  489. char *usage = "usage: [fsys name] label addr [type state epoch epochClose tag]";
  490. ARGBEGIN{
  491. default:
  492. return cliError(usage);
  493. }ARGEND
  494. if(argc != 1 && argc != 6)
  495. return cliError(usage);
  496. r = 0;
  497. vtRLock(fsys->fs->elk);
  498. fs = fsys->fs;
  499. addr = strtoul(argv[0], 0, 0);
  500. b = cacheLocal(fs->cache, PartData, addr, OReadOnly);
  501. if(b == nil)
  502. goto Out0;
  503. l = b->l;
  504. consPrint("%slabel %#ux %ud %ud %ud %ud %#x\n",
  505. argc==6 ? "old: " : "", addr, l.type, l.state,
  506. l.epoch, l.epochClose, l.tag);
  507. if(argc == 6){
  508. if(strcmp(argv[1], "-") != 0)
  509. l.type = atoi(argv[1]);
  510. if(strcmp(argv[2], "-") != 0)
  511. l.state = atoi(argv[2]);
  512. if(strcmp(argv[3], "-") != 0)
  513. l.epoch = strtoul(argv[3], 0, 0);
  514. if(strcmp(argv[4], "-") != 0)
  515. l.epochClose = strtoul(argv[4], 0, 0);
  516. if(strcmp(argv[5], "-") != 0)
  517. l.tag = strtoul(argv[5], 0, 0);
  518. consPrint("new: label %#ux %ud %ud %ud %ud %#x\n",
  519. addr, l.type, l.state, l.epoch, l.epochClose, l.tag);
  520. bb = _blockSetLabel(b, &l);
  521. if(bb == nil)
  522. goto Out1;
  523. n = 0;
  524. for(;;){
  525. if(blockWrite(bb)){
  526. while(bb->iostate != BioClean){
  527. assert(bb->iostate == BioWriting);
  528. vtSleep(bb->ioready);
  529. }
  530. break;
  531. }
  532. consPrint("blockWrite: %R\n");
  533. if(n++ >= 5){
  534. consPrint("giving up\n");
  535. break;
  536. }
  537. sleep(5*1000);
  538. }
  539. blockPut(bb);
  540. }
  541. r = 1;
  542. Out1:
  543. blockPut(b);
  544. Out0:
  545. vtRUnlock(fs->elk);
  546. return r;
  547. }
  548. /*
  549. * Inspect and edit the blocks on disk.
  550. */
  551. static int
  552. fsysBlock(Fsys* fsys, int argc, char* argv[])
  553. {
  554. Fs *fs;
  555. char *s;
  556. Block *b;
  557. uchar *buf;
  558. u32int addr;
  559. int c, count, i, offset;
  560. char *usage = "usage: [fsys name] block addr offset [count [data]]";
  561. ARGBEGIN{
  562. default:
  563. return cliError(usage);
  564. }ARGEND
  565. if(argc < 2 || argc > 4)
  566. return cliError(usage);
  567. fs = fsys->fs;
  568. addr = strtoul(argv[0], 0, 0);
  569. offset = strtoul(argv[1], 0, 0);
  570. if(offset < 0 || offset >= fs->blockSize){
  571. vtSetError("bad offset");
  572. return 0;
  573. }
  574. if(argc > 2)
  575. count = strtoul(argv[2], 0, 0);
  576. else
  577. count = 100000000;
  578. if(offset+count > fs->blockSize)
  579. count = fs->blockSize - count;
  580. vtRLock(fs->elk);
  581. b = cacheLocal(fs->cache, PartData, addr, argc==4 ? OReadWrite : OReadOnly);
  582. if(b == nil){
  583. vtSetError("cacheLocal %#ux: %R", addr);
  584. vtRUnlock(fs->elk);
  585. return 0;
  586. }
  587. consPrint("\t%sblock %#ux %ud %ud %.*H\n",
  588. argc==4 ? "old: " : "", addr, offset, count, count, b->data+offset);
  589. if(argc == 4){
  590. s = argv[3];
  591. if(strlen(s) != 2*count){
  592. vtSetError("bad data count");
  593. goto Out;
  594. }
  595. buf = vtMemAllocZ(count);
  596. for(i = 0; i < count*2; i++){
  597. if(s[i] >= '0' && s[i] <= '9')
  598. c = s[i] - '0';
  599. else if(s[i] >= 'a' && s[i] <= 'f')
  600. c = s[i] - 'a' + 10;
  601. else if(s[i] >= 'A' && s[i] <= 'F')
  602. c = s[i] - 'A' + 10;
  603. else{
  604. vtSetError("bad hex");
  605. vtMemFree(buf);
  606. goto Out;
  607. }
  608. if((i & 1) == 0)
  609. c <<= 4;
  610. buf[i>>1] |= c;
  611. }
  612. memmove(b->data+offset, buf, count);
  613. consPrint("\tnew: block %#ux %ud %ud %.*H\n",
  614. addr, offset, count, count, b->data+offset);
  615. blockDirty(b);
  616. }
  617. Out:
  618. blockPut(b);
  619. vtRUnlock(fs->elk);
  620. return 1;
  621. }
  622. /*
  623. * Free a disk block.
  624. */
  625. static int
  626. fsysBfree(Fsys* fsys, int argc, char* argv[])
  627. {
  628. Fs *fs;
  629. Label l;
  630. char *p;
  631. Block *b;
  632. u32int addr;
  633. char *usage = "usage: [fsys name] bfree addr ...";
  634. ARGBEGIN{
  635. default:
  636. return cliError(usage);
  637. }ARGEND
  638. if(argc == 0)
  639. return cliError(usage);
  640. fs = fsys->fs;
  641. vtRLock(fs->elk);
  642. while(argc > 0){
  643. addr = strtoul(argv[0], &p, 0);
  644. if(*p != '\0'){
  645. consPrint("bad address - '%s'\n", addr);
  646. /* syntax error; let's stop */
  647. vtRUnlock(fs->elk);
  648. return 0;
  649. }
  650. b = cacheLocal(fs->cache, PartData, addr, OReadOnly);
  651. if(b == nil){
  652. consPrint("loading %#ux: %R\n", addr);
  653. continue;
  654. }
  655. l = b->l;
  656. if(l.state == BsFree)
  657. consPrint("%#ux is already free\n", addr);
  658. else{
  659. consPrint("label %#ux %ud %ud %ud %ud %#x\n",
  660. addr, l.type, l.state, l.epoch, l.epochClose, l.tag);
  661. l.state = BsFree;
  662. l.type = BtMax;
  663. l.tag = 0;
  664. l.epoch = 0;
  665. l.epochClose = 0;
  666. if(!blockSetLabel(b, &l, 0))
  667. consPrint("freeing %#ux: %R\n", addr);
  668. }
  669. blockPut(b);
  670. argc--;
  671. argv++;
  672. }
  673. vtRUnlock(fs->elk);
  674. return 1;
  675. }
  676. static int
  677. fsysDf(Fsys *fsys, int argc, char* argv[])
  678. {
  679. char *usage = "usage: [fsys name] df";
  680. u32int used, tot, bsize;
  681. Fs *fs;
  682. ARGBEGIN{
  683. default:
  684. return cliError(usage);
  685. }ARGEND
  686. if(argc != 0)
  687. return cliError(usage);
  688. fs = fsys->fs;
  689. cacheCountUsed(fs->cache, fs->elo, &used, &tot, &bsize);
  690. consPrint("\t%s: %,llud used + %,llud free = %,llud (%ud%% used)\n",
  691. fsys->name, used*(vlong)bsize, (tot-used)*(vlong)bsize,
  692. tot*(vlong)bsize, used*100/tot);
  693. return 1;
  694. }
  695. /*
  696. * Zero an entry or a pointer.
  697. */
  698. static int
  699. fsysClrep(Fsys* fsys, int argc, char* argv[], int ch)
  700. {
  701. Fs *fs;
  702. Entry e;
  703. Block *b;
  704. u32int addr;
  705. int i, max, offset, sz;
  706. uchar zero[VtEntrySize];
  707. char *usage = "usage: [fsys name] clr%c addr offset ...";
  708. ARGBEGIN{
  709. default:
  710. return cliError(usage, ch);
  711. }ARGEND
  712. if(argc < 2)
  713. return cliError(usage, ch);
  714. fs = fsys->fs;
  715. vtRLock(fsys->fs->elk);
  716. addr = strtoul(argv[0], 0, 0);
  717. b = cacheLocal(fs->cache, PartData, addr, argc==4 ? OReadWrite : OReadOnly);
  718. if(b == nil){
  719. vtSetError("cacheLocal %#ux: %R", addr);
  720. Err:
  721. vtRUnlock(fsys->fs->elk);
  722. return 0;
  723. }
  724. switch(ch){
  725. default:
  726. vtSetError("clrep");
  727. goto Err;
  728. case 'e':
  729. if(b->l.type != BtDir){
  730. vtSetError("wrong block type");
  731. goto Err;
  732. }
  733. sz = VtEntrySize;
  734. memset(&e, 0, sizeof e);
  735. entryPack(&e, zero, 0);
  736. break;
  737. case 'p':
  738. if(b->l.type == BtDir || b->l.type == BtData){
  739. vtSetError("wrong block type");
  740. goto Err;
  741. }
  742. sz = VtScoreSize;
  743. memmove(zero, vtZeroScore, VtScoreSize);
  744. break;
  745. }
  746. max = fs->blockSize/sz;
  747. for(i = 1; i < argc; i++){
  748. offset = atoi(argv[i]);
  749. if(offset >= max){
  750. consPrint("\toffset %d too large (>= %d)\n", i, max);
  751. continue;
  752. }
  753. consPrint("\tblock %#ux %d %d %.*H\n", addr, offset*sz, sz, sz, b->data+offset*sz);
  754. memmove(b->data+offset*sz, zero, sz);
  755. }
  756. blockDirty(b);
  757. blockPut(b);
  758. vtRUnlock(fsys->fs->elk);
  759. return 1;
  760. }
  761. static int
  762. fsysClre(Fsys* fsys, int argc, char* argv[])
  763. {
  764. return fsysClrep(fsys, argc, argv, 'e');
  765. }
  766. static int
  767. fsysClrp(Fsys* fsys, int argc, char* argv[])
  768. {
  769. return fsysClrep(fsys, argc, argv, 'p');
  770. }
  771. static int
  772. fsysEsearch1(File* f, char* s, u32int elo)
  773. {
  774. int n, r;
  775. DirEntry de;
  776. DirEntryEnum *dee;
  777. File *ff;
  778. Entry e, ee;
  779. char *t;
  780. dee = deeOpen(f);
  781. if(dee == nil)
  782. return 0;
  783. n = 0;
  784. for(;;){
  785. r = deeRead(dee, &de);
  786. if(r < 0){
  787. consPrint("\tdeeRead %s/%s: %R\n", s, de.elem);
  788. break;
  789. }
  790. if(r == 0)
  791. break;
  792. if(de.mode & ModeSnapshot){
  793. if((ff = fileWalk(f, de.elem)) == nil)
  794. consPrint("\tcannot walk %s/%s: %R\n", s, de.elem);
  795. else{
  796. if(!fileGetSources(ff, &e, &ee))
  797. consPrint("\tcannot get sources for %s/%s: %R\n", s, de.elem);
  798. else if(e.snap != 0 && e.snap < elo){
  799. consPrint("\t%ud\tclri %s/%s\n", e.snap, s, de.elem);
  800. n++;
  801. }
  802. fileDecRef(ff);
  803. }
  804. }
  805. else if(de.mode & ModeDir){
  806. if((ff = fileWalk(f, de.elem)) == nil)
  807. consPrint("\tcannot walk %s/%s: %R\n", s, de.elem);
  808. else{
  809. t = smprint("%s/%s", s, de.elem);
  810. n += fsysEsearch1(ff, t, elo);
  811. vtMemFree(t);
  812. fileDecRef(ff);
  813. }
  814. }
  815. deCleanup(&de);
  816. if(r < 0)
  817. break;
  818. }
  819. deeClose(dee);
  820. return n;
  821. }
  822. static int
  823. fsysEsearch(Fs* fs, char* path, u32int elo)
  824. {
  825. int n;
  826. File *f;
  827. DirEntry de;
  828. f = fileOpen(fs, path);
  829. if(f == nil)
  830. return 0;
  831. if(!fileGetDir(f, &de)){
  832. consPrint("\tfileGetDir %s failed: %R\n", path);
  833. fileDecRef(f);
  834. return 0;
  835. }
  836. if((de.mode & ModeDir) == 0){
  837. fileDecRef(f);
  838. deCleanup(&de);
  839. return 0;
  840. }
  841. deCleanup(&de);
  842. n = fsysEsearch1(f, path, elo);
  843. fileDecRef(f);
  844. return n;
  845. }
  846. static int
  847. fsysEpoch(Fsys* fsys, int argc, char* argv[])
  848. {
  849. Fs *fs;
  850. int force, n, remove;
  851. u32int low, old;
  852. char *usage = "usage: [fsys name] epoch [[-ry] low]";
  853. force = 0;
  854. remove = 0;
  855. ARGBEGIN{
  856. case 'y':
  857. force = 1;
  858. break;
  859. case 'r':
  860. remove = 1;
  861. break;
  862. default:
  863. return cliError(usage);
  864. }ARGEND
  865. if(argc > 1)
  866. return cliError(usage);
  867. if(argc > 0)
  868. low = strtoul(argv[0], 0, 0);
  869. else
  870. low = ~(u32int)0;
  871. if(low == 0)
  872. return cliError("low epoch cannot be zero");
  873. fs = fsys->fs;
  874. vtRLock(fs->elk);
  875. consPrint("\tlow %ud hi %ud\n", fs->elo, fs->ehi);
  876. n = fsysEsearch(fsys->fs, "/archive", low);
  877. n += fsysEsearch(fsys->fs, "/snapshot", low);
  878. consPrint("\t%d snapshot%s found with epoch < %ud\n", n, n==1 ? "" : "s", low);
  879. vtRUnlock(fs->elk);
  880. /*
  881. * There's a small race here -- a new snapshot with epoch < low might
  882. * get introduced now that we unlocked fs->elk. Low has to
  883. * be <= fs->ehi. Of course, in order for this to happen low has
  884. * to be equal to the current fs->ehi _and_ a snapshot has to
  885. * run right now. This is a small enough window that I don't care.
  886. */
  887. if(n != 0 && !force){
  888. consPrint("\tnot setting low epoch\n");
  889. return 1;
  890. }
  891. old = fs->elo;
  892. if(!fsEpochLow(fs, low))
  893. consPrint("\tfsEpochLow: %R\n");
  894. else{
  895. consPrint("\told: epoch%s %ud\n", force ? " -y" : "", old);
  896. consPrint("\tnew: epoch%s %ud\n", force ? " -y" : "", fs->elo);
  897. if(fs->elo < low)
  898. consPrint("\twarning: new low epoch < old low epoch\n");
  899. if(force && remove)
  900. fsSnapshotRemove(fs);
  901. }
  902. return 1;
  903. }
  904. static int
  905. fsysCreate(Fsys* fsys, int argc, char* argv[])
  906. {
  907. int r;
  908. ulong mode;
  909. char *elem, *p, *path;
  910. char *usage = "usage: [fsys name] create path uid gid perm";
  911. DirEntry de;
  912. File *file, *parent;
  913. ARGBEGIN{
  914. default:
  915. return cliError(usage);
  916. }ARGEND
  917. if(argc != 4)
  918. return cliError(usage);
  919. if(!fsysParseMode(argv[3], &mode))
  920. return cliError(usage);
  921. if(mode&ModeSnapshot)
  922. return cliError("create - cannot create with snapshot bit set");
  923. if(strcmp(argv[1], uidnoworld) == 0)
  924. return cliError("permission denied");
  925. vtRLock(fsys->fs->elk);
  926. path = vtStrDup(argv[0]);
  927. if((p = strrchr(path, '/')) != nil){
  928. *p++ = '\0';
  929. elem = p;
  930. p = path;
  931. if(*p == '\0')
  932. p = "/";
  933. }
  934. else{
  935. p = "/";
  936. elem = path;
  937. }
  938. r = 0;
  939. if((parent = fileOpen(fsys->fs, p)) == nil)
  940. goto out;
  941. file = fileCreate(parent, elem, mode, argv[1]);
  942. fileDecRef(parent);
  943. if(file == nil){
  944. vtSetError("create %s/%s: %R", p, elem);
  945. goto out;
  946. }
  947. if(!fileGetDir(file, &de)){
  948. vtSetError("stat failed after create: %R");
  949. goto out1;
  950. }
  951. if(strcmp(de.gid, argv[2]) != 0){
  952. vtMemFree(de.gid);
  953. de.gid = vtStrDup(argv[2]);
  954. if(!fileSetDir(file, &de, argv[1])){
  955. vtSetError("wstat failed after create: %R");
  956. goto out2;
  957. }
  958. }
  959. r = 1;
  960. out2:
  961. deCleanup(&de);
  962. out1:
  963. fileDecRef(file);
  964. out:
  965. vtMemFree(path);
  966. vtRUnlock(fsys->fs->elk);
  967. return r;
  968. }
  969. static void
  970. fsysPrintStat(char *prefix, char *file, DirEntry *de)
  971. {
  972. char buf[64];
  973. if(prefix == nil)
  974. prefix = "";
  975. consPrint("%sstat %q %q %q %q %s %llud\n", prefix,
  976. file, de->elem, de->uid, de->gid, fsysModeString(de->mode, buf), de->size);
  977. }
  978. static int
  979. fsysStat(Fsys* fsys, int argc, char* argv[])
  980. {
  981. int i;
  982. File *f;
  983. DirEntry de;
  984. char *usage = "usage: [fsys name] stat files...";
  985. ARGBEGIN{
  986. default:
  987. return cliError(usage);
  988. }ARGEND
  989. if(argc == 0)
  990. return cliError(usage);
  991. vtRLock(fsys->fs->elk);
  992. for(i=0; i<argc; i++){
  993. if((f = fileOpen(fsys->fs, argv[i])) == nil){
  994. consPrint("%s: %R\n");
  995. continue;
  996. }
  997. if(!fileGetDir(f, &de)){
  998. consPrint("%s: %R\n");
  999. fileDecRef(f);
  1000. continue;
  1001. }
  1002. fsysPrintStat("\t", argv[i], &de);
  1003. deCleanup(&de);
  1004. fileDecRef(f);
  1005. }
  1006. vtRUnlock(fsys->fs->elk);
  1007. return 1;
  1008. }
  1009. static int
  1010. fsysWstat(Fsys *fsys, int argc, char* argv[])
  1011. {
  1012. File *f;
  1013. char *p;
  1014. DirEntry de;
  1015. char *usage = "usage: [fsys name] wstat file elem uid gid mode length\n"
  1016. "\tuse - for any field to mean don't change";
  1017. ARGBEGIN{
  1018. default:
  1019. return cliError(usage);
  1020. }ARGEND
  1021. if(argc != 6)
  1022. return cliError(usage);
  1023. vtRLock(fsys->fs->elk);
  1024. if((f = fileOpen(fsys->fs, argv[0])) == nil){
  1025. vtSetError("console wstat - walk - %R");
  1026. vtRUnlock(fsys->fs->elk);
  1027. return 0;
  1028. }
  1029. if(!fileGetDir(f, &de)){
  1030. vtSetError("console wstat - stat - %R");
  1031. fileDecRef(f);
  1032. vtRUnlock(fsys->fs->elk);
  1033. return 0;
  1034. }
  1035. fsysPrintStat("\told: w", argv[0], &de);
  1036. if(strcmp(argv[1], "-") != 0){
  1037. if(!validFileName(argv[1])){
  1038. vtSetError("console wstat - bad elem");
  1039. goto error;
  1040. }
  1041. vtMemFree(de.elem);
  1042. de.elem = vtStrDup(argv[1]);
  1043. }
  1044. if(strcmp(argv[2], "-") != 0){
  1045. if(!validUserName(argv[2])){
  1046. vtSetError("console wstat - bad uid");
  1047. goto error;
  1048. }
  1049. vtMemFree(de.uid);
  1050. de.uid = vtStrDup(argv[2]);
  1051. }
  1052. if(strcmp(argv[3], "-") != 0){
  1053. if(!validUserName(argv[3])){
  1054. vtSetError("console wstat - bad gid");
  1055. goto error;
  1056. }
  1057. vtMemFree(de.gid);
  1058. de.gid = vtStrDup(argv[3]);
  1059. }
  1060. if(strcmp(argv[4], "-") != 0){
  1061. if(!fsysParseMode(argv[4], &de.mode)){
  1062. vtSetError("console wstat - bad mode");
  1063. goto error;
  1064. }
  1065. }
  1066. if(strcmp(argv[5], "-") != 0){
  1067. de.size = strtoull(argv[5], &p, 0);
  1068. if(argv[5][0] == '\0' || *p != '\0' || de.size < 0){
  1069. vtSetError("console wstat - bad length");
  1070. goto error;
  1071. }
  1072. }
  1073. if(!fileSetDir(f, &de, uidadm)){
  1074. vtSetError("console wstat - %R");
  1075. goto error;
  1076. }
  1077. deCleanup(&de);
  1078. if(!fileGetDir(f, &de)){
  1079. vtSetError("console wstat - stat2 - %R");
  1080. goto error;
  1081. }
  1082. fsysPrintStat("\tnew: w", argv[0], &de);
  1083. deCleanup(&de);
  1084. fileDecRef(f);
  1085. vtRUnlock(fsys->fs->elk);
  1086. return 1;
  1087. error:
  1088. deCleanup(&de); /* okay to do this twice */
  1089. fileDecRef(f);
  1090. vtRUnlock(fsys->fs->elk);
  1091. return 0;
  1092. }
  1093. static void
  1094. fsckClri(Fsck *fsck, char *name, MetaBlock *mb, int i, Block *b)
  1095. {
  1096. USED(name);
  1097. if((fsck->flags&DoClri) == 0)
  1098. return;
  1099. mbDelete(mb, i);
  1100. mbPack(mb);
  1101. blockDirty(b);
  1102. }
  1103. static void
  1104. fsckClose(Fsck *fsck, Block *b, u32int epoch)
  1105. {
  1106. Label l;
  1107. if((fsck->flags&DoClose) == 0)
  1108. return;
  1109. l = b->l;
  1110. if(l.state == BsFree || (l.state&BsClosed)){
  1111. consPrint("%#ux is already closed\n", b->addr);
  1112. return;
  1113. }
  1114. if(epoch){
  1115. l.state |= BsClosed;
  1116. l.epochClose = epoch;
  1117. }else
  1118. l.state = BsFree;
  1119. if(!blockSetLabel(b, &l, 0))
  1120. consPrint("%#ux setlabel: %R\n", b->addr);
  1121. }
  1122. static void
  1123. fsckClre(Fsck *fsck, Block *b, int offset)
  1124. {
  1125. Entry e;
  1126. if((fsck->flags&DoClre) == 0)
  1127. return;
  1128. if(offset<0 || offset*VtEntrySize >= fsck->bsize){
  1129. consPrint("bad clre\n");
  1130. return;
  1131. }
  1132. memset(&e, 0, sizeof e);
  1133. entryPack(&e, b->data, offset);
  1134. blockDirty(b);
  1135. }
  1136. static void
  1137. fsckClrp(Fsck *fsck, Block *b, int offset)
  1138. {
  1139. if((fsck->flags&DoClrp) == 0)
  1140. return;
  1141. if(offset<0 || offset*VtScoreSize >= fsck->bsize){
  1142. consPrint("bad clre\n");
  1143. return;
  1144. }
  1145. memmove(b->data+offset*VtScoreSize, vtZeroScore, VtScoreSize);
  1146. blockDirty(b);
  1147. }
  1148. static int
  1149. fsysCheck(Fsys *fsys, int argc, char *argv[])
  1150. {
  1151. int i, halting;
  1152. char *usage = "usage: [fsys name] check [-v] [options]";
  1153. Fsck fsck;
  1154. Block *b;
  1155. Super super;
  1156. memset(&fsck, 0, sizeof fsck);
  1157. fsck.fs = fsys->fs;
  1158. fsck.clri = fsckClri;
  1159. fsck.clre = fsckClre;
  1160. fsck.clrp = fsckClrp;
  1161. fsck.close = fsckClose;
  1162. fsck.print = consPrint;
  1163. ARGBEGIN{
  1164. default:
  1165. return cliError(usage);
  1166. }ARGEND
  1167. for(i=0; i<argc; i++){
  1168. if(strcmp(argv[i], "pblock") == 0)
  1169. fsck.printblocks = 1;
  1170. else if(strcmp(argv[i], "pdir") == 0)
  1171. fsck.printdirs = 1;
  1172. else if(strcmp(argv[i], "pfile") == 0)
  1173. fsck.printfiles = 1;
  1174. else if(strcmp(argv[i], "bclose") == 0)
  1175. fsck.flags |= DoClose;
  1176. else if(strcmp(argv[i], "clri") == 0)
  1177. fsck.flags |= DoClri;
  1178. else if(strcmp(argv[i], "clre") == 0)
  1179. fsck.flags |= DoClre;
  1180. else if(strcmp(argv[i], "clrp") == 0)
  1181. fsck.flags |= DoClrp;
  1182. else if(strcmp(argv[i], "fix") == 0)
  1183. fsck.flags |= DoClose|DoClri|DoClre|DoClrp;
  1184. else if(strcmp(argv[i], "venti") == 0)
  1185. fsck.useventi = 1;
  1186. else if(strcmp(argv[i], "snapshot") == 0)
  1187. fsck.walksnapshots = 1;
  1188. else{
  1189. consPrint("unknown option '%s'\n", argv[i]);
  1190. return cliError(usage);
  1191. }
  1192. }
  1193. halting = fsys->fs->halted==0;
  1194. if(halting)
  1195. fsHalt(fsys->fs);
  1196. if(fsys->fs->arch){
  1197. b = superGet(fsys->fs->cache, &super);
  1198. if(b == nil){
  1199. consPrint("could not load super block\n");
  1200. goto Out;
  1201. }
  1202. blockPut(b);
  1203. if(super.current != NilBlock){
  1204. consPrint("cannot check fs while archiver is running; wait for it to finish\n");
  1205. goto Out;
  1206. }
  1207. }
  1208. fsCheck(&fsck);
  1209. consPrint("fsck: %d clri, %d clre, %d clrp, %d bclose\n",
  1210. fsck.nclri, fsck.nclre, fsck.nclrp, fsck.nclose);
  1211. Out:
  1212. if(halting)
  1213. fsUnhalt(fsys->fs);
  1214. return 1;
  1215. }
  1216. static int
  1217. fsysVenti(char* name, int argc, char* argv[])
  1218. {
  1219. int r;
  1220. char *host;
  1221. char *usage = "usage: [fsys name] venti [address]";
  1222. Fsys *fsys;
  1223. ARGBEGIN{
  1224. default:
  1225. return cliError(usage);
  1226. }ARGEND
  1227. if(argc == 0)
  1228. host = nil;
  1229. else if(argc == 1)
  1230. host = argv[0];
  1231. else
  1232. return cliError(usage);
  1233. if((fsys = _fsysGet(name)) == nil)
  1234. return 0;
  1235. vtLock(fsys->lock);
  1236. if(host == nil)
  1237. host = fsys->venti;
  1238. else{
  1239. vtMemFree(fsys->venti);
  1240. if(host[0])
  1241. fsys->venti = vtStrDup(host);
  1242. else{
  1243. host = nil;
  1244. fsys->venti = nil;
  1245. }
  1246. }
  1247. /* already open: do a redial */
  1248. if(fsys->fs != nil){
  1249. if(fsys->session == nil){
  1250. vtSetError("file system was opened with -V");
  1251. r = 0;
  1252. goto out;
  1253. }
  1254. r = 1;
  1255. if(!vtRedial(fsys->session, host)
  1256. || !vtConnect(fsys->session, 0))
  1257. r = 0;
  1258. goto out;
  1259. }
  1260. /* not yet open: try to dial */
  1261. if(fsys->session)
  1262. vtClose(fsys->session);
  1263. r = 1;
  1264. if((fsys->session = vtDial(host, 0)) == nil
  1265. || !vtConnect(fsys->session, 0))
  1266. r = 0;
  1267. out:
  1268. vtUnlock(fsys->lock);
  1269. fsysPut(fsys);
  1270. return r;
  1271. }
  1272. static int
  1273. fsysOpen(char* name, int argc, char* argv[])
  1274. {
  1275. char *p, *host;
  1276. Fsys *fsys;
  1277. long ncache;
  1278. int noauth, noventi, noperm, rflag, wstatallow;
  1279. char *usage = "usage: fsys name open [-APVWr] [-c ncache]";
  1280. ncache = 1000;
  1281. noauth = noperm = wstatallow = noventi = 0;
  1282. rflag = OReadWrite;
  1283. ARGBEGIN{
  1284. default:
  1285. return cliError(usage);
  1286. case 'A':
  1287. noauth = 1;
  1288. break;
  1289. case 'P':
  1290. noperm = 1;
  1291. break;
  1292. case 'V':
  1293. noventi = 1;
  1294. break;
  1295. case 'W':
  1296. wstatallow = 1;
  1297. break;
  1298. case 'c':
  1299. p = ARGF();
  1300. if(p == nil)
  1301. return cliError(usage);
  1302. ncache = strtol(argv[0], &p, 0);
  1303. if(ncache <= 0 || p == argv[0] || *p != '\0')
  1304. return cliError(usage);
  1305. break;
  1306. case 'r':
  1307. rflag = OReadOnly;
  1308. break;
  1309. }ARGEND
  1310. if(argc)
  1311. return cliError(usage);
  1312. if((fsys = _fsysGet(name)) == nil)
  1313. return 0;
  1314. vtLock(fsys->lock);
  1315. if(fsys->fs != nil){
  1316. vtSetError(EFsysBusy, fsys->name);
  1317. vtUnlock(fsys->lock);
  1318. fsysPut(fsys);
  1319. return 0;
  1320. }
  1321. if(noventi){
  1322. if(fsys->session){
  1323. vtClose(fsys->session);
  1324. fsys->session = nil;
  1325. }
  1326. }
  1327. else if(fsys->session == nil){
  1328. if(fsys->venti && fsys->venti[0])
  1329. host = fsys->venti;
  1330. else
  1331. host = nil;
  1332. fsys->session = vtDial(host, 1);
  1333. if(!vtConnect(fsys->session, nil) && !noventi)
  1334. fprint(2, "warning: connecting to venti: %R\n");
  1335. }
  1336. if((fsys->fs = fsOpen(fsys->dev, fsys->session, ncache, rflag)) == nil){
  1337. vtSetError("fsOpen: %R");
  1338. vtUnlock(fsys->lock);
  1339. fsysPut(fsys);
  1340. return 0;
  1341. }
  1342. fsys->noauth = noauth;
  1343. fsys->noperm = noperm;
  1344. fsys->wstatallow = wstatallow;
  1345. vtUnlock(fsys->lock);
  1346. fsysPut(fsys);
  1347. if(strcmp(name, "main") == 0)
  1348. usersFileRead(nil);
  1349. return 1;
  1350. }
  1351. static int
  1352. fsysUnconfig(char* name, int argc, char* argv[])
  1353. {
  1354. Fsys *fsys, **fp;
  1355. char *usage = "usage: fsys name unconfig";
  1356. ARGBEGIN{
  1357. default:
  1358. return cliError(usage);
  1359. }ARGEND
  1360. if(argc)
  1361. return cliError(usage);
  1362. vtLock(sbox.lock);
  1363. fp = &sbox.head;
  1364. for(fsys = *fp; fsys != nil; fsys = fsys->next){
  1365. if(strcmp(fsys->name, name) == 0)
  1366. break;
  1367. fp = &fsys->next;
  1368. }
  1369. if(fsys == nil){
  1370. vtSetError(EFsysNotFound, name);
  1371. vtUnlock(sbox.lock);
  1372. return 0;
  1373. }
  1374. if(fsys->ref != 0 || fsys->fs != nil){
  1375. vtSetError(EFsysBusy, fsys->name);
  1376. vtUnlock(sbox.lock);
  1377. return 0;
  1378. }
  1379. *fp = fsys->next;
  1380. vtUnlock(sbox.lock);
  1381. if(fsys->session != nil){
  1382. vtClose(fsys->session);
  1383. vtFree(fsys->session);
  1384. }
  1385. if(fsys->venti != nil)
  1386. vtMemFree(fsys->venti);
  1387. if(fsys->dev != nil)
  1388. vtMemFree(fsys->dev);
  1389. if(fsys->name != nil)
  1390. vtMemFree(fsys->name);
  1391. vtMemFree(fsys);
  1392. return 1;
  1393. }
  1394. static int
  1395. fsysConfig(char* name, int argc, char* argv[])
  1396. {
  1397. Fsys *fsys;
  1398. char *usage = "usage: fsys name config dev";
  1399. ARGBEGIN{
  1400. default:
  1401. return cliError(usage);
  1402. }ARGEND
  1403. if(argc != 1)
  1404. return cliError(usage);
  1405. if((fsys = _fsysGet(argv[0])) != nil){
  1406. vtLock(fsys->lock);
  1407. if(fsys->fs != nil){
  1408. vtSetError(EFsysBusy, fsys->name);
  1409. vtUnlock(fsys->lock);
  1410. fsysPut(fsys);
  1411. return 0;
  1412. }
  1413. vtMemFree(fsys->dev);
  1414. fsys->dev = vtStrDup(argv[0]);
  1415. vtUnlock(fsys->lock);
  1416. }
  1417. else if((fsys = fsysAlloc(name, argv[0])) == nil)
  1418. return 0;
  1419. fsysPut(fsys);
  1420. return 1;
  1421. }
  1422. static struct {
  1423. char* cmd;
  1424. int (*f)(Fsys*, int, char**);
  1425. int (*f1)(char*, int, char**);
  1426. } fsyscmd[] = {
  1427. { "close", fsysClose, },
  1428. { "config", nil, fsysConfig, },
  1429. { "open", nil, fsysOpen, },
  1430. { "unconfig", nil, fsysUnconfig, },
  1431. { "venti", nil, fsysVenti, },
  1432. { "bfree", fsysBfree, },
  1433. { "block", fsysBlock, },
  1434. { "check", fsysCheck, },
  1435. { "clre", fsysClre, },
  1436. { "clri", fsysClri, },
  1437. { "clrp", fsysClrp, },
  1438. { "create", fsysCreate, },
  1439. { "df", fsysDf, },
  1440. { "epoch", fsysEpoch, },
  1441. { "halt", fsysHalt, },
  1442. { "label", fsysLabel, },
  1443. { "remove", fsysRemove, },
  1444. { "snap", fsysSnap, },
  1445. { "snaptime", fsysSnapTime, },
  1446. { "snapclean", fsysSnapClean, },
  1447. { "stat", fsysStat, },
  1448. { "sync", fsysSync, },
  1449. { "unhalt", fsysUnhalt, },
  1450. { "wstat", fsysWstat, },
  1451. { "vac", fsysVac, },
  1452. { nil, nil, },
  1453. };
  1454. static int
  1455. fsysXXX1(Fsys *fsys, int i, int argc, char* argv[])
  1456. {
  1457. int r;
  1458. vtLock(fsys->lock);
  1459. if(fsys->fs == nil){
  1460. vtUnlock(fsys->lock);
  1461. vtSetError(EFsysNotOpen, fsys->name);
  1462. return 0;
  1463. }
  1464. if(fsys->fs->halted
  1465. && fsyscmd[i].f != fsysUnhalt && fsyscmd[i].f != fsysCheck){
  1466. vtSetError("file system %s is halted", fsys->name);
  1467. vtUnlock(fsys->lock);
  1468. return 0;
  1469. }
  1470. r = (*fsyscmd[i].f)(fsys, argc, argv);
  1471. vtUnlock(fsys->lock);
  1472. return r;
  1473. }
  1474. static int
  1475. fsysXXX(char* name, int argc, char* argv[])
  1476. {
  1477. int i, r;
  1478. Fsys *fsys;
  1479. for(i = 0; fsyscmd[i].cmd != nil; i++){
  1480. if(strcmp(fsyscmd[i].cmd, argv[0]) == 0)
  1481. break;
  1482. }
  1483. if(fsyscmd[i].cmd == nil){
  1484. vtSetError("unknown command - '%s'", argv[0]);
  1485. return 0;
  1486. }
  1487. /* some commands want the name... */
  1488. if(fsyscmd[i].f1 != nil){
  1489. if(strcmp(name, FsysAll) == 0){
  1490. vtSetError("cannot use fsys %#q with %#q command", FsysAll, argv[0]);
  1491. return 0;
  1492. }
  1493. return (*fsyscmd[i].f1)(name, argc, argv);
  1494. }
  1495. /* ... but most commands want the Fsys */
  1496. if(strcmp(name, FsysAll) == 0){
  1497. r = 1;
  1498. vtRLock(sbox.lock);
  1499. for(fsys = sbox.head; fsys != nil; fsys = fsys->next){
  1500. fsys->ref++;
  1501. r = fsysXXX1(fsys, i, argc, argv) && r;
  1502. fsys->ref--;
  1503. }
  1504. vtRUnlock(sbox.lock);
  1505. }else{
  1506. if((fsys = _fsysGet(name)) == nil)
  1507. return 0;
  1508. r = fsysXXX1(fsys, i, argc, argv);
  1509. fsysPut(fsys);
  1510. }
  1511. return r;
  1512. }
  1513. static int
  1514. cmdFsysXXX(int argc, char* argv[])
  1515. {
  1516. char *name;
  1517. if((name = sbox.curfsys) == nil){
  1518. vtSetError(EFsysNoCurrent, argv[0]);
  1519. return 0;
  1520. }
  1521. return fsysXXX(name, argc, argv);
  1522. }
  1523. static int
  1524. cmdFsys(int argc, char* argv[])
  1525. {
  1526. Fsys *fsys;
  1527. char *usage = "usage: fsys [name ...]";
  1528. ARGBEGIN{
  1529. default:
  1530. return cliError(usage);
  1531. }ARGEND
  1532. if(argc == 0){
  1533. vtRLock(sbox.lock);
  1534. for(fsys = sbox.head; fsys != nil; fsys = fsys->next)
  1535. consPrint("\t%s\n", fsys->name);
  1536. vtRUnlock(sbox.lock);
  1537. return 1;
  1538. }
  1539. if(argc == 1){
  1540. fsys = nil;
  1541. if(strcmp(argv[0], FsysAll) != 0 && (fsys = fsysGet(argv[0])) == nil)
  1542. return 0;
  1543. sbox.curfsys = vtStrDup(argv[0]);
  1544. consPrompt(sbox.curfsys);
  1545. if(fsys)
  1546. fsysPut(fsys);
  1547. return 1;
  1548. }
  1549. return fsysXXX(argv[0], argc-1, argv+1);
  1550. }
  1551. int
  1552. fsysInit(void)
  1553. {
  1554. int i;
  1555. fmtinstall('H', encodefmt);
  1556. fmtinstall('V', scoreFmt);
  1557. fmtinstall('R', vtErrFmt);
  1558. fmtinstall('L', labelFmt);
  1559. sbox.lock = vtLockAlloc();
  1560. cliAddCmd("fsys", cmdFsys);
  1561. for(i = 0; fsyscmd[i].cmd != nil; i++){
  1562. if(fsyscmd[i].f != nil)
  1563. cliAddCmd(fsyscmd[i].cmd, cmdFsysXXX);
  1564. }
  1565. /* the venti cmd is special: the fs can be either open or closed */
  1566. cliAddCmd("venti", cmdFsysXXX);
  1567. cliAddCmd("printconfig", cmdPrintConfig);
  1568. return 1;
  1569. }