devproc.c 28 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582
  1. #include "u.h"
  2. #include <trace.h>
  3. #include "tos.h"
  4. #include "../port/lib.h"
  5. #include "mem.h"
  6. #include "dat.h"
  7. #include "fns.h"
  8. #include "../port/error.h"
  9. #include "ureg.h"
  10. #include "edf.h"
  11. enum
  12. {
  13. Qdir,
  14. Qtrace,
  15. Qargs,
  16. Qctl,
  17. Qfd,
  18. Qfpregs,
  19. Qkregs,
  20. Qmem,
  21. Qnote,
  22. Qnoteid,
  23. Qnotepg,
  24. Qns,
  25. Qproc,
  26. Qregs,
  27. Qsegment,
  28. Qstatus,
  29. Qtext,
  30. Qwait,
  31. Qprofile,
  32. };
  33. enum
  34. {
  35. CMclose,
  36. CMclosefiles,
  37. CMfixedpri,
  38. CMhang,
  39. CMkill,
  40. CMnohang,
  41. CMnoswap,
  42. CMpri,
  43. CMprivate,
  44. CMprofile,
  45. CMstart,
  46. CMstartstop,
  47. CMstartsyscall,
  48. CMstop,
  49. CMwaitstop,
  50. CMwired,
  51. CMtrace,
  52. /* real time */
  53. CMperiod,
  54. CMdeadline,
  55. CMcost,
  56. CMsporadic,
  57. CMdeadlinenotes,
  58. CMadmit,
  59. CMextra,
  60. CMexpel,
  61. CMevent,
  62. };
  63. enum{
  64. Nevents = 0x4000,
  65. Emask = Nevents - 1,
  66. };
  67. #define STATSIZE (2*KNAMELEN+12+9*12)
  68. /*
  69. * Status, fd, and ns are left fully readable (0444) because of their use in debugging,
  70. * particularly on shared servers.
  71. * Arguably, ns and fd shouldn't be readable; if you'd prefer, change them to 0000
  72. */
  73. Dirtab procdir[] =
  74. {
  75. "args", {Qargs}, 0, 0660,
  76. "ctl", {Qctl}, 0, 0000,
  77. "fd", {Qfd}, 0, 0444,
  78. "fpregs", {Qfpregs}, sizeof(FPsave), 0000,
  79. "kregs", {Qkregs}, sizeof(Ureg), 0400,
  80. "mem", {Qmem}, 0, 0000,
  81. "note", {Qnote}, 0, 0000,
  82. "noteid", {Qnoteid}, 0, 0664,
  83. "notepg", {Qnotepg}, 0, 0000,
  84. "ns", {Qns}, 0, 0444,
  85. "proc", {Qproc}, 0, 0400,
  86. "regs", {Qregs}, sizeof(Ureg), 0000,
  87. "segment", {Qsegment}, 0, 0444,
  88. "status", {Qstatus}, STATSIZE, 0444,
  89. "text", {Qtext}, 0, 0000,
  90. "wait", {Qwait}, 0, 0400,
  91. "profile", {Qprofile}, 0, 0400,
  92. };
  93. static
  94. Cmdtab proccmd[] = {
  95. CMclose, "close", 2,
  96. CMclosefiles, "closefiles", 1,
  97. CMfixedpri, "fixedpri", 2,
  98. CMhang, "hang", 1,
  99. CMnohang, "nohang", 1,
  100. CMnoswap, "noswap", 1,
  101. CMkill, "kill", 1,
  102. CMpri, "pri", 2,
  103. CMprivate, "private", 1,
  104. CMprofile, "profile", 1,
  105. CMstart, "start", 1,
  106. CMstartstop, "startstop", 1,
  107. CMstartsyscall, "startsyscall", 1,
  108. CMstop, "stop", 1,
  109. CMwaitstop, "waitstop", 1,
  110. CMwired, "wired", 2,
  111. CMtrace, "trace", 0,
  112. CMperiod, "period", 2,
  113. CMdeadline, "deadline", 2,
  114. CMcost, "cost", 2,
  115. CMsporadic, "sporadic", 1,
  116. CMdeadlinenotes, "deadlinenotes", 1,
  117. CMadmit, "admit", 1,
  118. CMextra, "extra", 1,
  119. CMexpel, "expel", 1,
  120. CMevent, "event", 1,
  121. };
  122. /* Segment type from portdat.h */
  123. static char *sname[]={ "Text", "Data", "Bss", "Stack", "Shared", "Phys", };
  124. /*
  125. * Qids are, in path:
  126. * 4 bits of file type (qids above)
  127. * 23 bits of process slot number + 1
  128. * in vers,
  129. * 32 bits of pid, for consistency checking
  130. * If notepg, c->pgrpid.path is pgrp slot, .vers is noteid.
  131. */
  132. #define QSHIFT 5 /* location in qid of proc slot # */
  133. #define QID(q) ((((ulong)(q).path)&0x0000001F)>>0)
  134. #define SLOT(q) (((((ulong)(q).path)&0x07FFFFFE0)>>QSHIFT)-1)
  135. #define PID(q) ((q).vers)
  136. #define NOTEID(q) ((q).vers)
  137. void procctlreq(Proc*, char*, int);
  138. int procctlmemio(Proc*, ulong, int, void*, int);
  139. Chan* proctext(Chan*, Proc*);
  140. Segment* txt2data(Proc*, Segment*);
  141. int procstopped(void*);
  142. void mntscan(Mntwalk*, Proc*);
  143. static Traceevent *tevents;
  144. static Lock tlock;
  145. static int topens;
  146. static int tproduced, tconsumed;
  147. void (*proctrace)(Proc*, int, vlong);
  148. extern int unfair;
  149. static void
  150. profclock(Ureg *ur, Timer *)
  151. {
  152. Tos *tos;
  153. if(up == 0 || up->state != Running)
  154. return;
  155. /* user profiling clock */
  156. if(userureg(ur)){
  157. tos = (Tos*)(USTKTOP-sizeof(Tos));
  158. tos->clock += TK2MS(1);
  159. segclock(ur->pc);
  160. }
  161. }
  162. static int
  163. procgen(Chan *c, char *name, Dirtab *tab, int, int s, Dir *dp)
  164. {
  165. Qid qid;
  166. Proc *p;
  167. char *ename;
  168. Segment *q;
  169. ulong pid, path, perm, len;
  170. if(s == DEVDOTDOT){
  171. mkqid(&qid, Qdir, 0, QTDIR);
  172. devdir(c, qid, "#p", 0, eve, 0555, dp);
  173. return 1;
  174. }
  175. if(c->qid.path == Qdir){
  176. if(s == 0){
  177. strcpy(up->genbuf, "trace");
  178. mkqid(&qid, Qtrace, -1, QTFILE);
  179. devdir(c, qid, up->genbuf, 0, eve, 0444, dp);
  180. return 1;
  181. }
  182. if(name != nil){
  183. /* ignore s and use name to find pid */
  184. pid = strtol(name, &ename, 10);
  185. if(pid==0 || ename[0]!='\0')
  186. return -1;
  187. s = procindex(pid);
  188. if(s < 0)
  189. return -1;
  190. }
  191. else if(--s >= conf.nproc)
  192. return -1;
  193. p = proctab(s);
  194. pid = p->pid;
  195. if(pid == 0)
  196. return 0;
  197. sprint(up->genbuf, "%lud", pid);
  198. /*
  199. * String comparison is done in devwalk so name must match its formatted pid
  200. */
  201. if(name != nil && strcmp(name, up->genbuf) != 0)
  202. return -1;
  203. mkqid(&qid, (s+1)<<QSHIFT, pid, QTDIR);
  204. devdir(c, qid, up->genbuf, 0, p->user, DMDIR|0555, dp);
  205. return 1;
  206. }
  207. if(c->qid.path == Qtrace){
  208. strcpy(up->genbuf, "trace");
  209. mkqid(&qid, Qtrace, -1, QTFILE);
  210. devdir(c, qid, up->genbuf, 0, eve, 0444, dp);
  211. return 1;
  212. }
  213. if(s >= nelem(procdir))
  214. return -1;
  215. if(tab)
  216. panic("procgen");
  217. tab = &procdir[s];
  218. path = c->qid.path&~(((1<<QSHIFT)-1)); /* slot component */
  219. p = proctab(SLOT(c->qid));
  220. perm = tab->perm;
  221. if(perm == 0)
  222. perm = p->procmode;
  223. else /* just copy read bits */
  224. perm |= p->procmode & 0444;
  225. len = tab->length;
  226. switch(QID(c->qid)) {
  227. case Qwait:
  228. len = p->nwait; /* incorrect size, but >0 means there's something to read */
  229. break;
  230. case Qprofile:
  231. q = p->seg[TSEG];
  232. if(q && q->profile) {
  233. len = (q->top-q->base)>>LRESPROF;
  234. len *= sizeof(*q->profile);
  235. }
  236. break;
  237. }
  238. mkqid(&qid, path|tab->qid.path, c->qid.vers, QTFILE);
  239. devdir(c, qid, tab->name, len, p->user, perm, dp);
  240. return 1;
  241. }
  242. static void
  243. _proctrace(Proc* p, Tevent etype, vlong ts)
  244. {
  245. Traceevent *te;
  246. if (p->trace == 0 || topens == 0 ||
  247. tproduced - tconsumed >= Nevents)
  248. return;
  249. te = &tevents[tproduced&Emask];
  250. te->pid = p->pid;
  251. te->etype = etype;
  252. if (ts == 0)
  253. te->time = todget(nil);
  254. else
  255. te->time = ts;
  256. tproduced++;
  257. }
  258. static void
  259. procinit(void)
  260. {
  261. if(conf.nproc >= (1<<(16-QSHIFT))-1)
  262. print("warning: too many procs for devproc\n");
  263. addclock0link((void (*)(void))profclock, 113); /* Relative prime to HZ */
  264. }
  265. static Chan*
  266. procattach(char *spec)
  267. {
  268. return devattach('p', spec);
  269. }
  270. static Walkqid*
  271. procwalk(Chan *c, Chan *nc, char **name, int nname)
  272. {
  273. return devwalk(c, nc, name, nname, 0, 0, procgen);
  274. }
  275. static int
  276. procstat(Chan *c, uchar *db, int n)
  277. {
  278. return devstat(c, db, n, 0, 0, procgen);
  279. }
  280. /*
  281. * none can't read or write state on other
  282. * processes. This is to contain access of
  283. * servers running as none should they be
  284. * subverted by, for example, a stack attack.
  285. */
  286. static void
  287. nonone(Proc *p)
  288. {
  289. if(p == up)
  290. return;
  291. if(strcmp(up->user, "none") != 0)
  292. return;
  293. if(iseve())
  294. return;
  295. error(Eperm);
  296. }
  297. static Chan*
  298. procopen(Chan *c, int omode)
  299. {
  300. Proc *p;
  301. Pgrp *pg;
  302. Chan *tc;
  303. int pid;
  304. if(c->qid.type & QTDIR)
  305. return devopen(c, omode, 0, 0, procgen);
  306. if(QID(c->qid) == Qtrace){
  307. if (omode != OREAD)
  308. error(Eperm);
  309. lock(&tlock);
  310. if (waserror()){
  311. unlock(&tlock);
  312. nexterror();
  313. }
  314. if (topens > 0)
  315. error("already open");
  316. topens++;
  317. if (tevents == nil){
  318. tevents = (Traceevent*)malloc(sizeof(Traceevent) * Nevents);
  319. if(tevents == nil)
  320. error(Enomem);
  321. tproduced = tconsumed = 0;
  322. }
  323. proctrace = _proctrace;
  324. unlock(&tlock);
  325. poperror();
  326. c->mode = openmode(omode);
  327. c->flag |= COPEN;
  328. c->offset = 0;
  329. return c;
  330. }
  331. p = proctab(SLOT(c->qid));
  332. qlock(&p->debug);
  333. if(waserror()){
  334. qunlock(&p->debug);
  335. nexterror();
  336. }
  337. pid = PID(c->qid);
  338. if(p->pid != pid)
  339. error(Eprocdied);
  340. omode = openmode(omode);
  341. switch(QID(c->qid)){
  342. case Qtext:
  343. if(omode != OREAD)
  344. error(Eperm);
  345. tc = proctext(c, p);
  346. tc->offset = 0;
  347. qunlock(&p->debug);
  348. poperror();
  349. return tc;
  350. case Qproc:
  351. case Qkregs:
  352. case Qsegment:
  353. case Qprofile:
  354. case Qfd:
  355. if(omode != OREAD)
  356. error(Eperm);
  357. break;
  358. case Qnote:
  359. if(p->privatemem)
  360. error(Eperm);
  361. break;
  362. case Qmem:
  363. case Qctl:
  364. if(p->privatemem)
  365. error(Eperm);
  366. nonone(p);
  367. break;
  368. case Qargs:
  369. case Qnoteid:
  370. case Qstatus:
  371. case Qwait:
  372. case Qregs:
  373. case Qfpregs:
  374. nonone(p);
  375. break;
  376. case Qns:
  377. if(omode != OREAD)
  378. error(Eperm);
  379. c->aux = malloc(sizeof(Mntwalk));
  380. break;
  381. case Qnotepg:
  382. nonone(p);
  383. pg = p->pgrp;
  384. if(pg == nil)
  385. error(Eprocdied);
  386. if(omode!=OWRITE || pg->pgrpid == 1)
  387. error(Eperm);
  388. c->pgrpid.path = pg->pgrpid+1;
  389. c->pgrpid.vers = p->noteid;
  390. break;
  391. default:
  392. pprint("procopen %lux\n", c->qid);
  393. error(Egreg);
  394. }
  395. /* Affix pid to qid */
  396. if(p->state != Dead)
  397. c->qid.vers = p->pid;
  398. /* make sure the process slot didn't get reallocated while we were playing */
  399. coherence();
  400. if(p->pid != pid)
  401. error(Eprocdied);
  402. tc = devopen(c, omode, 0, 0, procgen);
  403. qunlock(&p->debug);
  404. poperror();
  405. return tc;
  406. }
  407. static int
  408. procwstat(Chan *c, uchar *db, int n)
  409. {
  410. Proc *p;
  411. Dir *d;
  412. if(c->qid.type&QTDIR)
  413. error(Eperm);
  414. if(QID(c->qid) == Qtrace)
  415. return devwstat(c, db, n);
  416. p = proctab(SLOT(c->qid));
  417. nonone(p);
  418. d = nil;
  419. if(waserror()){
  420. free(d);
  421. qunlock(&p->debug);
  422. nexterror();
  423. }
  424. qlock(&p->debug);
  425. if(p->pid != PID(c->qid))
  426. error(Eprocdied);
  427. if(strcmp(up->user, p->user) != 0 && strcmp(up->user, eve) != 0)
  428. error(Eperm);
  429. d = smalloc(sizeof(Dir)+n);
  430. n = convM2D(db, n, &d[0], (char*)&d[1]);
  431. if(n == 0)
  432. error(Eshortstat);
  433. if(!emptystr(d->uid) && strcmp(d->uid, p->user) != 0){
  434. if(strcmp(up->user, eve) != 0)
  435. error(Eperm);
  436. else
  437. kstrdup(&p->user, d->uid);
  438. }
  439. if(d->mode != ~0UL)
  440. p->procmode = d->mode&0777;
  441. poperror();
  442. free(d);
  443. qunlock(&p->debug);
  444. return n;
  445. }
  446. static long
  447. procoffset(long offset, char *va, int *np)
  448. {
  449. if(offset > 0) {
  450. offset -= *np;
  451. if(offset < 0) {
  452. memmove(va, va+*np+offset, -offset);
  453. *np = -offset;
  454. }
  455. else
  456. *np = 0;
  457. }
  458. return offset;
  459. }
  460. static int
  461. procqidwidth(Chan *c)
  462. {
  463. char buf[32];
  464. return sprint(buf, "%lud", c->qid.vers);
  465. }
  466. int
  467. procfdprint(Chan *c, int fd, int w, char *s, int ns)
  468. {
  469. int n;
  470. if(w == 0)
  471. w = procqidwidth(c);
  472. n = snprint(s, ns, "%3d %.2s %C %4ld (%.16llux %*lud %.2ux) %5ld %8lld %s\n",
  473. fd,
  474. &"r w rw"[(c->mode&3)<<1],
  475. devtab[c->type]->dc, c->dev,
  476. c->qid.path, w, c->qid.vers, c->qid.type,
  477. c->iounit, c->offset, c->path->s);
  478. return n;
  479. }
  480. static int
  481. procfds(Proc *p, char *va, int count, long offset)
  482. {
  483. Fgrp *f;
  484. Chan *c;
  485. char buf[256];
  486. int n, i, w, ww;
  487. char *a;
  488. /* print to buf to avoid holding fgrp lock while writing to user space */
  489. if(count > sizeof buf)
  490. count = sizeof buf;
  491. a = buf;
  492. qlock(&p->debug);
  493. f = p->fgrp;
  494. if(f == nil){
  495. qunlock(&p->debug);
  496. return 0;
  497. }
  498. lock(f);
  499. if(waserror()){
  500. unlock(f);
  501. qunlock(&p->debug);
  502. nexterror();
  503. }
  504. n = readstr(0, a, count, p->dot->path->s);
  505. n += snprint(a+n, count-n, "\n");
  506. offset = procoffset(offset, a, &n);
  507. /* compute width of qid.path */
  508. w = 0;
  509. for(i = 0; i <= f->maxfd; i++) {
  510. c = f->fd[i];
  511. if(c == nil)
  512. continue;
  513. ww = procqidwidth(c);
  514. if(ww > w)
  515. w = ww;
  516. }
  517. for(i = 0; i <= f->maxfd; i++) {
  518. c = f->fd[i];
  519. if(c == nil)
  520. continue;
  521. n += procfdprint(c, i, w, a+n, count-n);
  522. offset = procoffset(offset, a, &n);
  523. }
  524. unlock(f);
  525. qunlock(&p->debug);
  526. poperror();
  527. /* copy result to user space, now that locks are released */
  528. memmove(va, buf, n);
  529. return n;
  530. }
  531. static void
  532. procclose(Chan * c)
  533. {
  534. if(QID(c->qid) == Qtrace){
  535. lock(&tlock);
  536. if(topens > 0)
  537. topens--;
  538. if(topens == 0)
  539. proctrace = nil;
  540. unlock(&tlock);
  541. }
  542. if(QID(c->qid) == Qns && c->aux != 0)
  543. free(c->aux);
  544. }
  545. static void
  546. int2flag(int flag, char *s)
  547. {
  548. if(flag == 0){
  549. *s = '\0';
  550. return;
  551. }
  552. *s++ = '-';
  553. if(flag & MAFTER)
  554. *s++ = 'a';
  555. if(flag & MBEFORE)
  556. *s++ = 'b';
  557. if(flag & MCREATE)
  558. *s++ = 'c';
  559. if(flag & MCACHE)
  560. *s++ = 'C';
  561. *s = '\0';
  562. }
  563. static int
  564. procargs(Proc *p, char *buf, int nbuf)
  565. {
  566. int j, k, m;
  567. char *a;
  568. int n;
  569. a = p->args;
  570. if(p->setargs){
  571. snprint(buf, nbuf, "%s [%s]", p->text, p->args);
  572. return strlen(buf);
  573. }
  574. n = p->nargs;
  575. for(j = 0; j < nbuf - 1; j += m){
  576. if(n <= 0)
  577. break;
  578. if(j != 0)
  579. buf[j++] = ' ';
  580. m = snprint(buf+j, nbuf-j, "%q", a);
  581. k = strlen(a) + 1;
  582. a += k;
  583. n -= k;
  584. }
  585. return j;
  586. }
  587. static int
  588. eventsavailable(void *)
  589. {
  590. return tproduced > tconsumed;
  591. }
  592. static long
  593. procread(Chan *c, void *va, long n, vlong off)
  594. {
  595. /* NSEG*32 was too small for worst cases */
  596. char *a, flag[10], *sps, *srv, statbuf[NSEG*64];
  597. int i, j, m, navail, ne, pid, rsize;
  598. long l;
  599. uchar *rptr;
  600. ulong offset;
  601. Confmem *cm;
  602. Mntwalk *mw;
  603. Proc *p;
  604. Segment *sg, *s;
  605. Ureg kur;
  606. Waitq *wq;
  607. a = va;
  608. offset = off;
  609. if(c->qid.type & QTDIR)
  610. return devdirread(c, a, n, 0, 0, procgen);
  611. if(QID(c->qid) == Qtrace){
  612. if(!eventsavailable(nil))
  613. return 0;
  614. rptr = (uchar*)va;
  615. navail = tproduced - tconsumed;
  616. if(navail > n / sizeof(Traceevent))
  617. navail = n / sizeof(Traceevent);
  618. while(navail > 0) {
  619. ne = ((tconsumed & Emask) + navail > Nevents)?
  620. Nevents - (tconsumed & Emask): navail;
  621. memmove(rptr, &tevents[tconsumed & Emask],
  622. ne * sizeof(Traceevent));
  623. tconsumed += ne;
  624. rptr += ne * sizeof(Traceevent);
  625. navail -= ne;
  626. }
  627. return rptr - (uchar*)va;
  628. }
  629. p = proctab(SLOT(c->qid));
  630. if(p->pid != PID(c->qid))
  631. error(Eprocdied);
  632. switch(QID(c->qid)){
  633. case Qargs:
  634. qlock(&p->debug);
  635. j = procargs(p, up->genbuf, sizeof up->genbuf);
  636. qunlock(&p->debug);
  637. if(offset >= j)
  638. return 0;
  639. if(offset+n > j)
  640. n = j-offset;
  641. memmove(a, &up->genbuf[offset], n);
  642. return n;
  643. case Qmem:
  644. if(offset < KZERO)
  645. return procctlmemio(p, offset, n, va, 1);
  646. if(!iseve())
  647. error(Eperm);
  648. /* validate kernel addresses */
  649. if(offset < (ulong)end) {
  650. if(offset+n > (ulong)end)
  651. n = (ulong)end - offset;
  652. memmove(a, (char*)offset, n);
  653. return n;
  654. }
  655. for(i=0; i<nelem(conf.mem); i++){
  656. cm = &conf.mem[i];
  657. /* klimit-1 because klimit might be zero! */
  658. if(cm->kbase <= offset && offset <= cm->klimit-1){
  659. if(offset+n >= cm->klimit-1)
  660. n = cm->klimit - offset;
  661. memmove(a, (char*)offset, n);
  662. return n;
  663. }
  664. }
  665. error(Ebadarg);
  666. case Qprofile:
  667. s = p->seg[TSEG];
  668. if(s == 0 || s->profile == 0)
  669. error("profile is off");
  670. i = (s->top-s->base)>>LRESPROF;
  671. i *= sizeof(*s->profile);
  672. if(offset >= i)
  673. return 0;
  674. if(offset+n > i)
  675. n = i - offset;
  676. memmove(a, ((char*)s->profile)+offset, n);
  677. return n;
  678. case Qnote:
  679. qlock(&p->debug);
  680. if(waserror()){
  681. qunlock(&p->debug);
  682. nexterror();
  683. }
  684. if(p->pid != PID(c->qid))
  685. error(Eprocdied);
  686. if(n < 1) /* must accept at least the '\0' */
  687. error(Etoosmall);
  688. if(p->nnote == 0)
  689. n = 0;
  690. else {
  691. m = strlen(p->note[0].msg) + 1;
  692. if(m > n)
  693. m = n;
  694. memmove(va, p->note[0].msg, m);
  695. ((char*)va)[m-1] = '\0';
  696. p->nnote--;
  697. memmove(p->note, p->note+1, p->nnote*sizeof(Note));
  698. n = m;
  699. }
  700. if(p->nnote == 0)
  701. p->notepending = 0;
  702. poperror();
  703. qunlock(&p->debug);
  704. return n;
  705. case Qproc:
  706. if(offset >= sizeof(Proc))
  707. return 0;
  708. if(offset+n > sizeof(Proc))
  709. n = sizeof(Proc) - offset;
  710. memmove(a, ((char*)p)+offset, n);
  711. return n;
  712. case Qregs:
  713. rptr = (uchar*)p->dbgreg;
  714. rsize = sizeof(Ureg);
  715. goto regread;
  716. case Qkregs:
  717. memset(&kur, 0, sizeof(Ureg));
  718. setkernur(&kur, p);
  719. rptr = (uchar*)&kur;
  720. rsize = sizeof(Ureg);
  721. goto regread;
  722. case Qfpregs:
  723. rptr = (uchar*)&p->fpsave;
  724. rsize = sizeof(FPsave);
  725. regread:
  726. if(rptr == 0)
  727. error(Enoreg);
  728. if(offset >= rsize)
  729. return 0;
  730. if(offset+n > rsize)
  731. n = rsize - offset;
  732. memmove(a, rptr+offset, n);
  733. return n;
  734. case Qstatus:
  735. if(offset >= STATSIZE)
  736. return 0;
  737. if(offset+n > STATSIZE)
  738. n = STATSIZE - offset;
  739. sps = p->psstate;
  740. if(sps == 0)
  741. sps = statename[p->state];
  742. memset(statbuf, ' ', sizeof statbuf);
  743. memmove(statbuf+0*KNAMELEN, p->text, strlen(p->text));
  744. memmove(statbuf+1*KNAMELEN, p->user, strlen(p->user));
  745. memmove(statbuf+2*KNAMELEN, sps, strlen(sps));
  746. j = 2*KNAMELEN + 12;
  747. for(i = 0; i < 6; i++) {
  748. l = p->time[i];
  749. if(i == TReal)
  750. l = MACHP(0)->ticks - l;
  751. l = TK2MS(l);
  752. readnum(0, statbuf+j+NUMSIZE*i, NUMSIZE, l, NUMSIZE);
  753. }
  754. /* ignore stack, which is mostly non-existent */
  755. l = 0;
  756. for(i=1; i<NSEG; i++){
  757. s = p->seg[i];
  758. if(s)
  759. l += s->top - s->base;
  760. }
  761. readnum(0, statbuf+j+NUMSIZE*6, NUMSIZE, l>>10, NUMSIZE);
  762. readnum(0, statbuf+j+NUMSIZE*7, NUMSIZE, p->basepri, NUMSIZE);
  763. readnum(0, statbuf+j+NUMSIZE*8, NUMSIZE, p->priority, NUMSIZE);
  764. memmove(a, statbuf+offset, n);
  765. return n;
  766. case Qsegment:
  767. j = 0;
  768. for(i = 0; i < NSEG; i++) {
  769. sg = p->seg[i];
  770. if(sg == 0)
  771. continue;
  772. j += sprint(statbuf+j, "%-6s %c%c %.8lux %.8lux %4ld\n",
  773. sname[sg->type&SG_TYPE],
  774. sg->type&SG_RONLY ? 'R' : ' ',
  775. sg->profile ? 'P' : ' ',
  776. sg->base, sg->top, sg->ref);
  777. }
  778. if(offset >= j)
  779. return 0;
  780. if(offset+n > j)
  781. n = j-offset;
  782. if(n == 0 && offset == 0)
  783. exhausted("segments");
  784. memmove(a, &statbuf[offset], n);
  785. return n;
  786. case Qwait:
  787. if(!canqlock(&p->qwaitr))
  788. error(Einuse);
  789. if(waserror()) {
  790. qunlock(&p->qwaitr);
  791. nexterror();
  792. }
  793. lock(&p->exl);
  794. if(up == p && p->nchild == 0 && p->waitq == 0) {
  795. unlock(&p->exl);
  796. error(Enochild);
  797. }
  798. pid = p->pid;
  799. while(p->waitq == 0) {
  800. unlock(&p->exl);
  801. sleep(&p->waitr, haswaitq, p);
  802. if(p->pid != pid)
  803. error(Eprocdied);
  804. lock(&p->exl);
  805. }
  806. wq = p->waitq;
  807. p->waitq = wq->next;
  808. p->nwait--;
  809. unlock(&p->exl);
  810. qunlock(&p->qwaitr);
  811. poperror();
  812. n = snprint(a, n, "%d %lud %lud %lud %q",
  813. wq->w.pid,
  814. wq->w.time[TUser], wq->w.time[TSys], wq->w.time[TReal],
  815. wq->w.msg);
  816. free(wq);
  817. return n;
  818. case Qns:
  819. qlock(&p->debug);
  820. if(waserror()){
  821. qunlock(&p->debug);
  822. nexterror();
  823. }
  824. if(p->pgrp == nil || p->pid != PID(c->qid))
  825. error(Eprocdied);
  826. mw = c->aux;
  827. if(mw->cddone){
  828. qunlock(&p->debug);
  829. poperror();
  830. return 0;
  831. }
  832. mntscan(mw, p);
  833. if(mw->mh == 0){
  834. mw->cddone = 1;
  835. i = snprint(a, n, "cd %s\n", p->dot->path->s);
  836. qunlock(&p->debug);
  837. poperror();
  838. return i;
  839. }
  840. int2flag(mw->cm->mflag, flag);
  841. if(strcmp(mw->cm->to->path->s, "#M") == 0){
  842. srv = srvname(mw->cm->to->mchan);
  843. i = snprint(a, n, "mount %s %s %s %s\n", flag,
  844. srv==nil? mw->cm->to->mchan->path->s : srv,
  845. mw->mh->from->path->s, mw->cm->spec? mw->cm->spec : "");
  846. free(srv);
  847. }else
  848. i = snprint(a, n, "bind %s %s %s\n", flag,
  849. mw->cm->to->path->s, mw->mh->from->path->s);
  850. qunlock(&p->debug);
  851. poperror();
  852. return i;
  853. case Qnoteid:
  854. return readnum(offset, va, n, p->noteid, NUMSIZE);
  855. case Qfd:
  856. return procfds(p, va, n, offset);
  857. }
  858. error(Egreg);
  859. return 0; /* not reached */
  860. }
  861. void
  862. mntscan(Mntwalk *mw, Proc *p)
  863. {
  864. Pgrp *pg;
  865. Mount *t;
  866. Mhead *f;
  867. int nxt, i;
  868. ulong last, bestmid;
  869. pg = p->pgrp;
  870. rlock(&pg->ns);
  871. nxt = 0;
  872. bestmid = ~0;
  873. last = 0;
  874. if(mw->mh)
  875. last = mw->cm->mountid;
  876. for(i = 0; i < MNTHASH; i++) {
  877. for(f = pg->mnthash[i]; f; f = f->hash) {
  878. for(t = f->mount; t; t = t->next) {
  879. if(mw->mh == 0 ||
  880. (t->mountid > last && t->mountid < bestmid)) {
  881. mw->cm = t;
  882. mw->mh = f;
  883. bestmid = mw->cm->mountid;
  884. nxt = 1;
  885. }
  886. }
  887. }
  888. }
  889. if(nxt == 0)
  890. mw->mh = 0;
  891. runlock(&pg->ns);
  892. }
  893. static long
  894. procwrite(Chan *c, void *va, long n, vlong off)
  895. {
  896. int id, m;
  897. Proc *p, *t, *et;
  898. char *a, *arg, buf[ERRMAX];
  899. ulong offset = off;
  900. a = va;
  901. if(c->qid.type & QTDIR)
  902. error(Eisdir);
  903. p = proctab(SLOT(c->qid));
  904. /* Use the remembered noteid in the channel rather
  905. * than the process pgrpid
  906. */
  907. if(QID(c->qid) == Qnotepg) {
  908. pgrpnote(NOTEID(c->pgrpid), va, n, NUser);
  909. return n;
  910. }
  911. qlock(&p->debug);
  912. if(waserror()){
  913. qunlock(&p->debug);
  914. nexterror();
  915. }
  916. if(p->pid != PID(c->qid))
  917. error(Eprocdied);
  918. switch(QID(c->qid)){
  919. case Qargs:
  920. if(n == 0)
  921. error(Eshort);
  922. if(n >= ERRMAX)
  923. error(Etoobig);
  924. arg = malloc(n+1);
  925. if(arg == nil)
  926. error(Enomem);
  927. memmove(arg, va, n);
  928. m = n;
  929. if(arg[m-1] != 0)
  930. arg[m++] = 0;
  931. free(p->args);
  932. p->nargs = m;
  933. p->args = arg;
  934. p->setargs = 1;
  935. break;
  936. case Qmem:
  937. if(p->state != Stopped)
  938. error(Ebadctl);
  939. n = procctlmemio(p, offset, n, va, 0);
  940. break;
  941. case Qregs:
  942. if(offset >= sizeof(Ureg))
  943. n = 0;
  944. else if(offset+n > sizeof(Ureg))
  945. n = sizeof(Ureg) - offset;
  946. if(p->dbgreg == 0)
  947. error(Enoreg);
  948. setregisters(p->dbgreg, (char*)(p->dbgreg)+offset, va, n);
  949. break;
  950. case Qfpregs:
  951. if(offset >= sizeof(FPsave))
  952. n = 0;
  953. else if(offset+n > sizeof(FPsave))
  954. n = sizeof(FPsave) - offset;
  955. memmove((uchar*)&p->fpsave+offset, va, n);
  956. break;
  957. case Qctl:
  958. procctlreq(p, va, n);
  959. break;
  960. case Qnote:
  961. if(p->kp)
  962. error(Eperm);
  963. if(n >= ERRMAX-1)
  964. error(Etoobig);
  965. memmove(buf, va, n);
  966. buf[n] = 0;
  967. if(!postnote(p, 0, buf, NUser))
  968. error("note not posted");
  969. break;
  970. case Qnoteid:
  971. id = atoi(a);
  972. if(id == p->pid) {
  973. p->noteid = id;
  974. break;
  975. }
  976. t = proctab(0);
  977. for(et = t+conf.nproc; t < et; t++) {
  978. if(t->state == Dead)
  979. continue;
  980. if(id == t->noteid) {
  981. if(strcmp(p->user, t->user) != 0)
  982. error(Eperm);
  983. p->noteid = id;
  984. break;
  985. }
  986. }
  987. if(p->noteid != id)
  988. error(Ebadarg);
  989. break;
  990. default:
  991. pprint("unknown qid in procwrite\n");
  992. error(Egreg);
  993. }
  994. poperror();
  995. qunlock(&p->debug);
  996. return n;
  997. }
  998. Dev procdevtab = {
  999. 'p',
  1000. "proc",
  1001. devreset,
  1002. procinit,
  1003. devshutdown,
  1004. procattach,
  1005. procwalk,
  1006. procstat,
  1007. procopen,
  1008. devcreate,
  1009. procclose,
  1010. procread,
  1011. devbread,
  1012. procwrite,
  1013. devbwrite,
  1014. devremove,
  1015. procwstat,
  1016. };
  1017. Chan*
  1018. proctext(Chan *c, Proc *p)
  1019. {
  1020. Chan *tc;
  1021. Image *i;
  1022. Segment *s;
  1023. s = p->seg[TSEG];
  1024. if(s == 0)
  1025. error(Enonexist);
  1026. if(p->state==Dead)
  1027. error(Eprocdied);
  1028. lock(s);
  1029. i = s->image;
  1030. if(i == 0) {
  1031. unlock(s);
  1032. error(Eprocdied);
  1033. }
  1034. unlock(s);
  1035. lock(i);
  1036. if(waserror()) {
  1037. unlock(i);
  1038. nexterror();
  1039. }
  1040. tc = i->c;
  1041. if(tc == 0)
  1042. error(Eprocdied);
  1043. if(incref(tc) == 1 || (tc->flag&COPEN) == 0 || tc->mode!=OREAD) {
  1044. cclose(tc);
  1045. error(Eprocdied);
  1046. }
  1047. if(p->pid != PID(c->qid))
  1048. error(Eprocdied);
  1049. unlock(i);
  1050. poperror();
  1051. return tc;
  1052. }
  1053. void
  1054. procstopwait(Proc *p, int ctl)
  1055. {
  1056. int pid;
  1057. if(p->pdbg)
  1058. error(Einuse);
  1059. if(procstopped(p) || p->state == Broken)
  1060. return;
  1061. if(ctl != 0)
  1062. p->procctl = ctl;
  1063. p->pdbg = up;
  1064. pid = p->pid;
  1065. qunlock(&p->debug);
  1066. up->psstate = "Stopwait";
  1067. if(waserror()) {
  1068. p->pdbg = 0;
  1069. qlock(&p->debug);
  1070. nexterror();
  1071. }
  1072. sleep(&up->sleep, procstopped, p);
  1073. poperror();
  1074. qlock(&p->debug);
  1075. if(p->pid != pid)
  1076. error(Eprocdied);
  1077. }
  1078. static void
  1079. procctlcloseone(Proc *p, Fgrp *f, int fd)
  1080. {
  1081. Chan *c;
  1082. c = f->fd[fd];
  1083. if(c == nil)
  1084. return;
  1085. f->fd[fd] = nil;
  1086. unlock(f);
  1087. qunlock(&p->debug);
  1088. cclose(c);
  1089. qlock(&p->debug);
  1090. lock(f);
  1091. }
  1092. void
  1093. procctlclosefiles(Proc *p, int all, int fd)
  1094. {
  1095. int i;
  1096. Fgrp *f;
  1097. f = p->fgrp;
  1098. if(f == nil)
  1099. error(Eprocdied);
  1100. lock(f);
  1101. f->ref++;
  1102. if(all)
  1103. for(i = 0; i < f->maxfd; i++)
  1104. procctlcloseone(p, f, i);
  1105. else
  1106. procctlcloseone(p, f, fd);
  1107. unlock(f);
  1108. closefgrp(f);
  1109. }
  1110. static char *
  1111. parsetime(vlong *rt, char *s)
  1112. {
  1113. uvlong ticks;
  1114. ulong l;
  1115. char *e, *p;
  1116. static int p10[] = {100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1};
  1117. if (s == nil)
  1118. return("missing value");
  1119. ticks=strtoul(s, &e, 10);
  1120. if (*e == '.'){
  1121. p = e+1;
  1122. l = strtoul(p, &e, 10);
  1123. if(e-p > nelem(p10))
  1124. return "too many digits after decimal point";
  1125. if(e-p == 0)
  1126. return "ill-formed number";
  1127. l *= p10[e-p-1];
  1128. }else
  1129. l = 0;
  1130. if (*e == '\0' || strcmp(e, "s") == 0){
  1131. ticks = 1000000000 * ticks + l;
  1132. }else if (strcmp(e, "ms") == 0){
  1133. ticks = 1000000 * ticks + l/1000;
  1134. }else if (strcmp(e, "µs") == 0 || strcmp(e, "us") == 0){
  1135. ticks = 1000 * ticks + l/1000000;
  1136. }else if (strcmp(e, "ns") != 0)
  1137. return "unrecognized unit";
  1138. *rt = ticks;
  1139. return nil;
  1140. }
  1141. void
  1142. procctlreq(Proc *p, char *va, int n)
  1143. {
  1144. Segment *s;
  1145. int npc, pri;
  1146. Cmdbuf *cb;
  1147. Cmdtab *ct;
  1148. vlong time;
  1149. char *e;
  1150. void (*pt)(Proc*, int, vlong);
  1151. if(p->kp) /* no ctl requests to kprocs */
  1152. error(Eperm);
  1153. cb = parsecmd(va, n);
  1154. if(waserror()){
  1155. free(cb);
  1156. nexterror();
  1157. }
  1158. ct = lookupcmd(cb, proccmd, nelem(proccmd));
  1159. switch(ct->index){
  1160. case CMclose:
  1161. procctlclosefiles(p, 0, atoi(cb->f[1]));
  1162. break;
  1163. case CMclosefiles:
  1164. procctlclosefiles(p, 1, 0);
  1165. break;
  1166. case CMhang:
  1167. p->hang = 1;
  1168. break;
  1169. case CMkill:
  1170. switch(p->state) {
  1171. case Broken:
  1172. unbreak(p);
  1173. break;
  1174. case Stopped:
  1175. p->procctl = Proc_exitme;
  1176. postnote(p, 0, "sys: killed", NExit);
  1177. ready(p);
  1178. break;
  1179. default:
  1180. p->procctl = Proc_exitme;
  1181. postnote(p, 0, "sys: killed", NExit);
  1182. }
  1183. break;
  1184. case CMnohang:
  1185. p->hang = 0;
  1186. break;
  1187. case CMnoswap:
  1188. p->noswap = 1;
  1189. break;
  1190. case CMpri:
  1191. pri = atoi(cb->f[1]);
  1192. if(pri > PriNormal && !iseve())
  1193. error(Eperm);
  1194. procpriority(p, pri, 0);
  1195. break;
  1196. case CMfixedpri:
  1197. pri = atoi(cb->f[1]);
  1198. if(pri > PriNormal && !iseve())
  1199. error(Eperm);
  1200. procpriority(p, pri, 1);
  1201. break;
  1202. case CMprivate:
  1203. p->privatemem = 1;
  1204. break;
  1205. case CMprofile:
  1206. s = p->seg[TSEG];
  1207. if(s == 0 || (s->type&SG_TYPE) != SG_TEXT)
  1208. error(Ebadctl);
  1209. if(s->profile != 0)
  1210. free(s->profile);
  1211. npc = (s->top-s->base)>>LRESPROF;
  1212. s->profile = malloc(npc*sizeof(*s->profile));
  1213. if(s->profile == 0)
  1214. error(Enomem);
  1215. break;
  1216. case CMstart:
  1217. if(p->state != Stopped)
  1218. error(Ebadctl);
  1219. ready(p);
  1220. break;
  1221. case CMstartstop:
  1222. if(p->state != Stopped)
  1223. error(Ebadctl);
  1224. p->procctl = Proc_traceme;
  1225. ready(p);
  1226. procstopwait(p, Proc_traceme);
  1227. break;
  1228. case CMstartsyscall:
  1229. if(p->state != Stopped)
  1230. error(Ebadctl);
  1231. p->procctl = Proc_tracesyscall;
  1232. ready(p);
  1233. procstopwait(p, Proc_tracesyscall);
  1234. break;
  1235. case CMstop:
  1236. procstopwait(p, Proc_stopme);
  1237. break;
  1238. case CMwaitstop:
  1239. procstopwait(p, 0);
  1240. break;
  1241. case CMwired:
  1242. procwired(p, atoi(cb->f[1]));
  1243. break;
  1244. case CMtrace:
  1245. switch(cb->nf){
  1246. case 1:
  1247. p->trace ^= 1;
  1248. break;
  1249. case 2:
  1250. p->trace = (atoi(cb->f[1]) != 0);
  1251. break;
  1252. default:
  1253. error("args");
  1254. }
  1255. break;
  1256. /* real time */
  1257. case CMperiod:
  1258. if(p->edf == nil)
  1259. edfinit(p);
  1260. if(e=parsetime(&time, cb->f[1])) /* time in ns */
  1261. error(e);
  1262. edfstop(p);
  1263. p->edf->T = time/1000; /* Edf times are in µs */
  1264. break;
  1265. case CMdeadline:
  1266. if(p->edf == nil)
  1267. edfinit(p);
  1268. if(e=parsetime(&time, cb->f[1]))
  1269. error(e);
  1270. edfstop(p);
  1271. p->edf->D = time/1000;
  1272. break;
  1273. case CMcost:
  1274. if(p->edf == nil)
  1275. edfinit(p);
  1276. if(e=parsetime(&time, cb->f[1]))
  1277. error(e);
  1278. edfstop(p);
  1279. p->edf->C = time/1000;
  1280. break;
  1281. case CMsporadic:
  1282. if(p->edf == nil)
  1283. edfinit(p);
  1284. p->edf->flags |= Sporadic;
  1285. break;
  1286. case CMdeadlinenotes:
  1287. if(p->edf == nil)
  1288. edfinit(p);
  1289. p->edf->flags |= Sendnotes;
  1290. break;
  1291. case CMadmit:
  1292. if(p->edf == 0)
  1293. error("edf params");
  1294. if(e = edfadmit(p))
  1295. error(e);
  1296. break;
  1297. case CMextra:
  1298. if(p->edf == nil)
  1299. edfinit(p);
  1300. p->edf->flags |= Extratime;
  1301. break;
  1302. case CMexpel:
  1303. if(p->edf)
  1304. edfstop(p);
  1305. break;
  1306. case CMevent:
  1307. pt = proctrace;
  1308. if(up->trace && pt)
  1309. pt(up, SUser, 0);
  1310. break;
  1311. }
  1312. poperror();
  1313. free(cb);
  1314. }
  1315. int
  1316. procstopped(void *a)
  1317. {
  1318. Proc *p = a;
  1319. return p->state == Stopped;
  1320. }
  1321. int
  1322. procctlmemio(Proc *p, ulong offset, int n, void *va, int read)
  1323. {
  1324. KMap *k;
  1325. Pte *pte;
  1326. Page *pg;
  1327. Segment *s;
  1328. ulong soff, l;
  1329. char *a = va, *b;
  1330. for(;;) {
  1331. s = seg(p, offset, 1);
  1332. if(s == 0)
  1333. error(Ebadarg);
  1334. if(offset+n >= s->top)
  1335. n = s->top-offset;
  1336. if(!read && (s->type&SG_TYPE) == SG_TEXT)
  1337. s = txt2data(p, s);
  1338. s->steal++;
  1339. soff = offset-s->base;
  1340. if(waserror()) {
  1341. s->steal--;
  1342. nexterror();
  1343. }
  1344. if(fixfault(s, offset, read, 0) == 0)
  1345. break;
  1346. poperror();
  1347. s->steal--;
  1348. }
  1349. poperror();
  1350. pte = s->map[soff/PTEMAPMEM];
  1351. if(pte == 0)
  1352. panic("procctlmemio");
  1353. pg = pte->pages[(soff&(PTEMAPMEM-1))/BY2PG];
  1354. if(pagedout(pg))
  1355. panic("procctlmemio1");
  1356. l = BY2PG - (offset&(BY2PG-1));
  1357. if(n > l)
  1358. n = l;
  1359. k = kmap(pg);
  1360. if(waserror()) {
  1361. s->steal--;
  1362. kunmap(k);
  1363. nexterror();
  1364. }
  1365. b = (char*)VA(k);
  1366. b += offset&(BY2PG-1);
  1367. if(read == 1)
  1368. memmove(a, b, n); /* This can fault */
  1369. else
  1370. memmove(b, a, n);
  1371. kunmap(k);
  1372. poperror();
  1373. /* Ensure the process sees text page changes */
  1374. if(s->flushme)
  1375. memset(pg->cachectl, PG_TXTFLUSH, sizeof(pg->cachectl));
  1376. s->steal--;
  1377. if(read == 0)
  1378. p->newtlb = 1;
  1379. return n;
  1380. }
  1381. Segment*
  1382. txt2data(Proc *p, Segment *s)
  1383. {
  1384. int i;
  1385. Segment *ps;
  1386. ps = newseg(SG_DATA, s->base, s->size);
  1387. ps->image = s->image;
  1388. incref(ps->image);
  1389. ps->fstart = s->fstart;
  1390. ps->flen = s->flen;
  1391. ps->flushme = 1;
  1392. qlock(&p->seglock);
  1393. for(i = 0; i < NSEG; i++)
  1394. if(p->seg[i] == s)
  1395. break;
  1396. if(p->seg[i] != s)
  1397. panic("segment gone");
  1398. qunlock(&s->lk);
  1399. putseg(s);
  1400. qlock(&ps->lk);
  1401. p->seg[i] = ps;
  1402. qunlock(&p->seglock);
  1403. return ps;
  1404. }
  1405. Segment*
  1406. data2txt(Segment *s)
  1407. {
  1408. Segment *ps;
  1409. ps = newseg(SG_TEXT, s->base, s->size);
  1410. ps->image = s->image;
  1411. incref(ps->image);
  1412. ps->fstart = s->fstart;
  1413. ps->flen = s->flen;
  1414. ps->flushme = 1;
  1415. return ps;
  1416. }