devsegment.c 9.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578
  1. #include "u.h"
  2. #include "../port/lib.h"
  3. #include "mem.h"
  4. #include "dat.h"
  5. #include "fns.h"
  6. #include "../port/error.h"
  7. enum
  8. {
  9. Qtopdir,
  10. Qsegdir,
  11. Qctl,
  12. Qdata,
  13. /* commands to kproc */
  14. Cnone=0,
  15. Cread,
  16. Cwrite,
  17. Cstart,
  18. Cdie,
  19. };
  20. #define TYPE(x) (int)( (c)->qid.path & 0x7 )
  21. #define SEG(x) ( ((c)->qid.path >> 3) & 0x3f )
  22. #define PATH(s, t) ( ((s)<<3) | (t) )
  23. typedef struct Globalseg Globalseg;
  24. struct Globalseg
  25. {
  26. Ref;
  27. Segment *s;
  28. char *name;
  29. char *uid;
  30. vlong length;
  31. long perm;
  32. /* kproc to do reading and writing */
  33. QLock l; /* sync kproc access */
  34. Rendez cmdwait; /* where kproc waits */
  35. Rendez replywait; /* where requestor waits */
  36. Proc *kproc;
  37. char *data;
  38. long off;
  39. int dlen;
  40. int cmd;
  41. char err[64];
  42. };
  43. static Globalseg *globalseg[100];
  44. static Lock globalseglock;
  45. Segment* (*_globalsegattach)(Proc*, char*);
  46. static Segment* globalsegattach(Proc *p, char *name);
  47. static int cmddone(void*);
  48. static void segmentkproc(void*);
  49. static void docmd(Globalseg *g, int cmd);
  50. /*
  51. * returns with globalseg incref'd
  52. */
  53. static Globalseg*
  54. getgseg(Chan *c)
  55. {
  56. int x;
  57. Globalseg *g;
  58. x = SEG(c);
  59. lock(&globalseglock);
  60. if(x >= nelem(globalseg))
  61. panic("getgseg");
  62. g = globalseg[x];
  63. if(g != nil)
  64. incref(g);
  65. unlock(&globalseglock);
  66. if(g == nil)
  67. error("global segment disappeared");
  68. return g;
  69. }
  70. static void
  71. putgseg(Globalseg *g)
  72. {
  73. if(decref(g) > 0)
  74. return;
  75. if(g->s != nil)
  76. putseg(g->s);
  77. if(g->kproc)
  78. docmd(g, Cdie);
  79. free(g->name);
  80. free(g->uid);
  81. free(g);
  82. }
  83. static int
  84. segmentgen(Chan *c, char*, Dirtab*, int, int s, Dir *dp)
  85. {
  86. Qid q;
  87. Globalseg *g;
  88. ulong size;
  89. switch(TYPE(c)) {
  90. case Qtopdir:
  91. if(s == DEVDOTDOT){
  92. q.vers = 0;
  93. q.path = PATH(0, Qtopdir);
  94. q.type = QTDIR;
  95. devdir(c, q, "#g", 0, eve, DMDIR|0777, dp);
  96. break;
  97. }
  98. if(s >= nelem(globalseg))
  99. return -1;
  100. lock(&globalseglock);
  101. g = globalseg[s];
  102. if(g == nil){
  103. unlock(&globalseglock);
  104. return 0;
  105. }
  106. q.vers = 0;
  107. q.path = PATH(s, Qsegdir);
  108. q.type = QTDIR;
  109. devdir(c, q, g->name, 0, g->uid, DMDIR|0777, dp);
  110. unlock(&globalseglock);
  111. break;
  112. case Qsegdir:
  113. if(s == DEVDOTDOT){
  114. q.vers = 0;
  115. q.path = PATH(0, Qtopdir);
  116. q.type = QTDIR;
  117. devdir(c, q, "#g", 0, eve, DMDIR|0777, dp);
  118. break;
  119. }
  120. /* fall through */
  121. case Qctl:
  122. case Qdata:
  123. switch(s){
  124. case 0:
  125. g = getgseg(c);
  126. q.vers = 0;
  127. q.path = PATH(SEG(c), Qctl);
  128. q.type = QTFILE;
  129. devdir(c, q, "ctl", 0, g->uid, g->perm, dp);
  130. putgseg(g);
  131. break;
  132. case 1:
  133. g = getgseg(c);
  134. q.vers = 0;
  135. q.path = PATH(SEG(c), Qdata);
  136. q.type = QTFILE;
  137. if(g->s != nil)
  138. size = g->s->top - g->s->base;
  139. else
  140. size = 0;
  141. devdir(c, q, "data", size, g->uid, g->perm, dp);
  142. putgseg(g);
  143. break;
  144. default:
  145. return -1;
  146. }
  147. break;
  148. }
  149. return 1;
  150. }
  151. static void
  152. segmentinit(void)
  153. {
  154. _globalsegattach = globalsegattach;
  155. }
  156. static Chan*
  157. segmentattach(char *spec)
  158. {
  159. return devattach('g', spec);
  160. }
  161. static Walkqid*
  162. segmentwalk(Chan *c, Chan *nc, char **name, int nname)
  163. {
  164. return devwalk(c, nc, name, nname, 0, 0, segmentgen);
  165. }
  166. static int
  167. segmentstat(Chan *c, uchar *db, int n)
  168. {
  169. return devstat(c, db, n, 0, 0, segmentgen);
  170. }
  171. static int
  172. cmddone(void *arg)
  173. {
  174. Globalseg *g = arg;
  175. return g->cmd == Cnone;
  176. }
  177. static Chan*
  178. segmentopen(Chan *c, int omode)
  179. {
  180. Globalseg *g;
  181. switch(TYPE(c)){
  182. case Qtopdir:
  183. case Qsegdir:
  184. if(omode != 0)
  185. error(Eisdir);
  186. break;
  187. case Qctl:
  188. g = getgseg(c);
  189. if(waserror()){
  190. putgseg(g);
  191. nexterror();
  192. }
  193. devpermcheck(g->uid, g->perm, omode);
  194. c->aux = g;
  195. poperror();
  196. c->flag |= COPEN;
  197. break;
  198. case Qdata:
  199. g = getgseg(c);
  200. if(waserror()){
  201. putgseg(g);
  202. nexterror();
  203. }
  204. devpermcheck(g->uid, g->perm, omode);
  205. if(g->s == nil)
  206. error("segment not yet allocated");
  207. if(g->kproc == nil){
  208. qlock(&g->l);
  209. if(waserror()){
  210. qunlock(&g->l);
  211. nexterror();
  212. }
  213. if(g->kproc == nil){
  214. g->cmd = Cnone;
  215. kproc(g->name, segmentkproc, g);
  216. docmd(g, Cstart);
  217. }
  218. qunlock(&g->l);
  219. poperror();
  220. }
  221. c->aux = g;
  222. poperror();
  223. c->flag |= COPEN;
  224. break;
  225. default:
  226. panic("segmentopen");
  227. }
  228. c->mode = openmode(omode);
  229. c->offset = 0;
  230. return c;
  231. }
  232. static void
  233. segmentclose(Chan *c)
  234. {
  235. if(TYPE(c) == Qtopdir)
  236. return;
  237. if(c->flag & COPEN)
  238. putgseg(c->aux);
  239. }
  240. static void
  241. segmentcreate(Chan *c, char *name, int omode, ulong perm)
  242. {
  243. int x, xfree;
  244. Globalseg *g;
  245. if(TYPE(c) != Qtopdir)
  246. error(Eperm);
  247. if(isphysseg(name))
  248. error(Eexist);
  249. if((perm & DMDIR) == 0)
  250. error(Ebadarg);
  251. if(waserror()){
  252. unlock(&globalseglock);
  253. nexterror();
  254. }
  255. lock(&globalseglock);
  256. xfree = -1;
  257. for(x = 0; x < nelem(globalseg); x++){
  258. g = globalseg[x];
  259. if(g == nil){
  260. if(xfree < 0)
  261. xfree = x;
  262. } else {
  263. if(strcmp(g->name, name) == 0)
  264. error(Eexist);
  265. }
  266. }
  267. if(xfree < 0)
  268. error("too many global segments");
  269. g = smalloc(sizeof(Globalseg));
  270. g->ref = 1;
  271. kstrdup(&g->name, name);
  272. kstrdup(&g->uid, up->user);
  273. g->perm = 0660;
  274. globalseg[xfree] = g;
  275. unlock(&globalseglock);
  276. poperror();
  277. c->qid.path = PATH(x, Qsegdir);
  278. c->qid.type = QTDIR;
  279. c->qid.vers = 0;
  280. c->mode = openmode(omode);
  281. c->mode = OWRITE;
  282. }
  283. static long
  284. segmentread(Chan *c, void *a, long n, vlong voff)
  285. {
  286. Globalseg *g;
  287. char buf[32];
  288. if(c->qid.type == QTDIR)
  289. return devdirread(c, a, n, (Dirtab *)0, 0L, segmentgen);
  290. switch(TYPE(c)){
  291. case Qctl:
  292. g = c->aux;
  293. if(g->s == nil)
  294. error("segment not yet allocated");
  295. sprint(buf, "va %#lux %#lux\n", g->s->base, g->s->top-g->s->base);
  296. return readstr(voff, a, n, buf);
  297. case Qdata:
  298. g = c->aux;
  299. if(voff > g->s->top - g->s->base)
  300. error(Ebadarg);
  301. if(voff + n > g->s->top - g->s->base)
  302. n = g->s->top - g->s->base - voff;
  303. qlock(&g->l);
  304. g->off = voff + g->s->base;
  305. g->data = smalloc(n);
  306. if(waserror()){
  307. free(g->data);
  308. qunlock(&g->l);
  309. nexterror();
  310. }
  311. g->dlen = n;
  312. docmd(g, Cread);
  313. memmove(a, g->data, g->dlen);
  314. free(g->data);
  315. qunlock(&g->l);
  316. poperror();
  317. return g->dlen;
  318. default:
  319. panic("segmentread");
  320. }
  321. return 0; /* not reached */
  322. }
  323. static long
  324. segmentwrite(Chan *c, void *a, long n, vlong voff)
  325. {
  326. Cmdbuf *cb;
  327. Globalseg *g;
  328. ulong va, len, top;
  329. if(c->qid.type == QTDIR)
  330. error(Eperm);
  331. switch(TYPE(c)){
  332. case Qctl:
  333. g = c->aux;
  334. cb = parsecmd(a, n);
  335. if(strcmp(cb->f[0], "va") == 0){
  336. if(g->s != nil)
  337. error("already has a virtual address");
  338. if(cb->nf < 3)
  339. error(Ebadarg);
  340. va = strtoul(cb->f[1], 0, 0);
  341. len = strtoul(cb->f[2], 0, 0);
  342. top = PGROUND(va + len);
  343. va = va&~(BY2PG-1);
  344. len = (top - va) / BY2PG;
  345. if(len == 0)
  346. error(Ebadarg);
  347. g->s = newseg(SG_SHARED, va, len);
  348. } else
  349. error(Ebadctl);
  350. break;
  351. case Qdata:
  352. g = c->aux;
  353. if(voff + n > g->s->top - g->s->base)
  354. error(Ebadarg);
  355. qlock(&g->l);
  356. g->off = voff + g->s->base;
  357. g->data = smalloc(n);
  358. if(waserror()){
  359. free(g->data);
  360. qunlock(&g->l);
  361. nexterror();
  362. }
  363. g->dlen = n;
  364. memmove(g->data, a, g->dlen);
  365. docmd(g, Cwrite);
  366. free(g->data);
  367. qunlock(&g->l);
  368. poperror();
  369. return g->dlen;
  370. default:
  371. panic("segmentwrite");
  372. }
  373. return 0; /* not reached */
  374. }
  375. static int
  376. segmentwstat(Chan *c, uchar *dp, int n)
  377. {
  378. Globalseg *g;
  379. Dir *d;
  380. if(c->qid.type == QTDIR)
  381. error(Eperm);
  382. g = getgseg(c);
  383. if(waserror()){
  384. putgseg(g);
  385. nexterror();
  386. }
  387. if(strcmp(g->uid, up->user) && !iseve())
  388. error(Eperm);
  389. d = smalloc(sizeof(Dir)+n);
  390. n = convM2D(dp, n, &d[0], (char*)&d[1]);
  391. g->perm = d->mode & 0777;
  392. putgseg(g);
  393. poperror();
  394. free(d);
  395. return n;
  396. }
  397. static void
  398. segmentremove(Chan *c)
  399. {
  400. Globalseg *g;
  401. int x;
  402. if(TYPE(c) != Qsegdir)
  403. error(Eperm);
  404. lock(&globalseglock);
  405. x = SEG(c);
  406. g = globalseg[x];
  407. globalseg[x] = nil;
  408. unlock(&globalseglock);
  409. if(g != nil)
  410. putgseg(g);
  411. }
  412. /*
  413. * called by segattach()
  414. */
  415. static Segment*
  416. globalsegattach(Proc *p, char *name)
  417. {
  418. int x;
  419. Globalseg *g;
  420. Segment *s;
  421. g = nil;
  422. if(waserror()){
  423. unlock(&globalseglock);
  424. nexterror();
  425. }
  426. lock(&globalseglock);
  427. for(x = 0; x < nelem(globalseg); x++){
  428. g = globalseg[x];
  429. if(g != nil && strcmp(g->name, name) == 0)
  430. break;
  431. }
  432. if(x == nelem(globalseg)){
  433. unlock(&globalseglock);
  434. poperror();
  435. return nil;
  436. }
  437. devpermcheck(g->uid, g->perm, ORDWR);
  438. s = g->s;
  439. if(s == nil)
  440. error("global segment not assigned a virtual address");
  441. if(isoverlap(p, s->base, s->top - s->base) != nil)
  442. error("overlaps existing segment");
  443. incref(s);
  444. unlock(&globalseglock);
  445. poperror();
  446. return s;
  447. }
  448. static void
  449. docmd(Globalseg *g, int cmd)
  450. {
  451. g->err[0] = 0;
  452. g->cmd = cmd;
  453. wakeup(&g->cmdwait);
  454. sleep(&g->replywait, cmddone, g);
  455. if(g->err[0])
  456. error(g->err);
  457. }
  458. static int
  459. cmdready(void *arg)
  460. {
  461. Globalseg *g = arg;
  462. return g->cmd != Cnone;
  463. }
  464. static void
  465. segmentkproc(void *arg)
  466. {
  467. Globalseg *g = arg;
  468. int done;
  469. int sno;
  470. for(sno = 0; sno < NSEG; sno++)
  471. if(up->seg[sno] == nil && sno != ESEG)
  472. break;
  473. if(sno == NSEG)
  474. panic("segmentkproc");
  475. g->kproc = up;
  476. incref(g->s);
  477. up->seg[sno] = g->s;
  478. for(done = 0; !done;){
  479. sleep(&g->cmdwait, cmdready, g);
  480. if(waserror()){
  481. strncpy(g->err, up->errstr, sizeof(g->err));
  482. } else {
  483. switch(g->cmd){
  484. case Cstart:
  485. break;
  486. case Cdie:
  487. done = 1;
  488. break;
  489. case Cread:
  490. memmove(g->data, (char*)g->off, g->dlen);
  491. break;
  492. case Cwrite:
  493. memmove((char*)g->off, g->data, g->dlen);
  494. break;
  495. }
  496. poperror();
  497. }
  498. g->cmd = Cnone;
  499. wakeup(&g->replywait);
  500. }
  501. }
  502. Dev segmentdevtab = {
  503. 'g',
  504. "segment",
  505. devreset,
  506. segmentinit,
  507. devshutdown,
  508. segmentattach,
  509. segmentwalk,
  510. segmentstat,
  511. segmentopen,
  512. segmentcreate,
  513. segmentclose,
  514. segmentread,
  515. devbread,
  516. segmentwrite,
  517. devbwrite,
  518. segmentremove,
  519. segmentwstat,
  520. };