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