9fsys.c 34 KB

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