consolefs.c 20 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217
  1. #include <u.h>
  2. #include <libc.h>
  3. #include <auth.h>
  4. #include <fcall.h>
  5. #include <bio.h>
  6. #include <ndb.h>
  7. #include <thread.h>
  8. /*
  9. * This fs presents a 1 level file system. It contains
  10. * three files per console (xxx and xxxctl and xxxstat)
  11. */
  12. typedef struct Console Console;
  13. typedef struct Fid Fid;
  14. typedef struct Request Request;
  15. typedef struct Reqlist Reqlist;
  16. typedef struct Fs Fs;
  17. enum
  18. {
  19. /* last 5 bits of qid.path */
  20. Textern= 0, /* fake parent of top level */
  21. Ttopdir, /* top level directory */
  22. Qctl,
  23. Qstat,
  24. Qdata,
  25. Bufsize= 32*1024, /* chars buffered per reader */
  26. Maxcons= 64, /* maximum consoles */
  27. Nhash= 64, /* Fid hash buckets */
  28. };
  29. #define TYPE(x) (((ulong)x.path) & 0xf)
  30. #define CONS(x) ((((ulong)x.path) >> 4)&0xfff)
  31. #define QID(c, x) (((c)<<4) | (x))
  32. struct Request
  33. {
  34. Request *next;
  35. Fid *fid;
  36. Fs *fs;
  37. Fcall f;
  38. uchar buf[1];
  39. };
  40. struct Reqlist
  41. {
  42. Lock;
  43. Request *first;
  44. Request *last;
  45. };
  46. struct Fid
  47. {
  48. Lock;
  49. Fid *next; /* hash list */
  50. Fid *cnext; /* list of Fid's on a console */
  51. int fid;
  52. int ref;
  53. int attached;
  54. int open;
  55. char *user;
  56. Qid qid;
  57. Console *c;
  58. char buf[Bufsize];
  59. char *rp;
  60. char *wp;
  61. Reqlist r; /* active read requests */
  62. };
  63. struct Console
  64. {
  65. Lock;
  66. char *name;
  67. char *dev;
  68. int speed;
  69. int cronly;
  70. int ondemand; /* open only on demand */
  71. int pid; /* pid of reader */
  72. int fd;
  73. int cfd;
  74. int sfd;
  75. Fid *flist; /* open fids to broadcast to */
  76. };
  77. struct Fs
  78. {
  79. Lock;
  80. int fd; /* to kernel mount point */
  81. int messagesize;
  82. Fid *hash[Nhash];
  83. Console *cons[Maxcons];
  84. int ncons;
  85. };
  86. extern void console(Fs*, char*, char*, int, int, int);
  87. extern Fs* fsmount(char*);
  88. extern void fsreader(void*);
  89. extern void fsrun(void*);
  90. extern Fid* fsgetfid(Fs*, int);
  91. extern void fsputfid(Fs*, Fid*);
  92. extern int fsdirgen(Fs*, Qid, int, Dir*, uchar*, int);
  93. extern void fsreply(Fs*, Request*, char*);
  94. extern void fskick(Fs*, Fid*);
  95. extern int fsreopen(Fs*, Console*);
  96. extern void fsversion(Fs*, Request*, Fid*);
  97. extern void fsflush(Fs*, Request*, Fid*);
  98. extern void fsauth(Fs*, Request*, Fid*);
  99. extern void fsattach(Fs*, Request*, Fid*);
  100. extern void fswalk(Fs*, Request*, Fid*);
  101. extern void fsclwalk(Fs*, Request*, Fid*);
  102. extern void fsopen(Fs*, Request*, Fid*);
  103. extern void fscreate(Fs*, Request*, Fid*);
  104. extern void fsread(Fs*, Request*, Fid*);
  105. extern void fswrite(Fs*, Request*, Fid*);
  106. extern void fsclunk(Fs*, Request*, Fid*);
  107. extern void fsremove(Fs*, Request*, Fid*);
  108. extern void fsstat(Fs*, Request*, Fid*);
  109. extern void fswstat(Fs*, Request*, Fid*);
  110. void (*fcall[])(Fs*, Request*, Fid*) =
  111. {
  112. [Tflush] fsflush,
  113. [Tversion] fsversion,
  114. [Tauth] fsauth,
  115. [Tattach] fsattach,
  116. [Twalk] fswalk,
  117. [Topen] fsopen,
  118. [Tcreate] fscreate,
  119. [Tread] fsread,
  120. [Twrite] fswrite,
  121. [Tclunk] fsclunk,
  122. [Tremove] fsremove,
  123. [Tstat] fsstat,
  124. [Twstat] fswstat
  125. };
  126. char Eperm[] = "permission denied";
  127. char Eexist[] = "file does not exist";
  128. char Enotdir[] = "not a directory";
  129. char Eisopen[] = "file already open";
  130. char Ebadcount[] = "bad read/write count";
  131. char Enofid[] = "no such fid";
  132. char *consoledb = "/lib/ndb/consoledb";
  133. char *mntpt = "/mnt/consoles";
  134. int messagesize = 8192+IOHDRSZ;
  135. void
  136. fatal(char *fmt, ...)
  137. {
  138. va_list arg;
  139. char buf[1024];
  140. write(2, "consolefs: ", 10);
  141. va_start(arg, fmt);
  142. vseprint(buf, buf+1024, fmt, arg);
  143. va_end(arg);
  144. write(2, buf, strlen(buf));
  145. write(2, "\n", 1);
  146. threadexitsall(fmt);
  147. }
  148. void*
  149. emalloc(uint n)
  150. {
  151. void *p;
  152. p = malloc(n);
  153. if(p == nil)
  154. fatal("malloc failed: %r");
  155. memset(p, 0, n);
  156. return p;
  157. }
  158. int debug;
  159. Ndb *db;
  160. /*
  161. * any request that can get queued for a delayed reply
  162. */
  163. Request*
  164. allocreq(Fs *fs, int bufsize)
  165. {
  166. Request *r;
  167. r = emalloc(sizeof(Request)+bufsize);
  168. r->fs = fs;
  169. r->next = nil;
  170. return r;
  171. }
  172. /*
  173. * for maintaining lists of requests
  174. */
  175. void
  176. addreq(Reqlist *l, Request *r)
  177. {
  178. lock(l);
  179. if(l->first == nil)
  180. l->first = r;
  181. else
  182. l->last->next = r;
  183. l->last = r;
  184. r->next = nil;
  185. unlock(l);
  186. }
  187. /*
  188. * remove the first request from a list of requests
  189. */
  190. Request*
  191. remreq(Reqlist *l)
  192. {
  193. Request *r;
  194. lock(l);
  195. r = l->first;
  196. if(r != nil)
  197. l->first = r->next;
  198. unlock(l);
  199. return r;
  200. }
  201. /*
  202. * remove a request with the given tag from a list of requests
  203. */
  204. Request*
  205. remtag(Reqlist *l, int tag)
  206. {
  207. Request *or, **ll;
  208. lock(l);
  209. ll = &l->first;
  210. for(or = *ll; or; or = or->next){
  211. if(or->f.tag == tag){
  212. *ll = or->next;
  213. unlock(l);
  214. return or;
  215. }
  216. ll = &or->next;
  217. }
  218. unlock(l);
  219. return nil;
  220. }
  221. Qid
  222. parentqid(Qid q)
  223. {
  224. if(q.type & QTDIR)
  225. return (Qid){QID(0, Textern), 0, QTDIR};
  226. else
  227. return (Qid){QID(0, Ttopdir), 0, QTDIR};
  228. }
  229. int
  230. fsdirgen(Fs *fs, Qid parent, int i, Dir *d, uchar *buf, int nbuf)
  231. {
  232. static char name[64];
  233. char *p;
  234. int xcons;
  235. d->uid = d->gid = d->muid = "network";
  236. d->length = 0;
  237. d->atime = time(nil);
  238. d->mtime = d->atime;
  239. d->type = 'C';
  240. d->dev = '0';
  241. switch(TYPE(parent)){
  242. case Textern:
  243. if(i != 0)
  244. return -1;
  245. p = "consoles";
  246. d->mode = DMDIR|0555;
  247. d->qid.type = QTDIR;
  248. d->qid.path = QID(0, Ttopdir);
  249. d->qid.vers = 0;
  250. break;
  251. case Ttopdir:
  252. xcons = i/3;
  253. if(xcons >= fs->ncons)
  254. return -1;
  255. p = fs->cons[xcons]->name;
  256. switch(i%3){
  257. case 0:
  258. snprint(name, sizeof name, "%sctl", p);
  259. p = name;
  260. d->qid.type = QTFILE;
  261. d->qid.path = QID(xcons, Qctl);
  262. d->qid.vers = 0;
  263. break;
  264. case 1:
  265. snprint(name, sizeof name, "%sstat", p);
  266. p = name;
  267. d->qid.type = QTFILE;
  268. d->qid.path = QID(xcons, Qstat);
  269. d->qid.vers = 0;
  270. break;
  271. case 2:
  272. d->qid.type = QTFILE;
  273. d->qid.path = QID(xcons, Qdata);
  274. d->qid.vers = 0;
  275. break;
  276. }
  277. d->mode = 0666;
  278. break;
  279. default:
  280. return -1;
  281. }
  282. d->name = p;
  283. if(buf != nil)
  284. return convD2M(d, buf, nbuf);
  285. return 0;
  286. }
  287. /*
  288. * mount the user interface and start a request processor
  289. */
  290. Fs*
  291. fsmount(char *mntpt)
  292. {
  293. Fs *fs;
  294. int pfd[2], srv;
  295. char buf[32];
  296. int n;
  297. static void *v[2];
  298. fs = emalloc(sizeof(Fs));
  299. if(pipe(pfd) < 0)
  300. fatal("opening pipe: %r");
  301. /* start up the file system process */
  302. v[0] = fs;
  303. v[1] = pfd;
  304. proccreate(fsrun, v, 16*1024);
  305. /* Typically mounted before /srv exists */
  306. if(access("#s/consoles", AEXIST) < 0){
  307. srv = create("#s/consoles", OWRITE, 0666);
  308. if(srv < 0)
  309. fatal("post: %r");
  310. n = sprint(buf, "%d", pfd[1]);
  311. if(write(srv, buf, n) < 0)
  312. fatal("write srv: %r");
  313. close(srv);
  314. }
  315. mount(pfd[1], -1, mntpt, MBEFORE, "");
  316. close(pfd[1]);
  317. return fs;
  318. }
  319. /*
  320. * reopen a console
  321. */
  322. int
  323. fsreopen(Fs* fs, Console *c)
  324. {
  325. char buf[128];
  326. static void *v[2];
  327. if(c->pid){
  328. if(postnote(PNPROC, c->pid, "reopen") != 0)
  329. fprint(2, "postnote failed: %r\n");
  330. c->pid = 0;
  331. }
  332. if(c->fd >= 0){
  333. close(c->fd);
  334. close(c->cfd);
  335. close(c->sfd);
  336. c->cfd = -1;
  337. c->fd = -1;
  338. c->sfd = -1;
  339. }
  340. if(c->flist == nil && c->ondemand)
  341. return 0;
  342. c->fd = open(c->dev, ORDWR);
  343. if(c->fd < 0)
  344. return -1;
  345. snprint(buf, sizeof(buf), "%sctl", c->dev);
  346. c->cfd = open(buf, ORDWR);
  347. fprint(c->cfd, "b%d", c->speed);
  348. snprint(buf, sizeof(buf), "%sstat", c->dev);
  349. c->sfd = open(buf, OREAD);
  350. v[0] = fs;
  351. v[1] = c;
  352. proccreate(fsreader, v, 16*1024);
  353. return 0;
  354. }
  355. void
  356. change(Fs *fs, Console *c, int doreopen, int speed, int cronly, int ondemand)
  357. {
  358. lock(c);
  359. if(speed != c->speed){
  360. c->speed = speed;
  361. doreopen = 1;
  362. }
  363. if(ondemand != c->ondemand){
  364. c->ondemand = ondemand;
  365. doreopen = 1;
  366. }
  367. c->cronly = cronly;
  368. if(doreopen)
  369. fsreopen(fs, c);
  370. unlock(c);
  371. }
  372. /*
  373. * create a console interface
  374. */
  375. void
  376. console(Fs* fs, char *name, char *dev, int speed, int cronly, int ondemand)
  377. {
  378. Console *c;
  379. char *x;
  380. int i, doreopen;
  381. if(fs->ncons >= Maxcons)
  382. fatal("too many consoles, too little time");
  383. doreopen = 0;
  384. for(i = 0; i < fs->ncons; i++){
  385. c = fs->cons[i];
  386. if(strcmp(name, c->name) == 0){
  387. if(strcmp(dev, c->dev) != 0){
  388. /* new device */
  389. x = c->dev;
  390. c->dev = strdup(dev);
  391. free(x);
  392. doreopen = 1;
  393. }
  394. change(fs, c, doreopen, speed, cronly, ondemand);
  395. return;
  396. }
  397. }
  398. for(i = 0; i < fs->ncons; i++){
  399. c = fs->cons[i];
  400. if(strcmp(dev, c->dev) == 0){
  401. /* at least a rename */
  402. x = c->name;
  403. c->name = strdup(name);
  404. free(x);
  405. change(fs, c, doreopen, speed, cronly, ondemand);
  406. return;
  407. }
  408. }
  409. c = emalloc(sizeof(Console));
  410. fs->cons[fs->ncons++] = c;
  411. c->name = strdup(name);
  412. c->dev = strdup(dev);
  413. c->fd = -1;
  414. c->cfd = -1;
  415. c->sfd = -1;
  416. change(fs, c, 1, speed, cronly, ondemand);
  417. }
  418. /*
  419. * buffer data from console to a client.
  420. * circular q with writer able to catch up to reader.
  421. * the reader may miss data but always sees an in order sequence.
  422. */
  423. void
  424. fromconsole(Fid *f, char *p, int n)
  425. {
  426. char *rp, *wp, *ep;
  427. int pass;
  428. lock(f);
  429. rp = f->rp;
  430. wp = f->wp;
  431. ep = f->buf + sizeof(f->buf);
  432. pass = 0;
  433. while(n--){
  434. *wp++ = *p++;
  435. if(wp >= ep)
  436. wp = f->buf;
  437. if(rp == wp)
  438. pass = 1;
  439. }
  440. f->wp = wp;
  441. /* we overtook the read pointer, push it up so readers always
  442. * see the tail of what was written
  443. */
  444. if(pass){
  445. wp++;
  446. if(wp >= ep)
  447. f->rp = f->buf;
  448. else
  449. f->rp = wp;
  450. }
  451. unlock(f);
  452. }
  453. /*
  454. * broadcast a list of members to all listeners
  455. */
  456. void
  457. bcastmembers(Fs *fs, Console *c, char *msg, Fid *f)
  458. {
  459. int n;
  460. Fid *fl;
  461. char buf[512];
  462. sprint(buf, "[%s%s", msg, f->user);
  463. for(fl = c->flist; fl != nil && strlen(buf) + 64 < sizeof(buf); fl = fl->cnext){
  464. if(f == fl)
  465. continue;
  466. strcat(buf, ", ");
  467. strcat(buf, fl->user);
  468. }
  469. strcat(buf, "]\n");
  470. n = strlen(buf);
  471. for(fl = c->flist; fl; fl = fl->cnext){
  472. fromconsole(fl, buf, n);
  473. fskick(fs, fl);
  474. }
  475. }
  476. void
  477. handler(void*, char *msg)
  478. {
  479. if(strstr(msg, "reopen"))
  480. noted(NCONT);
  481. noted(NDFLT);
  482. }
  483. /*
  484. * a process to read console output and broadcast it (one per console)
  485. */
  486. void
  487. fsreader(void *v)
  488. {
  489. int n;
  490. Fid *fl;
  491. char buf[1024];
  492. Fs *fs;
  493. Console *c;
  494. void **a;
  495. a = v;
  496. fs = a[0];
  497. c = a[1];
  498. c->pid = getpid();
  499. notify(handler);
  500. for(;;){
  501. n = read(c->fd, buf, sizeof(buf));
  502. if(n < 0)
  503. break;
  504. lock(c);
  505. for(fl = c->flist; fl; fl = fl->cnext){
  506. fromconsole(fl, buf, n);
  507. fskick(fs, fl);
  508. }
  509. unlock(c);
  510. }
  511. }
  512. void
  513. readdb(Fs *fs)
  514. {
  515. Ndbtuple *t, *nt;
  516. char *dev, *cons;
  517. int cronly, speed, ondemand;
  518. ndbreopen(db);
  519. /* start a listener for each console */
  520. for(;;){
  521. t = ndbparse(db);
  522. if(t == nil)
  523. break;
  524. dev = nil;
  525. cons = nil;
  526. speed = 9600;
  527. cronly = 0;
  528. ondemand = 0;
  529. for(nt = t; nt; nt = nt->entry){
  530. if(strcmp(nt->attr, "console") == 0)
  531. cons = nt->val;
  532. else if(strcmp(nt->attr, "dev") == 0)
  533. dev = nt->val;
  534. else if(strcmp(nt->attr, "speed") == 0)
  535. speed = atoi(nt->val);
  536. else if(strcmp(nt->attr, "cronly") == 0)
  537. cronly = 1;
  538. else if(strcmp(nt->attr, "openondemand") == 0)
  539. ondemand = 1;
  540. }
  541. if(dev != nil && cons != nil)
  542. console(fs, cons, dev, speed, cronly, ondemand);
  543. ndbfree(t);
  544. }
  545. }
  546. int dbmtime;
  547. /*
  548. * a request processor (one per Fs)
  549. */
  550. void
  551. fsrun(void *v)
  552. {
  553. int n, t;
  554. Request *r;
  555. Fid *f;
  556. Dir *d;
  557. void **a = v;
  558. Fs* fs;
  559. int *pfd;
  560. fs = a[0];
  561. pfd = a[1];
  562. fs->fd = pfd[0];
  563. for(;;){
  564. d = dirstat(consoledb);
  565. if(d != nil && d->mtime != dbmtime){
  566. dbmtime = d->mtime;
  567. readdb(fs);
  568. }
  569. free(d);
  570. r = allocreq(fs, messagesize);
  571. n = read9pmsg(fs->fd, r->buf, messagesize);
  572. if(n <= 0)
  573. fatal("unmounted");
  574. if(convM2S(r->buf, n, &r->f) == 0){
  575. fprint(2, "can't convert %ux %ux %ux\n", r->buf[0],
  576. r->buf[1], r->buf[2]);
  577. free(r);
  578. continue;
  579. }
  580. f = fsgetfid(fs, r->f.fid);
  581. r->fid = f;
  582. if(debug)
  583. fprint(2, "%F path %llux\n", &r->f, f->qid.path);
  584. t = r->f.type;
  585. r->f.type++;
  586. (*fcall[t])(fs, r, f);
  587. }
  588. }
  589. Fid*
  590. fsgetfid(Fs *fs, int fid)
  591. {
  592. Fid *f, *nf;
  593. lock(fs);
  594. for(f = fs->hash[fid%Nhash]; f; f = f->next){
  595. if(f->fid == fid){
  596. f->ref++;
  597. unlock(fs);
  598. return f;
  599. }
  600. }
  601. nf = emalloc(sizeof(Fid));
  602. nf->next = fs->hash[fid%Nhash];
  603. fs->hash[fid%Nhash] = nf;
  604. nf->fid = fid;
  605. nf->ref = 1;
  606. nf->wp = nf->buf;
  607. nf->rp = nf->wp;
  608. unlock(fs);
  609. return nf;
  610. }
  611. void
  612. fsputfid(Fs *fs, Fid *f)
  613. {
  614. Fid **l, *nf;
  615. lock(fs);
  616. if(--f->ref > 0){
  617. unlock(fs);
  618. return;
  619. }
  620. for(l = &fs->hash[f->fid%Nhash]; nf = *l; l = &nf->next)
  621. if(nf == f){
  622. *l = f->next;
  623. break;
  624. }
  625. unlock(fs);
  626. free(f->user);
  627. free(f);
  628. }
  629. void
  630. fsauth(Fs *fs, Request *r, Fid*)
  631. {
  632. fsreply(fs, r, "consolefs: authentication not required");
  633. }
  634. void
  635. fsversion(Fs *fs, Request *r, Fid*)
  636. {
  637. if(r->f.msize < 256){
  638. fsreply(fs, r, "message size too small");
  639. return;
  640. }
  641. messagesize = r->f.msize;
  642. if(messagesize > 8192+IOHDRSZ)
  643. messagesize = 8192+IOHDRSZ;
  644. r->f.msize = messagesize;
  645. if(strncmp(r->f.version, "9P2000", 6) != 0){
  646. fsreply(fs, r, "unrecognized 9P version");
  647. return;
  648. }
  649. r->f.version = "9P2000";
  650. fsreply(fs, r, nil);
  651. }
  652. void
  653. fsflush(Fs *fs, Request *r, Fid *f)
  654. {
  655. Request *or;
  656. or = remtag(&f->r, r->f.oldtag);
  657. if(or != nil){
  658. fsputfid(fs, or->fid);
  659. free(or);
  660. }
  661. fsreply(fs, r, nil);
  662. }
  663. void
  664. fsattach(Fs *fs, Request *r, Fid *f)
  665. {
  666. f->qid.type = QTDIR;
  667. f->qid.path = QID(0, Ttopdir);
  668. f->qid.vers = 0;
  669. if(r->f.uname[0])
  670. f->user = strdup(r->f.uname);
  671. else
  672. f->user = strdup("none");
  673. /* hold down the fid till the clunk */
  674. f->attached = 1;
  675. lock(fs);
  676. f->ref++;
  677. unlock(fs);
  678. r->f.qid = f->qid;
  679. fsreply(fs, r, nil);
  680. }
  681. void
  682. fswalk(Fs *fs, Request *r, Fid *f)
  683. {
  684. char *name;
  685. Dir d;
  686. int i, nqid, nwname;
  687. Qid qid, wqid[MAXWELEM];
  688. Fid *nf;
  689. char *err;
  690. if(f->attached == 0){
  691. fsreply(fs, r, Enofid);
  692. return;
  693. }
  694. nf = nil;
  695. if(r->f.fid != r->f.newfid){
  696. nf = fsgetfid(fs, r->f.newfid);
  697. nf->attached = f->attached;
  698. nf->open = f->open;
  699. nf->qid = f->qid;
  700. nf->user = strdup(f->user);
  701. nf->c = f->c;
  702. nf->wp = nf->buf;
  703. nf->rp = nf->wp;
  704. f = nf;
  705. }
  706. qid = f->qid;
  707. err = nil;
  708. nwname = r->f.nwname;
  709. nqid = 0;
  710. if(nwname > 0){
  711. for(; err == nil && nqid < nwname; nqid++){
  712. if(nqid >= MAXWELEM){
  713. err = "too many name elements";
  714. break;
  715. }
  716. name = r->f.wname[nqid];
  717. if(strcmp(name, "..") == 0)
  718. qid = parentqid(qid);
  719. else if(strcmp(name, ".") != 0){
  720. for(i = 0; ; i++){
  721. if(fsdirgen(fs, qid, i, &d, nil, 0) < 0){
  722. err = Eexist;
  723. break;
  724. }
  725. if(strcmp(name, d.name) == 0){
  726. qid = d.qid;
  727. break;
  728. }
  729. }
  730. }
  731. wqid[nqid] = qid;
  732. }
  733. if(nf != nil && nqid < nwname)
  734. fsputfid(fs, nf);
  735. if(nqid == nwname)
  736. f->qid = qid;
  737. }
  738. memmove(r->f.wqid, wqid, nqid*sizeof(Qid));
  739. r->f.nwqid = nqid;
  740. fsreply(fs, r, err);
  741. }
  742. int
  743. ingroup(char *user, char *group)
  744. {
  745. Ndbtuple *t, *nt;
  746. Ndbs s;
  747. t = ndbsearch(db, &s, "group", group);
  748. if(t == nil)
  749. return 0;
  750. for(nt = t; nt; nt = nt->entry){
  751. if(strcmp(nt->attr, "uid") == 0)
  752. if(strcmp(nt->val, user) == 0)
  753. break;
  754. }
  755. ndbfree(t);
  756. return nt != nil;
  757. }
  758. int
  759. userok(char *u, char *cname)
  760. {
  761. Ndbtuple *t, *nt;
  762. Ndbs s;
  763. t = ndbsearch(db, &s, "console", cname);
  764. if(t == nil)
  765. return 0;
  766. for(nt = t; nt; nt = nt->entry){
  767. if(strcmp(nt->attr, "uid") == 0)
  768. if(strcmp(nt->val, u) == 0)
  769. break;
  770. if(strcmp(nt->attr, "gid") == 0)
  771. if(ingroup(u, nt->val))
  772. break;
  773. }
  774. ndbfree(t);
  775. return nt != nil;
  776. }
  777. int m2p[] ={
  778. [OREAD] 4,
  779. [OWRITE] 2,
  780. [ORDWR] 6
  781. };
  782. void
  783. fsopen(Fs *fs, Request *r, Fid *f)
  784. {
  785. int mode;
  786. Console *c;
  787. if(f->attached == 0){
  788. fsreply(fs, r, Enofid);
  789. return;
  790. }
  791. if(f->open){
  792. fsreply(fs, r, Eisopen);
  793. return;
  794. }
  795. mode = r->f.mode & 3;
  796. if((QTDIR & f->qid.type) && mode != OREAD){
  797. fsreply(fs, r, Eperm);
  798. return;
  799. }
  800. switch(TYPE(f->qid)){
  801. case Qdata:
  802. c = fs->cons[CONS(f->qid)];
  803. if(!userok(f->user, c->name)){
  804. fsreply(fs, r, Eperm);
  805. return;
  806. }
  807. f->rp = f->buf;
  808. f->wp = f->buf;
  809. f->c = c;
  810. lock(c);
  811. f->cnext = c->flist;
  812. c->flist = f;
  813. bcastmembers(fs, c, "+", f);
  814. if(c->pid == 0)
  815. fsreopen(fs, c);
  816. unlock(c);
  817. break;
  818. case Qctl:
  819. c = fs->cons[CONS(f->qid)];
  820. if(!userok(f->user, c->name)){
  821. fsreply(fs, r, Eperm);
  822. return;
  823. }
  824. f->c = c;
  825. break;
  826. case Qstat:
  827. c = fs->cons[CONS(f->qid)];
  828. if(!userok(f->user, c->name)){
  829. fsreply(fs, r, Eperm);
  830. return;
  831. }
  832. f->c = c;
  833. break;
  834. }
  835. f->open = 1;
  836. r->f.iounit = messagesize-IOHDRSZ;
  837. r->f.qid = f->qid;
  838. fsreply(fs, r, nil);
  839. }
  840. void
  841. fscreate(Fs *fs, Request *r, Fid*)
  842. {
  843. fsreply(fs, r, Eperm);
  844. }
  845. void
  846. fsread(Fs *fs, Request *r, Fid *f)
  847. {
  848. uchar *p, *e;
  849. int i, m, off;
  850. vlong offset;
  851. Dir d;
  852. char sbuf[ERRMAX];
  853. if(f->attached == 0){
  854. fsreply(fs, r, Enofid);
  855. return;
  856. }
  857. if(r->f.count < 0){
  858. fsreply(fs, r, Ebadcount);
  859. return;
  860. }
  861. if(QTDIR & f->qid.type){
  862. p = r->buf + IOHDRSZ;
  863. e = p + r->f.count;
  864. offset = r->f.offset;
  865. off = 0;
  866. for(i=0; p<e; i++, off+=m){
  867. m = fsdirgen(fs, f->qid, i, &d, p, e-p);
  868. if(m <= BIT16SZ)
  869. break;
  870. if(off >= offset)
  871. p += m;
  872. }
  873. r->f.data = (char*)r->buf + IOHDRSZ;
  874. r->f.count = (char*)p - r->f.data;
  875. } else {
  876. switch(TYPE(f->qid)){
  877. case Qdata:
  878. addreq(&f->r, r);
  879. fskick(fs, f);
  880. return;
  881. case Qctl:
  882. r->f.data = (char*)r->buf+IOHDRSZ;
  883. r->f.count = 0;
  884. break;
  885. case Qstat:
  886. if(r->f.count > sizeof(sbuf))
  887. r->f.count = sizeof(sbuf);
  888. i = pread(f->c->sfd, sbuf, r->f.count, r->f.offset);
  889. if(i < 0){
  890. errstr(sbuf, sizeof sbuf);
  891. fsreply(fs, r, sbuf);
  892. return;
  893. }
  894. r->f.data = sbuf;
  895. r->f.count = i;
  896. break;
  897. default:
  898. fsreply(fs, r, Eexist);
  899. return;
  900. }
  901. }
  902. fsreply(fs, r, nil);
  903. }
  904. void
  905. fswrite(Fs *fs, Request *r, Fid *f)
  906. {
  907. int i;
  908. if(f->attached == 0){
  909. fsreply(fs, r, Enofid);
  910. return;
  911. }
  912. if(r->f.count < 0){
  913. fsreply(fs, r, Ebadcount);
  914. return;
  915. }
  916. if(QTDIR & f->qid.type){
  917. fsreply(fs, r, Eperm);
  918. return;
  919. }
  920. switch(TYPE(f->qid)){
  921. default:
  922. fsreply(fs, r, Eperm);
  923. return;
  924. case Qctl:
  925. write(f->c->cfd, r->f.data, r->f.count);
  926. break;
  927. case Qdata:
  928. if(f->c->cronly)
  929. for(i = 0; i < r->f.count; i++)
  930. if(r->f.data[i] == '\n')
  931. r->f.data[i] = '\r';
  932. write(f->c->fd, r->f.data, r->f.count);
  933. break;
  934. }
  935. fsreply(fs, r, nil);
  936. }
  937. void
  938. fsclunk(Fs *fs, Request *r, Fid *f)
  939. {
  940. Fid **l, *fl;
  941. Request *nr;
  942. if(f->open && TYPE(f->qid) == Qdata){
  943. while((nr = remreq(&f->r)) != nil){
  944. fsputfid(fs, f);
  945. free(nr);
  946. }
  947. lock(f->c);
  948. for(l = &f->c->flist; *l; l = &fl->cnext){
  949. fl = *l;
  950. if(fl == f){
  951. *l = fl->cnext;
  952. break;
  953. }
  954. }
  955. bcastmembers(fs, f->c, "-", f);
  956. if(f->c->ondemand && f->c->flist == nil)
  957. fsreopen(fs, f->c);
  958. unlock(f->c);
  959. }
  960. fsreply(fs, r, nil);
  961. fsputfid(fs, f);
  962. }
  963. void
  964. fsremove(Fs *fs, Request *r, Fid*)
  965. {
  966. fsreply(fs, r, Eperm);
  967. }
  968. void
  969. fsstat(Fs *fs, Request *r, Fid *f)
  970. {
  971. int i;
  972. Qid q;
  973. Dir d;
  974. q = parentqid(f->qid);
  975. for(i = 0; ; i++){
  976. r->f.stat = r->buf+IOHDRSZ;
  977. if((r->f.nstat = fsdirgen(fs, q, i, &d, r->f.stat, messagesize-IOHDRSZ)) <= BIT16SZ){
  978. fsreply(fs, r, Eexist);
  979. return;
  980. }
  981. if(d.qid.path == f->qid.path)
  982. break;
  983. }
  984. fsreply(fs, r, nil);
  985. }
  986. void
  987. fswstat(Fs *fs, Request *r, Fid*)
  988. {
  989. fsreply(fs, r, Eperm);
  990. }
  991. void
  992. fsreply(Fs *fs, Request *r, char *err)
  993. {
  994. int n;
  995. uchar buf[8192+IOHDRSZ];
  996. if(err){
  997. r->f.type = Rerror;
  998. r->f.ename = err;
  999. }
  1000. n = convS2M(&r->f, buf, messagesize);
  1001. if(debug)
  1002. fprint(2, "%F path %llux n=%d\n", &r->f, r->fid->qid.path, n);
  1003. fsputfid(fs, r->fid);
  1004. if(write(fs->fd, buf, n) != n)
  1005. fatal("unmounted");
  1006. free(r);
  1007. }
  1008. /*
  1009. * called whenever input or a read request has been received
  1010. */
  1011. void
  1012. fskick(Fs *fs, Fid *f)
  1013. {
  1014. Request *r;
  1015. char *p, *rp, *wp, *ep;
  1016. int i;
  1017. lock(f);
  1018. while(f->rp != f->wp){
  1019. r = remreq(&f->r);
  1020. if(r == nil)
  1021. break;
  1022. p = (char*)r->buf;
  1023. rp = f->rp;
  1024. wp = f->wp;
  1025. ep = &f->buf[Bufsize];
  1026. for(i = 0; i < r->f.count && rp != wp; i++){
  1027. *p++ = *rp++;
  1028. if(rp >= ep)
  1029. rp = f->buf;
  1030. }
  1031. f->rp = rp;
  1032. r->f.data = (char*)r->buf;
  1033. r->f.count = p - (char*)r->buf;
  1034. fsreply(fs, r, nil);
  1035. }
  1036. unlock(f);
  1037. }
  1038. void
  1039. usage(void)
  1040. {
  1041. fprint(2, "usage: consolefs [-d] [-m mount-point] [-c console-db]\n");
  1042. threadexitsall("usage");
  1043. }
  1044. void
  1045. threadmain(int argc, char **argv)
  1046. {
  1047. fmtinstall('F', fcallfmt);
  1048. ARGBEGIN{
  1049. case 'd':
  1050. debug++;
  1051. break;
  1052. case 'c':
  1053. consoledb = ARGF();
  1054. if(consoledb == nil)
  1055. usage();
  1056. break;
  1057. case 'm':
  1058. mntpt = ARGF();
  1059. if(mntpt == nil)
  1060. usage();
  1061. break;
  1062. }ARGEND;
  1063. db = ndbopen(consoledb);
  1064. if(db == nil)
  1065. fatal("can't open %s: %r", consoledb);
  1066. fsmount(mntpt);
  1067. }