ramfs.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896
  1. #include <u.h>
  2. #include <libc.h>
  3. #include <auth.h>
  4. #include <fcall.h>
  5. /*
  6. * Rather than reading /adm/users, which is a lot of work for
  7. * a toy program, we assume all groups have the form
  8. * NNN:user:user:
  9. * meaning that each user is the leader of his own group.
  10. */
  11. enum
  12. {
  13. OPERM = 0x3, /* mask of all permission types in open mode */
  14. Nram = 2048,
  15. Maxsize = 768*1024*1024,
  16. Maxfdata = 8192,
  17. };
  18. typedef struct Fid Fid;
  19. typedef struct Ram Ram;
  20. struct Fid
  21. {
  22. short busy;
  23. short open;
  24. short rclose;
  25. int fid;
  26. Fid *next;
  27. char *user;
  28. Ram *ram;
  29. };
  30. struct Ram
  31. {
  32. short busy;
  33. short open;
  34. long parent; /* index in Ram array */
  35. Qid qid;
  36. long perm;
  37. char *name;
  38. ulong atime;
  39. ulong mtime;
  40. char *user;
  41. char *group;
  42. char *muid;
  43. char *data;
  44. long ndata;
  45. };
  46. enum
  47. {
  48. Pexec = 1,
  49. Pwrite = 2,
  50. Pread = 4,
  51. Pother = 1,
  52. Pgroup = 8,
  53. Powner = 64,
  54. };
  55. ulong path; /* incremented for each new file */
  56. Fid *fids;
  57. Ram ram[Nram];
  58. int nram;
  59. int mfd[2];
  60. char *user;
  61. uchar mdata[IOHDRSZ+Maxfdata];
  62. uchar rdata[Maxfdata]; /* buffer for data in reply */
  63. uchar statbuf[STATMAX];
  64. Fcall thdr;
  65. Fcall rhdr;
  66. int messagesize = sizeof mdata;
  67. Fid * newfid(int);
  68. uint ramstat(Ram*, uchar*, uint);
  69. void error(char*);
  70. void io(void);
  71. void *erealloc(void*, ulong);
  72. void *emalloc(ulong);
  73. char *estrdup(char*);
  74. void usage(void);
  75. int perm(Fid*, Ram*, int);
  76. char *rflush(Fid*), *rversion(Fid*), *rauth(Fid*),
  77. *rattach(Fid*), *rwalk(Fid*),
  78. *ropen(Fid*), *rcreate(Fid*),
  79. *rread(Fid*), *rwrite(Fid*), *rclunk(Fid*),
  80. *rremove(Fid*), *rstat(Fid*), *rwstat(Fid*);
  81. int needfid[] = {
  82. [Tversion] 0,
  83. [Tflush] 0,
  84. [Tauth] 0,
  85. [Tattach] 0,
  86. [Twalk] 1,
  87. [Topen] 1,
  88. [Tcreate] 1,
  89. [Tread] 1,
  90. [Twrite] 1,
  91. [Tclunk] 1,
  92. [Tremove] 1,
  93. [Tstat] 1,
  94. [Twstat] 1,
  95. };
  96. char *(*fcalls[])(Fid*) = {
  97. [Tversion] rversion,
  98. [Tflush] rflush,
  99. [Tauth] rauth,
  100. [Tattach] rattach,
  101. [Twalk] rwalk,
  102. [Topen] ropen,
  103. [Tcreate] rcreate,
  104. [Tread] rread,
  105. [Twrite] rwrite,
  106. [Tclunk] rclunk,
  107. [Tremove] rremove,
  108. [Tstat] rstat,
  109. [Twstat] rwstat,
  110. };
  111. char Eperm[] = "permission denied";
  112. char Enotdir[] = "not a directory";
  113. char Enoauth[] = "ramfs: authentication not required";
  114. char Enotexist[] = "file does not exist";
  115. char Einuse[] = "file in use";
  116. char Eexist[] = "file exists";
  117. char Eisdir[] = "file is a directory";
  118. char Enotowner[] = "not owner";
  119. char Eisopen[] = "file already open for I/O";
  120. char Excl[] = "exclusive use file already open";
  121. char Ename[] = "illegal name";
  122. char Eversion[] = "unknown 9P version";
  123. char Enotempty[] = "directory not empty";
  124. int debug;
  125. int private;
  126. static int memlim = 1;
  127. void
  128. notifyf(void *a, char *s)
  129. {
  130. USED(a);
  131. if(strncmp(s, "interrupt", 9) == 0)
  132. noted(NCONT);
  133. noted(NDFLT);
  134. }
  135. void
  136. main(int argc, char *argv[])
  137. {
  138. Ram *r;
  139. char *defmnt, *service;
  140. int p[2];
  141. int fd;
  142. int stdio = 0;
  143. service = "ramfs";
  144. defmnt = "/tmp";
  145. ARGBEGIN{
  146. case 'i':
  147. defmnt = 0;
  148. stdio = 1;
  149. mfd[0] = 0;
  150. mfd[1] = 1;
  151. break;
  152. case 'm':
  153. defmnt = EARGF(usage());
  154. break;
  155. case 'p':
  156. private++;
  157. break;
  158. case 's':
  159. defmnt = 0;
  160. break;
  161. case 'u':
  162. memlim = 0; /* unlimited memory consumption */
  163. break;
  164. case 'D':
  165. debug = 1;
  166. break;
  167. case 'S':
  168. defmnt = 0;
  169. service = EARGF(usage());
  170. break;
  171. default:
  172. usage();
  173. }ARGEND
  174. if(pipe(p) < 0)
  175. error("pipe failed");
  176. if(!stdio){
  177. mfd[0] = p[0];
  178. mfd[1] = p[0];
  179. if(defmnt == 0){
  180. char buf[64];
  181. snprint(buf, sizeof buf, "#s/%s", service);
  182. fd = create(buf, OWRITE|ORCLOSE, 0666);
  183. if(fd < 0)
  184. error("create failed");
  185. sprint(buf, "%d", p[1]);
  186. if(write(fd, buf, strlen(buf)) < 0)
  187. error("writing service file");
  188. }
  189. }
  190. user = getuser();
  191. notify(notifyf);
  192. nram = 1;
  193. r = &ram[0];
  194. r->busy = 1;
  195. r->data = 0;
  196. r->ndata = 0;
  197. r->perm = DMDIR | 0775;
  198. r->qid.type = QTDIR;
  199. r->qid.path = 0LL;
  200. r->qid.vers = 0;
  201. r->parent = 0;
  202. r->user = user;
  203. r->group = user;
  204. r->muid = user;
  205. r->atime = time(0);
  206. r->mtime = r->atime;
  207. r->name = estrdup(".");
  208. if(debug) {
  209. fmtinstall('F', fcallfmt);
  210. fmtinstall('M', dirmodefmt);
  211. }
  212. switch(rfork(RFFDG|RFPROC|RFNAMEG|RFNOTEG)){
  213. case -1:
  214. error("fork");
  215. case 0:
  216. close(p[1]);
  217. io();
  218. break;
  219. default:
  220. close(p[0]); /* don't deadlock if child fails */
  221. if(defmnt && mount(p[1], -1, defmnt, MREPL|MCREATE, "") < 0)
  222. error("mount failed");
  223. }
  224. exits(0);
  225. }
  226. char*
  227. rversion(Fid*)
  228. {
  229. Fid *f;
  230. for(f = fids; f; f = f->next)
  231. if(f->busy)
  232. rclunk(f);
  233. if(thdr.msize > sizeof mdata)
  234. rhdr.msize = sizeof mdata;
  235. else
  236. rhdr.msize = thdr.msize;
  237. messagesize = rhdr.msize;
  238. if(strncmp(thdr.version, "9P2000", 6) != 0)
  239. return Eversion;
  240. rhdr.version = "9P2000";
  241. return 0;
  242. }
  243. char*
  244. rauth(Fid*)
  245. {
  246. return "ramfs: no authentication required";
  247. }
  248. char*
  249. rflush(Fid *f)
  250. {
  251. USED(f);
  252. return 0;
  253. }
  254. char*
  255. rattach(Fid *f)
  256. {
  257. /* no authentication! */
  258. f->busy = 1;
  259. f->rclose = 0;
  260. f->ram = &ram[0];
  261. rhdr.qid = f->ram->qid;
  262. if(thdr.uname[0])
  263. f->user = estrdup(thdr.uname);
  264. else
  265. f->user = "none";
  266. if(strcmp(user, "none") == 0)
  267. user = f->user;
  268. return 0;
  269. }
  270. char*
  271. clone(Fid *f, Fid **nf)
  272. {
  273. if(f->open)
  274. return Eisopen;
  275. if(f->ram->busy == 0)
  276. return Enotexist;
  277. *nf = newfid(thdr.newfid);
  278. (*nf)->busy = 1;
  279. (*nf)->open = 0;
  280. (*nf)->rclose = 0;
  281. (*nf)->ram = f->ram;
  282. (*nf)->user = f->user; /* no ref count; the leakage is minor */
  283. return 0;
  284. }
  285. char*
  286. rwalk(Fid *f)
  287. {
  288. Ram *r, *fram;
  289. char *name;
  290. Ram *parent;
  291. Fid *nf;
  292. char *err;
  293. ulong t;
  294. int i;
  295. err = nil;
  296. nf = nil;
  297. rhdr.nwqid = 0;
  298. if(thdr.newfid != thdr.fid){
  299. err = clone(f, &nf);
  300. if(err)
  301. return err;
  302. f = nf; /* walk the new fid */
  303. }
  304. fram = f->ram;
  305. if(thdr.nwname > 0){
  306. t = time(0);
  307. for(i=0; i<thdr.nwname && i<MAXWELEM; i++){
  308. if((fram->qid.type & QTDIR) == 0){
  309. err = Enotdir;
  310. break;
  311. }
  312. if(fram->busy == 0){
  313. err = Enotexist;
  314. break;
  315. }
  316. fram->atime = t;
  317. name = thdr.wname[i];
  318. if(strcmp(name, ".") == 0){
  319. Found:
  320. rhdr.nwqid++;
  321. rhdr.wqid[i] = fram->qid;
  322. continue;
  323. }
  324. parent = &ram[fram->parent];
  325. if(!perm(f, parent, Pexec)){
  326. err = Eperm;
  327. break;
  328. }
  329. if(strcmp(name, "..") == 0){
  330. fram = parent;
  331. goto Found;
  332. }
  333. for(r=ram; r < &ram[nram]; r++)
  334. if(r->busy && r->parent==fram-ram && strcmp(name, r->name)==0){
  335. fram = r;
  336. goto Found;
  337. }
  338. break;
  339. }
  340. if(i==0 && err == nil)
  341. err = Enotexist;
  342. }
  343. if(nf != nil && (err!=nil || rhdr.nwqid<thdr.nwname)){
  344. /* clunk the new fid, which is the one we walked */
  345. f->busy = 0;
  346. f->ram = nil;
  347. }
  348. if(rhdr.nwqid > 0)
  349. err = nil; /* didn't get everything in 9P2000 right! */
  350. if(rhdr.nwqid == thdr.nwname) /* update the fid after a successful walk */
  351. f->ram = fram;
  352. return err;
  353. }
  354. char *
  355. ropen(Fid *f)
  356. {
  357. Ram *r;
  358. int mode, trunc;
  359. if(f->open)
  360. return Eisopen;
  361. r = f->ram;
  362. if(r->busy == 0)
  363. return Enotexist;
  364. if(r->perm & DMEXCL)
  365. if(r->open)
  366. return Excl;
  367. mode = thdr.mode;
  368. if(r->qid.type & QTDIR){
  369. if(mode != OREAD)
  370. return Eperm;
  371. rhdr.qid = r->qid;
  372. return 0;
  373. }
  374. if(mode & ORCLOSE){
  375. /* can't remove root; must be able to write parent */
  376. if(r->qid.path==0 || !perm(f, &ram[r->parent], Pwrite))
  377. return Eperm;
  378. f->rclose = 1;
  379. }
  380. trunc = mode & OTRUNC;
  381. mode &= OPERM;
  382. if(mode==OWRITE || mode==ORDWR || trunc)
  383. if(!perm(f, r, Pwrite))
  384. return Eperm;
  385. if(mode==OREAD || mode==ORDWR)
  386. if(!perm(f, r, Pread))
  387. return Eperm;
  388. if(mode==OEXEC)
  389. if(!perm(f, r, Pexec))
  390. return Eperm;
  391. if(trunc && (r->perm&DMAPPEND)==0){
  392. r->ndata = 0;
  393. if(r->data)
  394. free(r->data);
  395. r->data = 0;
  396. r->qid.vers++;
  397. }
  398. rhdr.qid = r->qid;
  399. rhdr.iounit = messagesize-IOHDRSZ;
  400. f->open = 1;
  401. r->open++;
  402. return 0;
  403. }
  404. char *
  405. rcreate(Fid *f)
  406. {
  407. Ram *r;
  408. char *name;
  409. long parent, prm;
  410. if(f->open)
  411. return Eisopen;
  412. if(f->ram->busy == 0)
  413. return Enotexist;
  414. parent = f->ram - ram;
  415. if((f->ram->qid.type&QTDIR) == 0)
  416. return Enotdir;
  417. /* must be able to write parent */
  418. if(!perm(f, f->ram, Pwrite))
  419. return Eperm;
  420. prm = thdr.perm;
  421. name = thdr.name;
  422. if(strcmp(name, ".")==0 || strcmp(name, "..")==0)
  423. return Ename;
  424. for(r=ram; r<&ram[nram]; r++)
  425. if(r->busy && parent==r->parent)
  426. if(strcmp((char*)name, r->name)==0)
  427. return Einuse;
  428. for(r=ram; r->busy; r++)
  429. if(r == &ram[Nram-1])
  430. return "no free ram resources";
  431. r->busy = 1;
  432. r->qid.path = ++path;
  433. r->qid.vers = 0;
  434. if(prm & DMDIR)
  435. r->qid.type |= QTDIR;
  436. r->parent = parent;
  437. free(r->name);
  438. r->name = estrdup(name);
  439. r->user = f->user;
  440. r->group = f->ram->group;
  441. r->muid = f->ram->muid;
  442. if(prm & DMDIR)
  443. prm = (prm&~0777) | (f->ram->perm&prm&0777);
  444. else
  445. prm = (prm&(~0777|0111)) | (f->ram->perm&prm&0666);
  446. r->perm = prm;
  447. r->ndata = 0;
  448. if(r-ram >= nram)
  449. nram = r - ram + 1;
  450. r->atime = time(0);
  451. r->mtime = r->atime;
  452. f->ram->mtime = r->atime;
  453. f->ram = r;
  454. rhdr.qid = r->qid;
  455. rhdr.iounit = messagesize-IOHDRSZ;
  456. f->open = 1;
  457. if(thdr.mode & ORCLOSE)
  458. f->rclose = 1;
  459. r->open++;
  460. return 0;
  461. }
  462. char*
  463. rread(Fid *f)
  464. {
  465. Ram *r;
  466. uchar *buf;
  467. long off;
  468. int n, m, cnt;
  469. if(f->ram->busy == 0)
  470. return Enotexist;
  471. n = 0;
  472. rhdr.count = 0;
  473. off = thdr.offset;
  474. buf = rdata;
  475. cnt = thdr.count;
  476. if(cnt > messagesize) /* shouldn't happen, anyway */
  477. cnt = messagesize;
  478. if(f->ram->qid.type & QTDIR){
  479. for(r=ram+1; off > 0; r++){
  480. if(r->busy && r->parent==f->ram-ram)
  481. off -= ramstat(r, statbuf, sizeof statbuf);
  482. if(r == &ram[nram-1])
  483. return 0;
  484. }
  485. for(; r<&ram[nram] && n < cnt; r++){
  486. if(!r->busy || r->parent!=f->ram-ram)
  487. continue;
  488. m = ramstat(r, buf+n, cnt-n);
  489. if(m == 0)
  490. break;
  491. n += m;
  492. }
  493. rhdr.data = (char*)rdata;
  494. rhdr.count = n;
  495. return 0;
  496. }
  497. r = f->ram;
  498. if(off >= r->ndata)
  499. return 0;
  500. r->atime = time(0);
  501. n = cnt;
  502. if(off+n > r->ndata)
  503. n = r->ndata - off;
  504. rhdr.data = r->data+off;
  505. rhdr.count = n;
  506. return 0;
  507. }
  508. char*
  509. rwrite(Fid *f)
  510. {
  511. Ram *r;
  512. ulong off;
  513. int cnt;
  514. r = f->ram;
  515. if(r->busy == 0)
  516. return Enotexist;
  517. off = thdr.offset;
  518. if(r->perm & DMAPPEND)
  519. off = r->ndata;
  520. cnt = thdr.count;
  521. if(r->qid.type & QTDIR)
  522. return Eisdir;
  523. if(memlim && off+cnt >= Maxsize) /* sanity check */
  524. return "write too big";
  525. if(off+cnt > r->ndata)
  526. r->data = erealloc(r->data, off+cnt);
  527. if(off > r->ndata)
  528. memset(r->data+r->ndata, 0, off-r->ndata);
  529. if(off+cnt > r->ndata)
  530. r->ndata = off+cnt;
  531. memmove(r->data+off, thdr.data, cnt);
  532. r->qid.vers++;
  533. r->mtime = time(0);
  534. rhdr.count = cnt;
  535. return 0;
  536. }
  537. static int
  538. emptydir(Ram *dr)
  539. {
  540. long didx = dr - ram;
  541. Ram *r;
  542. for(r=ram; r<&ram[nram]; r++)
  543. if(r->busy && didx==r->parent)
  544. return 0;
  545. return 1;
  546. }
  547. char *
  548. realremove(Ram *r)
  549. {
  550. if(r->qid.type & QTDIR && !emptydir(r))
  551. return Enotempty;
  552. r->ndata = 0;
  553. if(r->data)
  554. free(r->data);
  555. r->data = 0;
  556. r->parent = 0;
  557. memset(&r->qid, 0, sizeof r->qid);
  558. free(r->name);
  559. r->name = nil;
  560. r->busy = 0;
  561. return nil;
  562. }
  563. char *
  564. rclunk(Fid *f)
  565. {
  566. char *e = nil;
  567. if(f->open)
  568. f->ram->open--;
  569. if(f->rclose)
  570. e = realremove(f->ram);
  571. f->busy = 0;
  572. f->open = 0;
  573. f->ram = 0;
  574. return e;
  575. }
  576. char *
  577. rremove(Fid *f)
  578. {
  579. Ram *r;
  580. if(f->open)
  581. f->ram->open--;
  582. f->busy = 0;
  583. f->open = 0;
  584. r = f->ram;
  585. f->ram = 0;
  586. if(r->qid.path == 0 || !perm(f, &ram[r->parent], Pwrite))
  587. return Eperm;
  588. ram[r->parent].mtime = time(0);
  589. return realremove(r);
  590. }
  591. char *
  592. rstat(Fid *f)
  593. {
  594. if(f->ram->busy == 0)
  595. return Enotexist;
  596. rhdr.nstat = ramstat(f->ram, statbuf, sizeof statbuf);
  597. rhdr.stat = statbuf;
  598. return 0;
  599. }
  600. char *
  601. rwstat(Fid *f)
  602. {
  603. Ram *r, *s;
  604. Dir dir;
  605. if(f->ram->busy == 0)
  606. return Enotexist;
  607. convM2D(thdr.stat, thdr.nstat, &dir, (char*)statbuf);
  608. r = f->ram;
  609. /*
  610. * To change length, must have write permission on file.
  611. */
  612. if(dir.length!=~0 && dir.length!=r->ndata){
  613. if(!perm(f, r, Pwrite))
  614. return Eperm;
  615. }
  616. /*
  617. * To change name, must have write permission in parent
  618. * and name must be unique.
  619. */
  620. if(dir.name[0]!='\0' && strcmp(dir.name, r->name)!=0){
  621. if(!perm(f, &ram[r->parent], Pwrite))
  622. return Eperm;
  623. for(s=ram; s<&ram[nram]; s++)
  624. if(s->busy && s->parent==r->parent)
  625. if(strcmp(dir.name, s->name)==0)
  626. return Eexist;
  627. }
  628. /*
  629. * To change mode, must be owner or group leader.
  630. * Because of lack of users file, leader=>group itself.
  631. */
  632. if(dir.mode!=~0 && r->perm!=dir.mode){
  633. if(strcmp(f->user, r->user) != 0)
  634. if(strcmp(f->user, r->group) != 0)
  635. return Enotowner;
  636. }
  637. /*
  638. * To change group, must be owner and member of new group,
  639. * or leader of current group and leader of new group.
  640. * Second case cannot happen, but we check anyway.
  641. */
  642. if(dir.gid[0]!='\0' && strcmp(r->group, dir.gid)!=0){
  643. if(strcmp(f->user, r->user) == 0)
  644. // if(strcmp(f->user, dir.gid) == 0)
  645. goto ok;
  646. if(strcmp(f->user, r->group) == 0)
  647. if(strcmp(f->user, dir.gid) == 0)
  648. goto ok;
  649. return Enotowner;
  650. ok:;
  651. }
  652. /* all ok; do it */
  653. if(dir.mode != ~0){
  654. dir.mode &= ~DMDIR; /* cannot change dir bit */
  655. dir.mode |= r->perm&DMDIR;
  656. r->perm = dir.mode;
  657. }
  658. if(dir.name[0] != '\0'){
  659. free(r->name);
  660. r->name = estrdup(dir.name);
  661. }
  662. if(dir.gid[0] != '\0')
  663. r->group = estrdup(dir.gid);
  664. if(dir.length!=~0 && dir.length!=r->ndata){
  665. r->data = erealloc(r->data, dir.length);
  666. if(r->ndata < dir.length)
  667. memset(r->data+r->ndata, 0, dir.length-r->ndata);
  668. r->ndata = dir.length;
  669. }
  670. ram[r->parent].mtime = time(0);
  671. return 0;
  672. }
  673. uint
  674. ramstat(Ram *r, uchar *buf, uint nbuf)
  675. {
  676. int n;
  677. Dir dir;
  678. dir.name = r->name;
  679. dir.qid = r->qid;
  680. dir.mode = r->perm;
  681. dir.length = r->ndata;
  682. dir.uid = r->user;
  683. dir.gid = r->group;
  684. dir.muid = r->muid;
  685. dir.atime = r->atime;
  686. dir.mtime = r->mtime;
  687. n = convD2M(&dir, buf, nbuf);
  688. if(n > 2)
  689. return n;
  690. return 0;
  691. }
  692. Fid *
  693. newfid(int fid)
  694. {
  695. Fid *f, *ff;
  696. ff = 0;
  697. for(f = fids; f; f = f->next)
  698. if(f->fid == fid)
  699. return f;
  700. else if(!ff && !f->busy)
  701. ff = f;
  702. if(ff){
  703. ff->fid = fid;
  704. return ff;
  705. }
  706. f = emalloc(sizeof *f);
  707. f->ram = nil;
  708. f->fid = fid;
  709. f->next = fids;
  710. fids = f;
  711. return f;
  712. }
  713. void
  714. io(void)
  715. {
  716. char *err, buf[40];
  717. int n, pid, ctl;
  718. Fid *fid;
  719. pid = getpid();
  720. if(private){
  721. snprint(buf, sizeof buf, "/proc/%d/ctl", pid);
  722. ctl = open(buf, OWRITE);
  723. if(ctl < 0){
  724. fprint(2, "can't protect ramfs\n");
  725. }else{
  726. fprint(ctl, "noswap\n");
  727. fprint(ctl, "private\n");
  728. close(ctl);
  729. }
  730. }
  731. for(;;){
  732. /*
  733. * reading from a pipe or a network device
  734. * will give an error after a few eof reads.
  735. * however, we cannot tell the difference
  736. * between a zero-length read and an interrupt
  737. * on the processes writing to us,
  738. * so we wait for the error.
  739. */
  740. n = read9pmsg(mfd[0], mdata, messagesize);
  741. if(n < 0){
  742. rerrstr(buf, sizeof buf);
  743. if(buf[0]=='\0' || strstr(buf, "hungup"))
  744. exits("");
  745. error("mount read");
  746. }
  747. if(n == 0)
  748. continue;
  749. if(convM2S(mdata, n, &thdr) == 0)
  750. continue;
  751. if(debug)
  752. fprint(2, "ramfs %d:<-%F\n", pid, &thdr);
  753. if(thdr.type<0 || thdr.type>=nelem(fcalls) || !fcalls[thdr.type])
  754. err = "bad fcall type";
  755. else if(((fid=newfid(thdr.fid))==nil || !fid->ram) && needfid[thdr.type])
  756. err = "fid not in use";
  757. else
  758. err = (*fcalls[thdr.type])(fid);
  759. if(err){
  760. rhdr.type = Rerror;
  761. rhdr.ename = err;
  762. }else{
  763. rhdr.type = thdr.type + 1;
  764. rhdr.fid = thdr.fid;
  765. }
  766. rhdr.tag = thdr.tag;
  767. if(debug)
  768. fprint(2, "ramfs %d:->%F\n", pid, &rhdr);/**/
  769. n = convS2M(&rhdr, mdata, messagesize);
  770. if(n == 0)
  771. error("convS2M error on write");
  772. if(write(mfd[1], mdata, n) != n)
  773. error("mount write");
  774. }
  775. }
  776. int
  777. perm(Fid *f, Ram *r, int p)
  778. {
  779. if((p*Pother) & r->perm)
  780. return 1;
  781. if(strcmp(f->user, r->group)==0 && ((p*Pgroup) & r->perm))
  782. return 1;
  783. if(strcmp(f->user, r->user)==0 && ((p*Powner) & r->perm))
  784. return 1;
  785. return 0;
  786. }
  787. void
  788. error(char *s)
  789. {
  790. fprint(2, "%s: %s: %r\n", argv0, s);
  791. exits(s);
  792. }
  793. void *
  794. emalloc(ulong n)
  795. {
  796. void *p;
  797. p = malloc(n);
  798. if(!p)
  799. error("out of memory");
  800. memset(p, 0, n);
  801. return p;
  802. }
  803. void *
  804. erealloc(void *p, ulong n)
  805. {
  806. p = realloc(p, n);
  807. if(!p)
  808. error("out of memory");
  809. return p;
  810. }
  811. char *
  812. estrdup(char *q)
  813. {
  814. char *p;
  815. int n;
  816. n = strlen(q)+1;
  817. p = malloc(n);
  818. if(!p)
  819. error("out of memory");
  820. memmove(p, q, n);
  821. return p;
  822. }
  823. void
  824. usage(void)
  825. {
  826. fprint(2, "usage: %s [-Dipsu] [-m mountpoint] [-S srvname]\n", argv0);
  827. exits("usage");
  828. }