fault.c 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428
  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. int
  8. fault(ulong addr, int read)
  9. {
  10. Segment *s;
  11. char *sps;
  12. if(up == nil)
  13. panic("fault: nil up");
  14. if(up->nlocks.ref)
  15. print("fault: nlocks %ld\n", up->nlocks.ref);
  16. sps = up->psstate;
  17. up->psstate = "Fault";
  18. spllo();
  19. m->pfault++;
  20. for(;;) {
  21. s = seg(up, addr, 1); /* leaves s->lk qlocked if seg != nil */
  22. if(s == 0) {
  23. up->psstate = sps;
  24. return -1;
  25. }
  26. if(!read && (s->type&SG_RONLY)) {
  27. qunlock(&s->lk);
  28. up->psstate = sps;
  29. return -1;
  30. }
  31. if(fixfault(s, addr, read, 1) == 0)
  32. break;
  33. }
  34. up->psstate = sps;
  35. return 0;
  36. }
  37. static void
  38. faulterror(char *s, Chan *c, int freemem)
  39. {
  40. char buf[ERRMAX];
  41. if(c && c->path){
  42. snprint(buf, sizeof buf, "%s accessing %s: %s", s, c->path->s, up->errstr);
  43. s = buf;
  44. }
  45. if(up->nerrlab) {
  46. postnote(up, 1, s, NDebug);
  47. error(s);
  48. }
  49. pexit(s, freemem);
  50. }
  51. void (*checkaddr)(ulong, Segment *, Page *);
  52. ulong addr2check;
  53. int
  54. fixfault(Segment *s, ulong addr, int read, int doputmmu)
  55. {
  56. int type;
  57. int ref;
  58. Pte **p, *etp;
  59. ulong mmuphys=0, soff;
  60. Page **pg, *lkp, *new;
  61. Page *(*fn)(Segment*, ulong);
  62. addr &= ~(BY2PG-1);
  63. soff = addr-s->base;
  64. p = &s->map[soff/PTEMAPMEM];
  65. if(*p == 0)
  66. *p = ptealloc();
  67. etp = *p;
  68. pg = &etp->pages[(soff&(PTEMAPMEM-1))/BY2PG];
  69. type = s->type&SG_TYPE;
  70. if(pg < etp->first)
  71. etp->first = pg;
  72. if(pg > etp->last)
  73. etp->last = pg;
  74. switch(type) {
  75. default:
  76. panic("fault");
  77. break;
  78. case SG_TEXT: /* Demand load */
  79. if(pagedout(*pg))
  80. pio(s, addr, soff, pg);
  81. mmuphys = PPN((*pg)->pa) | PTERONLY|PTEVALID;
  82. (*pg)->modref = PG_REF;
  83. break;
  84. case SG_BSS:
  85. case SG_SHARED: /* Zero fill on demand */
  86. case SG_STACK:
  87. if(*pg == 0) {
  88. new = newpage(1, &s, addr);
  89. if(s == 0)
  90. return -1;
  91. *pg = new;
  92. }
  93. goto common;
  94. case SG_DATA:
  95. common: /* Demand load/pagein/copy on write */
  96. if(pagedout(*pg))
  97. pio(s, addr, soff, pg);
  98. /*
  99. * It's only possible to copy on write if
  100. * we're the only user of the segment.
  101. */
  102. if(read && conf.copymode == 0 && s->ref == 1) {
  103. mmuphys = PPN((*pg)->pa)|PTERONLY|PTEVALID;
  104. (*pg)->modref |= PG_REF;
  105. break;
  106. }
  107. lkp = *pg;
  108. lock(lkp);
  109. if(lkp->image == &swapimage)
  110. ref = lkp->ref + swapcount(lkp->daddr);
  111. else
  112. ref = lkp->ref;
  113. if(ref > 1) {
  114. unlock(lkp);
  115. if(swapfull()){
  116. qunlock(&s->lk);
  117. pprint("swap space full\n");
  118. faulterror(Enoswap, nil, 1);
  119. }
  120. new = newpage(0, &s, addr);
  121. if(s == 0)
  122. return -1;
  123. *pg = new;
  124. copypage(lkp, *pg);
  125. putpage(lkp);
  126. }
  127. else {
  128. /* save a copy of the original for the image cache */
  129. if(lkp->image && !swapfull())
  130. duppage(lkp);
  131. unlock(lkp);
  132. }
  133. mmuphys = PPN((*pg)->pa) | PTEWRITE | PTEVALID;
  134. (*pg)->modref = PG_MOD|PG_REF;
  135. break;
  136. case SG_PHYSICAL:
  137. if(*pg == 0) {
  138. fn = s->pseg->pgalloc;
  139. if(fn)
  140. *pg = (*fn)(s, addr);
  141. else {
  142. new = smalloc(sizeof(Page));
  143. new->va = addr;
  144. new->pa = s->pseg->pa+(addr-s->base);
  145. new->ref = 1;
  146. *pg = new;
  147. }
  148. }
  149. if (checkaddr && addr == addr2check)
  150. (*checkaddr)(addr, s, *pg);
  151. mmuphys = PPN((*pg)->pa) |PTEWRITE|PTEUNCACHED|PTEVALID;
  152. (*pg)->modref = PG_MOD|PG_REF;
  153. break;
  154. }
  155. qunlock(&s->lk);
  156. if(doputmmu)
  157. putmmu(addr, mmuphys, *pg);
  158. return 0;
  159. }
  160. void
  161. pio(Segment *s, ulong addr, ulong soff, Page **p)
  162. {
  163. Page *new;
  164. KMap *k;
  165. Chan *c;
  166. int n, ask;
  167. char *kaddr;
  168. ulong daddr;
  169. Page *loadrec;
  170. retry:
  171. loadrec = *p;
  172. if(loadrec == 0) { /* from a text/data image */
  173. daddr = s->fstart+soff;
  174. new = lookpage(s->image, daddr);
  175. if(new != nil) {
  176. *p = new;
  177. return;
  178. }
  179. }
  180. else { /* from a swap image */
  181. daddr = swapaddr(loadrec);
  182. new = lookpage(&swapimage, daddr);
  183. if(new != nil) {
  184. putswap(loadrec);
  185. *p = new;
  186. return;
  187. }
  188. }
  189. qunlock(&s->lk);
  190. new = newpage(0, 0, addr);
  191. k = kmap(new);
  192. kaddr = (char*)VA(k);
  193. if(loadrec == 0) { /* This is demand load */
  194. c = s->image->c;
  195. while(waserror()) {
  196. if(strcmp(up->errstr, Eintr) == 0)
  197. continue;
  198. kunmap(k);
  199. putpage(new);
  200. faulterror("sys: demand load I/O error", c, 0);
  201. }
  202. ask = s->flen-soff;
  203. if(ask > BY2PG)
  204. ask = BY2PG;
  205. n = devtab[c->type]->read(c, kaddr, ask, daddr);
  206. if(n != ask)
  207. faulterror(Eioload, c, 0);
  208. if(ask < BY2PG)
  209. memset(kaddr+ask, 0, BY2PG-ask);
  210. poperror();
  211. kunmap(k);
  212. qlock(&s->lk);
  213. /*
  214. * race, another proc may have gotten here first while
  215. * s->lk was unlocked
  216. */
  217. if(*p == 0) {
  218. new->daddr = daddr;
  219. cachepage(new, s->image);
  220. *p = new;
  221. }
  222. else
  223. putpage(new);
  224. }
  225. else { /* This is paged out */
  226. c = swapimage.c;
  227. if(waserror()) {
  228. kunmap(k);
  229. putpage(new);
  230. qlock(&s->lk);
  231. qunlock(&s->lk);
  232. faulterror("sys: page in I/O error", c, 0);
  233. }
  234. n = devtab[c->type]->read(c, kaddr, BY2PG, daddr);
  235. if(n != BY2PG)
  236. faulterror(Eioload, c, 0);
  237. poperror();
  238. kunmap(k);
  239. qlock(&s->lk);
  240. /*
  241. * race, another proc may have gotten here first
  242. * (and the pager may have run on that page) while
  243. * s->lk was unlocked
  244. */
  245. if(*p != loadrec){
  246. if(!pagedout(*p)){
  247. /* another process did it for me */
  248. putpage(new);
  249. goto done;
  250. } else {
  251. /* another process and the pager got in */
  252. putpage(new);
  253. goto retry;
  254. }
  255. }
  256. new->daddr = daddr;
  257. cachepage(new, &swapimage);
  258. *p = new;
  259. putswap(loadrec);
  260. }
  261. done:
  262. if(s->flushme)
  263. memset((*p)->cachectl, PG_TXTFLUSH, sizeof((*p)->cachectl));
  264. }
  265. /*
  266. * Called only in a system call
  267. */
  268. int
  269. okaddr(ulong addr, ulong len, int write)
  270. {
  271. Segment *s;
  272. if((long)len >= 0) {
  273. for(;;) {
  274. s = seg(up, addr, 0);
  275. if(s == 0 || (write && (s->type&SG_RONLY)))
  276. break;
  277. if(addr+len > s->top) {
  278. len -= s->top - addr;
  279. addr = s->top;
  280. continue;
  281. }
  282. return 1;
  283. }
  284. }
  285. pprint("suicide: invalid address %#lux/%lud in sys call pc=%#lux\n", addr, len, userpc());
  286. return 0;
  287. }
  288. void
  289. validaddr(ulong addr, ulong len, int write)
  290. {
  291. if(!okaddr(addr, len, write))
  292. pexit("Suicide", 0);
  293. }
  294. /*
  295. * &s[0] is known to be a valid address.
  296. */
  297. void*
  298. vmemchr(void *s, int c, int n)
  299. {
  300. int m;
  301. ulong a;
  302. void *t;
  303. a = (ulong)s;
  304. while(PGROUND(a) != PGROUND(a+n-1)){
  305. /* spans pages; handle this page */
  306. m = BY2PG - (a & (BY2PG-1));
  307. t = memchr((void*)a, c, m);
  308. if(t)
  309. return t;
  310. a += m;
  311. n -= m;
  312. if(a < KZERO)
  313. validaddr(a, 1, 0);
  314. }
  315. /* fits in one page */
  316. return memchr((void*)a, c, n);
  317. }
  318. Segment*
  319. seg(Proc *p, ulong addr, int dolock)
  320. {
  321. Segment **s, **et, *n;
  322. et = &p->seg[NSEG];
  323. for(s = p->seg; s < et; s++) {
  324. n = *s;
  325. if(n == 0)
  326. continue;
  327. if(addr >= n->base && addr < n->top) {
  328. if(dolock == 0)
  329. return n;
  330. qlock(&n->lk);
  331. if(addr >= n->base && addr < n->top)
  332. return n;
  333. qunlock(&n->lk);
  334. }
  335. }
  336. return 0;
  337. }
  338. extern void checkmmu(ulong, ulong);
  339. void
  340. checkpages(void)
  341. {
  342. int checked;
  343. ulong addr, off;
  344. Pte *p;
  345. Page *pg;
  346. Segment **sp, **ep, *s;
  347. if(up == nil)
  348. return;
  349. checked = 0;
  350. for(sp=up->seg, ep=&up->seg[NSEG]; sp<ep; sp++){
  351. s = *sp;
  352. if(s == nil)
  353. continue;
  354. qlock(&s->lk);
  355. for(addr=s->base; addr<s->top; addr+=BY2PG){
  356. off = addr - s->base;
  357. p = s->map[off/PTEMAPMEM];
  358. if(p == 0)
  359. continue;
  360. pg = p->pages[(off&(PTEMAPMEM-1))/BY2PG];
  361. if(pg == 0 || pagedout(pg))
  362. continue;
  363. checkmmu(addr, pg->pa);
  364. checked++;
  365. }
  366. qunlock(&s->lk);
  367. }
  368. print("%ld %s: checked %d page table entries\n", up->pid, up->text, checked);
  369. }