![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vmpage.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / lsys / vm|
Return to vmpage.c CVS log | Up to [Research Unix] / researchv10dc / lsys / vm |
1.1 ! root 1: /* vmpage.c 4.16 81/05/12 */ ! 2: ! 3: #include "sys/param.h" ! 4: #include "sys/systm.h" ! 5: #include "sys/inode.h" ! 6: #include "sys/user.h" ! 7: #include "sys/proc.h" ! 8: #include "sys/pte.h" ! 9: #include "sys/buf.h" ! 10: #include "sys/text.h" ! 11: #include "sys/mtpr.h" ! 12: #include "sys/cmap.h" ! 13: #include "sys/vm.h" ! 14: #include "sys/file.h" ! 15: ! 16: struct pte *Pushmap; ! 17: struct user *pushutl; ! 18: ! 19: int nohash = 0; ! 20: /* ! 21: * Handle a page fault. ! 22: * ! 23: * Basic outline ! 24: * If page is allocated, but just not valid: ! 25: * Wait if intransit, else just revalidate ! 26: * Done ! 27: * Compute <dev,bn> from which page operation would take place ! 28: * If page is text page, and filling from file system or swap space: ! 29: * If in free list cache, reattach it and then done ! 30: * Allocate memory for page in ! 31: * If block here, restart because we could have swapped, etc. ! 32: * Lock process from swapping for duration ! 33: * Update pte's to reflect that page is intransit. ! 34: * If page is zero fill on demand: ! 35: * Clear pages and flush free list cache of stale cacheing ! 36: * for this swap page (e.g. before initializing again due ! 37: * to 407/410 exec). ! 38: * If page is fill from file and in buffer cache: ! 39: * Copy the page from the buffer cache. ! 40: * If not a fill on demand: ! 41: * Determine swap address and cluster to page in ! 42: * Do the swap to bring the page in ! 43: * Instrument the pagein ! 44: * After swap validate the required new page ! 45: * Leave prepaged pages reclaimable (not valid) ! 46: * Update shared copies of text page tables ! 47: * Complete bookkeeping on pages brought in: ! 48: * No longer intransit ! 49: * Hash text pages into core hash structure ! 50: * Unlock pages (modulo raw i/o requirements) ! 51: * Flush translation buffer ! 52: * Process pagein is done ! 53: */ ! 54: int preptofree = 1; /* send pre-paged pages to free list */ ! 55: static struct cmap dbcmap; /* debug */ ! 56: ! 57: pagein(virtaddr,uu) ! 58: caddr_t virtaddr; ! 59: register struct user *uu; ! 60: { ! 61: register struct proc *p; ! 62: register struct pte *pte; ! 63: register struct inode *ip; ! 64: register unsigned v; ! 65: unsigned pf; ! 66: int type, fileno, prot; ! 67: struct pte opte; ! 68: struct buf *bp; ! 69: dev_t dev; ! 70: register int i; ! 71: int klsize; ! 72: unsigned vsave; ! 73: struct cmap *c; ! 74: int j; ! 75: daddr_t bn, bncache, bnswap; ! 76: int otime, olbolt, oicr, a, s; ! 77: ! 78: s = spl6(); ! 79: otime = time, olbolt = lbolt, oicr = mfpr(ICR); ! 80: cnt.v_faults++; ! 81: /* ! 82: * Classify faulted page into a segment and get a pte ! 83: * for the faulted page. ! 84: */ ! 85: vsave = v = clbase(btop((unsigned int)virtaddr)); ! 86: p = uu->u_procp; ! 87: if (isatsv(p, v)) ! 88: type = CTEXT; ! 89: else if (isassv(p, v)) ! 90: type = CSTACK; ! 91: else ! 92: type = CDATA; ! 93: pte = vtopte(p, v); ! 94: if (pte->pg_v) ! 95: panic("pagein"); ! 96: ! 97: /* ! 98: * If page is reclaimable, reclaim it. ! 99: * If page is text and intransit, sleep while it is intransit, ! 100: * If it is valid after the sleep, we are done. ! 101: * Otherwise we have to start checking again, since page could ! 102: * even be reclaimable now (we may have swapped for a long time). ! 103: */ ! 104: restart: ! 105: if (pte->pg_fod == 0 && pte->pg_pfnum) { ! 106: if (type == CTEXT && cmap[pgtocm(pte->pg_pfnum)].c_intrans) { ! 107: sleep((caddr_t)p->p_textp, PSWP+1); ! 108: pte = vtopte(p, v); ! 109: if (pte->pg_v) { ! 110: valid: ! 111: if (p->p_flag & SDLYU) { ! 112: mlock(pte->pg_pfnum); ! 113: if (!pte->pg_v) { ! 114: munlock(pte->pg_pfnum); ! 115: goto restart; ! 116: } ! 117: } ! 118: tbiscl(v); ! 119: cnt.v_intrans++; ! 120: return; ! 121: } ! 122: goto restart; ! 123: } ! 124: /* ! 125: * If page is in the free list, then take ! 126: * it back into the resident set, updating ! 127: * the size recorded for the resident set. ! 128: */ ! 129: if (cmap[pgtocm(pte->pg_pfnum)].c_free) { ! 130: munlink(pte->pg_pfnum); ! 131: cnt.v_pgfrec++; ! 132: if (type == CTEXT) ! 133: p->p_textp->x_rssize += CLSIZE; ! 134: else ! 135: p->p_rssize += CLSIZE; ! 136: } ! 137: pte->pg_v = 1; ! 138: if (anycl(pte, pg_m)) ! 139: pte->pg_m = 1; ! 140: distcl(pte); ! 141: if (type == CTEXT) ! 142: distpte(p->p_textp, vtotp(p, v), pte); ! 143: if (p->p_flag & SDLYU) { ! 144: mlock(pte->pg_pfnum); ! 145: if (!pte->pg_v) { ! 146: munlock(pte->pg_pfnum); ! 147: goto restart; ! 148: } ! 149: } ! 150: uu->u_vm.vm_minflt++; ! 151: cnt.v_pgrec++; ! 152: tbiscl(v); ! 153: a = vmtime(otime, olbolt, oicr); ! 154: rectime += a; ! 155: if (a >= 0) ! 156: vmfltmon(rmon, a, rmonmin, rres, NRMON); ! 157: splx(s); ! 158: return; ! 159: } ! 160: splx(s); ! 161: /* ! 162: * <dev,bn> is where data comes from/goes to. ! 163: * <dev,bncache> is where data is cached from/to. ! 164: * <swapdev,bnswap> is where data will eventually go. ! 165: */ ! 166: if (pte->pg_fod == 0) { ! 167: fileno = -1; ! 168: bnswap = bncache = bn = dbtofsb(swapdev, ! 169: vtod(p, v, &uu->u_dmap, &uu->u_smap)); ! 170: dev = swapdev; ! 171: } else { ! 172: fileno = ((struct fpte *)pte)->pg_source + PG_FMIN; ! 173: bn = ((struct fpte *)pte)->pg_blkno; ! 174: bnswap = dbtofsb(swapdev, vtod(p, v, &uu->u_dmap, &uu->u_smap)); ! 175: if (fileno > PG_FMAX) ! 176: panic("pagein pg_source"); ! 177: if (fileno == PG_FTEXT) { ! 178: if (p->p_textp == 0) ! 179: panic("pagein PG_FTEXT"); ! 180: dev = p->p_textp->x_iptr->i_dev; ! 181: bncache = bn; ! 182: } else if (fileno == PG_FZERO) { ! 183: dev = swapdev; ! 184: bncache = bnswap; ! 185: } else { ! 186: if (uu->u_ofile[fileno] == NULL) ! 187: panic("pagein uu->u_ofile"); ! 188: ip = uu->u_ofile[fileno]->f_inode; ! 189: dev = ip->i_dev; ! 190: } ! 191: } ! 192: klsize = 1; ! 193: opte = *pte; ! 194: ! 195: /* ! 196: * Check for text detached but in free list. ! 197: * This can happen only if the page is filling ! 198: * from a inode or from the swap device, (e.g. not when reading ! 199: * in 407/410 execs to a zero fill page.) ! 200: * honour lock bit to avoid race with pageout ! 201: */ ! 202: if (type == CTEXT && fileno != PG_FZERO && !nohash) { ! 203: while ((c = mfind(getfsx(dev), bncache)) != 0) { ! 204: pf = cmtopg(c - cmap); ! 205: if (c->c_lock == 0) ! 206: break; ! 207: mlock(pf); ! 208: munlock(pf); ! 209: } ! 210: if (c) { ! 211: dbcmap = *c; ! 212: if (c->c_type != CTEXT || c->c_gone == 0 || ! 213: c->c_free == 0) ! 214: panic("pagein mfind"); ! 215: p->p_textp->x_rssize += CLSIZE; ! 216: /* ! 217: * Following code mimics memall(). ! 218: */ ! 219: pf = cmtopg(c - cmap); ! 220: munlink(pf); ! 221: for (j = 0; j < CLSIZE; j++) { ! 222: *(int *)pte = pf++; ! 223: pte->pg_prot = opte.pg_prot; ! 224: pte++; ! 225: } ! 226: pte -= CLSIZE; ! 227: c->c_free = 0; ! 228: c->c_gone = 0; ! 229: if (c->c_intrans || c->c_want) ! 230: panic("pagein intrans|want"); ! 231: c->c_lock = 1; ! 232: if (c->c_page != vtotp(p, v)) ! 233: panic("pagein c_page chgd"); ! 234: c->c_ndx = p->p_textp - &text[0]; ! 235: if (dev == swapdev) ! 236: cnt.v_xsfrec++; ! 237: else ! 238: cnt.v_xifrec++; ! 239: cnt.v_pgrec++; ! 240: uu->u_vm.vm_minflt++; ! 241: if (dev != swapdev) { ! 242: c = mfind(MSWAPX, bnswap); ! 243: if (c) ! 244: munhash(MSWAPX, bnswap); ! 245: pte->pg_swapm = 1; ! 246: } ! 247: goto skipswap; ! 248: } ! 249: } ! 250: ! 251: /* ! 252: * Wasn't reclaimable or reattachable. ! 253: * Have to prepare to bring the page in. ! 254: * We allocate the page before locking so we will ! 255: * be swappable if there is no free memory. ! 256: * If we block we have to start over, since anything ! 257: * could have happened. ! 258: */ ! 259: if (freemem < CLSIZE * KLMAX) { ! 260: while (freemem < CLSIZE * KLMAX) ! 261: sleep((caddr_t)&freemem, PSWP+2); ! 262: pte = vtopte(p, v); ! 263: if (pte->pg_v) ! 264: goto valid; ! 265: goto restart; ! 266: } ! 267: ! 268: /* ! 269: * Now can get memory and committed to bringing in the page. ! 270: * Lock this process, get a page, ! 271: * construct the new pte, and increment ! 272: * the (process or text) resident set size. ! 273: */ ! 274: p->p_flag |= SPAGE; ! 275: (void) memall(pte, CLSIZE, p, type); ! 276: pte->pg_prot = opte.pg_prot; ! 277: pf = pte->pg_pfnum; ! 278: cmap[pgtocm(pf)].c_intrans = 1; ! 279: distcl(pte); ! 280: if (type == CTEXT) { ! 281: p->p_textp->x_rssize += CLSIZE; ! 282: distpte(p->p_textp, vtotp(p, v), pte); ! 283: } else ! 284: p->p_rssize += CLSIZE; ! 285: ! 286: /* ! 287: * Two cases: either fill on demand (zero or text) ! 288: * or from swap space. ! 289: */ ! 290: if (opte.pg_fod) { ! 291: pte->pg_swapm = 1; ! 292: if (fileno == PG_FZERO || fileno == PG_FTEXT) { ! 293: /* ! 294: * Flush any previous text page use of this ! 295: * swap device block. ! 296: */ ! 297: if (type == CTEXT) { ! 298: c = mfind(MSWAPX, bnswap); ! 299: if (c) ! 300: munhash(MSWAPX, bnswap); ! 301: } ! 302: /* ! 303: * If zero fill, short-circuit hard work ! 304: * by just clearing pages. ! 305: */ ! 306: if (fileno == PG_FZERO) { ! 307: for (i = 0; i < CLSIZE; i++) ! 308: clearseg(pf+i); ! 309: if (type != CTEXT) ! 310: cnt.v_zfod += CLSIZE; ! 311: goto skipswap; ! 312: } ! 313: cnt.v_exfod += CLSIZE; ! 314: } else ! 315: /* ! 316: * Vreading block... whoops ! 317: */ ! 318: panic("pagein, vrpages ref'd"); ! 319: /* ! 320: * Check that block is not in file system buffer cache. ! 321: * The way the cache is handled now, this ! 322: * happens only once every 2 days. ! 323: */ ! 324: if (bp = baddr(dev, bn)) { ! 325: pte->pg_v = 1; ! 326: prot = *(int *)pte & PG_PROT; ! 327: pte->pg_prot = 0; ! 328: *(int *)pte |= PG_UW; ! 329: distcl(pte); ! 330: tbiscl(v); ! 331: /* THIS ASSUMES THAT CLSIZE*NBPG==BSIZE */ ! 332: bcopy(bp->b_un.b_addr, ptob(v), BSIZE(dev)); ! 333: brelse(bp); ! 334: pte->pg_prot = 0; ! 335: *(int *)pte |= prot; ! 336: goto skipswap; ! 337: } ! 338: } else { ! 339: if (opte.pg_pfnum) ! 340: panic("pagein pfnum"); ! 341: /* ! 342: * Fill from swap area. Try to find adjacent ! 343: * pages to bring in also. ! 344: */ ! 345: v = kluster(p, v, pte, B_READ, &klsize, ! 346: (type == CTEXT) ? kltxt : ! 347: ((p->p_flag & SSEQL) ? klseql : klin), bn); ! 348: /* THIS COULD BE COMPUTED INCREMENTALLY... */ ! 349: bncache = bn = dbtofsb(swapdev, vtod(p, v, &uu->u_dmap, &uu->u_smap)); ! 350: pte->pg_vreadm = opte.pg_vreadm; ! 351: } ! 352: ! 353: distcl(pte); ! 354: swap(p, fsbtodb(dev, bn), ptob(v), klsize * ctob(CLSIZE), ! 355: B_READ, B_PGIN, dev, 0); ! 356: ! 357: /* ! 358: * Instrumentation. ! 359: */ ! 360: uu->u_vm.vm_majflt++; ! 361: cnt.v_pgin++; ! 362: cnt.v_pgpgin += klsize * CLSIZE; ! 363: a = vmtime(otime, olbolt, oicr) / 100; ! 364: pgintime += a; ! 365: if (a >= 0) ! 366: vmfltmon(pmon, a, pmonmin, pres, NPMON); ! 367: ! 368: skipswap: ! 369: /* ! 370: * Fix page table entries. ! 371: * ! 372: * Only page requested in is validated, and rest of pages ! 373: * can be ``reclaimed''. This allows system to reclaim prepaged pages ! 374: * quickly if they are not used and memory is tight. ! 375: */ ! 376: pte = vtopte(p, vsave); ! 377: pte->pg_v = 1; ! 378: distcl(pte); ! 379: if (type == CTEXT) { ! 380: distpte(p->p_textp, vtotp(p, vsave), pte); ! 381: if (opte.pg_fod) ! 382: p->p_textp->x_flag |= XWRIT; ! 383: wakeup((caddr_t)p->p_textp); ! 384: } ! 385: ! 386: /* ! 387: * Memall returned page(s) locked. Unlock all ! 388: * pages in cluster. If locking pages for raw i/o ! 389: * leave the page which was required to be paged in locked, ! 390: * but still unlock others. ! 391: * If text pages, hash into the cmap situation table. ! 392: */ ! 393: pte = vtopte(p, v); ! 394: for (i = 0; i < klsize; i++) { ! 395: c = &cmap[pgtocm(pte->pg_pfnum)]; ! 396: c->c_intrans = 0; ! 397: if (type == CTEXT && c->c_blkno == 0 && bncache && !nohash) { ! 398: mhash(c, getfsx(dev), bncache); ! 399: bncache++; ! 400: } ! 401: if (v != vsave || (p->p_flag & SDLYU) == 0) ! 402: munlock(pte->pg_pfnum); ! 403: if (v != vsave && type != CTEXT && preptofree) { ! 404: /* ! 405: * Throw pre-paged data/stack pages at the ! 406: * bottom of the free list. ! 407: */ ! 408: p->p_rssize -= CLSIZE; ! 409: memfree(pte, CLSIZE, 0); ! 410: } ! 411: tbiscl(v); /* conservative ? */ ! 412: v += CLSIZE; ! 413: pte += CLSIZE; ! 414: } ! 415: ! 416: /* ! 417: * All done. ! 418: */ ! 419: p->p_flag &= ~SPAGE; ! 420: if (p->p_flag & SPROCWT) { ! 421: register s = spl6(); ! 422: p->p_flag &= ~SPROCWT; ! 423: p->p_usrpri = 127; ! 424: wakeup((caddr_t)&(p->p_stat)); ! 425: ++runrun; ! 426: splx(s); ! 427: } ! 428: ! 429: /* ! 430: * If process is declared fifo, memory is tight, ! 431: * and this was a data page-in, free memory ! 432: * klsdist pagein clusters away from the current fault. ! 433: */ ! 434: if ((p->p_flag&SSEQL) && freemem < lotsfree && ! 435: type == CDATA && p == u.u_procp) { ! 436: int k = (vtodp(p, vsave) / CLSIZE) / klseql; ! 437: #ifdef notdef ! 438: if (vsave > uu->u_vsave) ! 439: k -= klsdist; ! 440: else ! 441: k += klsdist; ! 442: dpageout(p, k * klseql * CLSIZE, klout*CLSIZE); ! 443: uu->u_vsave = vsave; ! 444: #else ! 445: dpageout(p, (k - klsdist) * klseql * CLSIZE, klout*CLSIZE); ! 446: dpageout(p, (k + klsdist) * klseql * CLSIZE, klout*CLSIZE); ! 447: #endif ! 448: } ! 449: } ! 450: ! 451: #if defined(BERT) ! 452: int dmod = 1000000; ! 453: int dcnt; ! 454: #endif ! 455: /* ! 456: * Take away n pages of data space ! 457: * starting at data page dp. ! 458: * Used to take pages away from sequential processes. ! 459: * Mimics pieces of code in pageout() below. ! 460: */ ! 461: dpageout(p, dp, n) ! 462: struct proc *p; ! 463: int dp, n; ! 464: { ! 465: register struct cmap *c; ! 466: int i, klsize; ! 467: register struct pte *pte; ! 468: unsigned v; ! 469: daddr_t daddr; ! 470: ! 471: if (dp < 0) { ! 472: n += dp; ! 473: dp = 0; ! 474: } ! 475: if (dp + n > p->p_dsize) ! 476: n = p->p_dsize - dp; ! 477: #if defined(BERT) ! 478: if (++dcnt % dmod == 0) ! 479: printf("dp %d, n %d\n", dp, n); ! 480: #endif ! 481: for (i = 0; i < n; i += CLSIZE, dp += CLSIZE) { ! 482: pte = dptopte(p, dp); ! 483: if (pte->pg_fod || pte->pg_pfnum == 0) ! 484: continue; ! 485: c = &cmap[pgtocm(pte->pg_pfnum)]; ! 486: if (c->c_lock || c->c_free) ! 487: continue; ! 488: if (pte->pg_v) { ! 489: pte->pg_v = 0; ! 490: if (anycl(pte, pg_m)) ! 491: pte->pg_m = 1; ! 492: distcl(pte); ! 493: } ! 494: if (dirtycl(pte)) { ! 495: if (bswlist.av_forw == NULL) ! 496: continue; ! 497: mlock(pte->pg_pfnum); ! 498: if (anycl(pte, pg_m)) { ! 499: pte->pg_vreadm = 1; ! 500: pte->pg_m = 0; ! 501: } ! 502: pte->pg_swapm = 0; ! 503: distcl(pte); ! 504: p->p_poip++; ! 505: v = kluster(p, dptov(p, dp), pte, B_WRITE, ! 506: &klsize, klout, (daddr_t)0); ! 507: /* THIS ASSUMES THAT p == u.u_procp */ ! 508: daddr = vtod(p, v, &u.u_dmap, &u.u_smap); ! 509: swap(p, daddr, ptob(v), klsize * ctob(CLSIZE), ! 510: B_WRITE, B_DIRTY, swapdev, pte->pg_pfnum); ! 511: } else { ! 512: if (c->c_gone == 0) ! 513: p->p_rssize -= CLSIZE; ! 514: memfree(pte, CLSIZE, 0); ! 515: cnt.v_seqfree += CLSIZE; ! 516: } ! 517: } ! 518: } ! 519: ! 520: int fifo = 0; ! 521: /* ! 522: * The page out daemon, which runs as process 2. ! 523: * ! 524: * As long as there are at least lotsfree pages, ! 525: * this process is not run. When the number of free ! 526: * pages stays in the range desfree to lotsfree, ! 527: * this daemon runs through the pages in the loop ! 528: * at a rate determined in vmsched(), simulating the missing ! 529: * hardware reference bit, and cleaning pages and transferring ! 530: * them to the free list. ! 531: */ ! 532: int hand; ! 533: pageout() ! 534: { ! 535: register struct proc *rp; ! 536: register struct text *xp; ! 537: register struct cmap *c; ! 538: register struct pte *pte; ! 539: int count, pushes; ! 540: swblk_t daddr; ! 541: unsigned v; ! 542: int maxhand = pgtocm(maxfree); ! 543: int klsize; ! 544: ! 545: loop: ! 546: /* ! 547: * Before sleeping, look to see if there are any swap I/O headers ! 548: * in the ``cleaned'' list that correspond to dirty ! 549: * pages that have been pushed asynchronously. If so, ! 550: * empty the list by calling cleanup(). ! 551: * ! 552: * N.B.: We guarantee never to block while the cleaned list is nonempty. ! 553: */ ! 554: (void) spl6(); ! 555: if (bclnlist != NULL) ! 556: cleanup(); ! 557: sleep((caddr_t)&proc[PAGEPID], PSWP+1); ! 558: (void) spl0(); ! 559: count = 0; ! 560: pushes = 0; ! 561: while (nscan < desscan && freemem < lotsfree) { ! 562: top: ! 563: /* ! 564: * An iteration of the clock pointer (hand) around the loop. ! 565: * Look at the page at hand. If it is a ! 566: * locked (for physical i/o e.g.), system (u., page table) ! 567: * or free, then leave it alone. ! 568: * Otherwise, find a process and text pointer for the ! 569: * page, and a virtual page number in either the ! 570: * process or the text image. ! 571: */ ! 572: c = &cmap[hand]; ! 573: if (c->c_lock || c->c_free) ! 574: goto skip; ! 575: switch (c->c_type) { ! 576: ! 577: case CSYS: ! 578: goto skip; ! 579: ! 580: case CTEXT: ! 581: xp = &text[c->c_ndx]; ! 582: rp = xp->x_caddr; ! 583: v = tptov(rp, c->c_page); ! 584: pte = tptopte(rp, c->c_page); ! 585: break; ! 586: ! 587: case CDATA: ! 588: case CSTACK: ! 589: rp = &proc[c->c_ndx]; ! 590: xp = rp->p_textp; ! 591: if (c->c_type == CDATA) { ! 592: v = dptov(rp, c->c_page); ! 593: pte = dptopte(rp, c->c_page); ! 594: } else { ! 595: v = sptov(rp, c->c_page); ! 596: pte = sptopte(rp, c->c_page); ! 597: } ! 598: break; ! 599: } ! 600: if (pte->pg_pfnum != cmtopg(hand)) ! 601: panic("bad c_page"); ! 602: /* ! 603: * If page is valid; make invalid but reclaimable. ! 604: * If this pte is not valid, then it must be reclaimable ! 605: * and we can add it to the free list. ! 606: */ ! 607: if (pte->pg_v) { ! 608: pte->pg_v = 0; ! 609: if (anycl(pte, pg_m)) ! 610: pte->pg_m = 1; ! 611: distcl(pte); ! 612: if (c->c_type == CTEXT) ! 613: distpte(xp, vtotp(rp, v), pte); ! 614: if ((rp->p_flag & (SSEQL|SUANOM)) || fifo || ! 615: rp->p_rssize > rp->p_maxrss) ! 616: goto take; ! 617: } else { ! 618: take: ! 619: if (c->c_type != CTEXT) { ! 620: /* ! 621: * Guarantee a minimal investment in data ! 622: * space for jobs in balance set. ! 623: */ ! 624: if (rp->p_rssize < saferss - rp->p_slptime) ! 625: goto skip; ! 626: } ! 627: ! 628: /* ! 629: * If the page is currently dirty, we ! 630: * have to arrange to have it cleaned before it ! 631: * can be freed. We mark it clean immediately. ! 632: * If it is reclaimed while being pushed, then modified ! 633: * again, we are assured of the correct order of ! 634: * writes because we lock the page during the write. ! 635: * This guarantees that a swap() of this process (and ! 636: * thus this page), initiated in parallel, will, ! 637: * in fact, push the page after us. ! 638: * ! 639: * The most general worst case here would be for ! 640: * a reclaim, a modify and a swapout to occur ! 641: * all before the single page transfer completes. ! 642: */ ! 643: if (dirtycl(pte)) { ! 644: /* ! 645: * Limit pushes to avoid saturating ! 646: * pageout device. ! 647: * ! 648: * MAGIC 4 BECAUSE WE RUN EVERY 1/4 SEC (clock) ! 649: */ ! 650: if (pushes > maxpgio / 4) ! 651: goto skip; ! 652: pushes++; ! 653: /* ! 654: * If the process is being swapped out ! 655: * or about to exit, do not bother with its ! 656: * dirty pages ! 657: */ ! 658: if (rp->p_flag & (SLOCK|SWEXIT)) ! 659: goto skip; ! 660: ! 661: /* ! 662: * Now carefully make sure that there will ! 663: * be a header available for the push so that ! 664: * we will not block waiting for a header in ! 665: * swap(). The reason this is important is ! 666: * that we (proc[PAGEPID]) are the one who cleans ! 667: * dirty swap headers and we could otherwise ! 668: * deadlock waiting for ourselves to clean ! 669: * swap headers. The sleep here on &proc[PAGEPID] ! 670: * is actually (effectively) a sleep on both ! 671: * ourselves and &bswlist, and this is known ! 672: * to iodone and swap in bio.c. That is, ! 673: * &proc[PAGEPID] will be awakened both when dirty ! 674: * headers show up and also to get the pageout ! 675: * daemon moving. ! 676: */ ! 677: (void) spl6(); ! 678: if (bclnlist != NULL) ! 679: cleanup(); ! 680: if (bswlist.av_forw == NULL) { ! 681: bswlist.b_flags |= B_WANTED; ! 682: sleep((caddr_t)&proc[PAGEPID], PSWP+2); ! 683: (void) spl0(); ! 684: /* ! 685: * Page disposition may have changed ! 686: * since process may have exec'ed, ! 687: * forked, exited or just about ! 688: * anything else... try this page ! 689: * frame again, from the top. ! 690: */ ! 691: goto top; ! 692: } ! 693: (void) spl0(); ! 694: ! 695: mlock((unsigned)cmtopg(hand)); ! 696: uaccess(rp, Pushmap, pushutl); ! 697: /* ! 698: * Now committed to pushing the page... ! 699: */ ! 700: if (anycl(pte, pg_m)) { ! 701: pte->pg_vreadm = 1; ! 702: pte->pg_m = 0; ! 703: } ! 704: pte->pg_swapm = 0; ! 705: distcl(pte); ! 706: if (c->c_type == CTEXT) { ! 707: xp->x_poip++; ! 708: distpte(xp, vtotp(rp, v), pte); ! 709: } else ! 710: rp->p_poip++; ! 711: v = kluster(rp, v, pte, B_WRITE, &klsize, klout, (daddr_t)0); ! 712: if (klsize == 0) ! 713: panic("pageout klsize"); ! 714: daddr = vtod(rp, v, &pushutl->u_dmap, &pushutl->u_smap); ! 715: swap(rp, daddr, ptob(v), klsize * ctob(CLSIZE), ! 716: B_WRITE, B_DIRTY, swapdev, pte->pg_pfnum); ! 717: /* ! 718: * The cleaning of this page will be ! 719: * completed later, in cleanup() called ! 720: * (synchronously) by us (proc[PAGEPID]). In ! 721: * the meantime, the page frame is locked ! 722: * so no havoc can result. ! 723: */ ! 724: goto skip; ! 725: ! 726: } ! 727: /* ! 728: * Decrement the resident set size of the current ! 729: * text object/process, and put the page in the ! 730: * free list. Note that we don't give memfree the ! 731: * pte as its argument, since we don't want to destroy ! 732: * the pte. If it hasn't already been discarded ! 733: * it may yet have a chance to be reclaimed from ! 734: * the free list. ! 735: */ ! 736: if (c->c_gone == 0) ! 737: if (c->c_type == CTEXT) ! 738: xp->x_rssize -= CLSIZE; ! 739: else ! 740: rp->p_rssize -= CLSIZE; ! 741: memfree(pte, CLSIZE, 0); ! 742: cnt.v_dfree += CLSIZE; ! 743: ! 744: /* ! 745: * We managed to add a page to the free list, ! 746: * so we give ourselves another couple of trips ! 747: * around the loop. ! 748: */ ! 749: count = 0; ! 750: } ! 751: skip: ! 752: cnt.v_scan++; ! 753: nscan++; ! 754: if (++hand >= maxhand) { ! 755: hand = 0; ! 756: cnt.v_rev++; ! 757: if (count > 2) { ! 758: /* ! 759: * Extremely unlikely, but we went around ! 760: * the loop twice and didn't get anywhere. ! 761: * Don't cycle, stop till the next clock tick. ! 762: */ ! 763: goto loop; ! 764: } ! 765: count++; ! 766: } ! 767: } ! 768: goto loop; ! 769: } ! 770: ! 771: /* ! 772: * Process the ``cleaned'' list. ! 773: * ! 774: * Scan through the linked list of swap I/O headers ! 775: * and free the corresponding pages that have been ! 776: * cleaned by being written back to the paging area. ! 777: * If the page has been reclaimed during this time, ! 778: * we do not free the page. As they are processed, ! 779: * the swap I/O headers are removed from the cleaned ! 780: * list and inserted into the free list. ! 781: */ ! 782: cleanup() ! 783: { ! 784: register struct buf *bp; ! 785: register struct proc *rp; ! 786: register struct text *xp; ! 787: register struct cmap *c; ! 788: register struct pte *pte; ! 789: unsigned pf; ! 790: register int i; ! 791: int s; ! 792: ! 793: for (;;) { ! 794: s = spl6(); ! 795: if ((bp = bclnlist) == NULL) { ! 796: splx(s); ! 797: break; ! 798: } ! 799: bclnlist = bp->av_forw; ! 800: splx(s); ! 801: pte = dptopte(&proc[PAGEPID], btop(bp->b_un.b_addr)); ! 802: for (i = 0; i < bp->b_bcount; i += CLSIZE * NBPG) { ! 803: pf = pte->pg_pfnum; ! 804: munlock(pf); ! 805: c = &cmap[pgtocm(pf)]; ! 806: if (c->c_gone) { ! 807: memfree(pte, CLSIZE, 0); ! 808: cnt.v_dfree += CLSIZE; ! 809: } ! 810: pte += CLSIZE; ! 811: } ! 812: c = &cmap[pgtocm(bp->b_pfcent)]; ! 813: switch (c->c_type) { ! 814: ! 815: case CSYS: ! 816: panic("cleanup CSYS"); ! 817: ! 818: case CTEXT: ! 819: xp = &text[c->c_ndx]; ! 820: xp->x_poip--; ! 821: if (xp->x_poip == 0) ! 822: wakeup((caddr_t)&xp->x_poip); ! 823: break; ! 824: ! 825: case CDATA: ! 826: case CSTACK: ! 827: rp = &proc[c->c_ndx]; ! 828: rp->p_poip--; ! 829: if (rp->p_poip == 0) ! 830: wakeup((caddr_t)&rp->p_poip); ! 831: break; ! 832: } ! 833: if (c->c_gone == 0) { ! 834: switch (c->c_type) { ! 835: ! 836: case CTEXT: ! 837: pte = tptopte(xp->x_caddr, c->c_page); ! 838: break; ! 839: ! 840: case CDATA: ! 841: pte = dptopte(rp, c->c_page); ! 842: break; ! 843: ! 844: case CSTACK: ! 845: pte = sptopte(rp, c->c_page); ! 846: break; ! 847: } ! 848: if (pte->pg_v == 0) { ! 849: if (c->c_type == CTEXT) ! 850: xp->x_rssize -= CLSIZE; ! 851: else ! 852: rp->p_rssize -= CLSIZE; ! 853: memfree(pte, CLSIZE, 0); ! 854: cnt.v_dfree += CLSIZE; ! 855: } ! 856: } ! 857: bp->b_flags = 0; ! 858: bp->av_forw = bswlist.av_forw; ! 859: bswlist.av_forw = bp; ! 860: if (bswlist.b_flags & B_WANTED) { ! 861: bswlist.b_flags &= ~B_WANTED; ! 862: wakeup((caddr_t)&bswlist); ! 863: } ! 864: } ! 865: } ! 866: ! 867: /* ! 868: * Kluster locates pages adjacent to the argument pages ! 869: * that are immediately available to include in the pagein/pageout, ! 870: * and given the availability of memory includes them. ! 871: * It knows that the process image is contiguous in chunks; ! 872: * an assumption here is that CLSIZE * KLMAX is a divisor of dmmin, ! 873: * so that by looking at KLMAX chunks of pages, all such will ! 874: * necessarily be mapped swap contiguous. ! 875: */ ! 876: int noklust; ! 877: int klicnt[KLMAX]; ! 878: int klocnt[KLMAX]; ! 879: ! 880: kluster(p, v, pte0, rw, pkl, klsize, bn0) ! 881: register struct proc *p; ! 882: unsigned v; ! 883: struct pte *pte0; ! 884: int rw, *pkl, klsize; ! 885: daddr_t bn0; ! 886: { ! 887: int type, cl, clmax; ! 888: int kloff, k, klmax; ! 889: register struct pte *pte; ! 890: int klback, klforw; ! 891: register int i; ! 892: unsigned v0; ! 893: daddr_t bn; ! 894: ! 895: if (rw == B_READ) ! 896: klicnt[0]++; ! 897: else ! 898: klocnt[0]++; ! 899: *pkl = 1; ! 900: if (noklust || klsize <= 1 || klsize > KLMAX || (klsize & (klsize - 1))) ! 901: return (v); ! 902: if (rw == B_READ && freemem < CLSIZE * KLMAX) ! 903: return (v); ! 904: if (isassv(p, v)) { ! 905: type = CSTACK; ! 906: cl = vtosp(p, v) / CLSIZE; ! 907: clmax = p->p_ssize / CLSIZE; ! 908: } else if (isadsv(p, v)) { ! 909: type = CDATA; ! 910: cl = vtodp(p, v) / CLSIZE; ! 911: clmax = p->p_dsize / CLSIZE; ! 912: } else { ! 913: type = CTEXT; ! 914: cl = vtotp(p, v) / CLSIZE; ! 915: clmax = p->p_textp->x_size / CLSIZE; ! 916: } ! 917: kloff = cl & (klsize - 1); ! 918: pte = pte0; ! 919: bn = bn0; ! 920: for (k = kloff; --k >= 0;) { ! 921: if (type == CSTACK) ! 922: pte += CLSIZE; ! 923: else ! 924: pte -= CLSIZE; ! 925: if (type == CTEXT && rw == B_READ && bn) { ! 926: bn--; ! 927: if (mfind(MSWAPX, bn)) ! 928: break; ! 929: } ! 930: if (!klok(pte, rw)) ! 931: break; ! 932: } ! 933: klback = (kloff - k) - 1; ! 934: pte = pte0; ! 935: if ((cl - kloff) + klsize > clmax) ! 936: klmax = clmax - (cl - kloff); ! 937: else ! 938: klmax = klsize; ! 939: bn = bn0; ! 940: for (k = kloff; ++k < klmax;) { ! 941: if (type == CSTACK) ! 942: pte -= CLSIZE; ! 943: else ! 944: pte += CLSIZE; ! 945: if (type == CTEXT && rw == B_READ && bn) { ! 946: bn++; ! 947: if (mfind(MSWAPX, bn)) ! 948: break; ! 949: } ! 950: if (!klok(pte, rw)) ! 951: break; ! 952: } ! 953: klforw = (k - kloff) - 1; ! 954: if (klforw + klback == 0) ! 955: return (v); ! 956: pte = pte0; ! 957: if (type == CSTACK) { ! 958: pte -= klforw * CLSIZE; ! 959: v -= klforw * CLSIZE; ! 960: } else { ! 961: pte -= klback * CLSIZE; ! 962: v -= klback * CLSIZE; ! 963: } ! 964: *pkl = klforw + klback + 1; ! 965: if (rw == B_READ) ! 966: klicnt[0]--, klicnt[*pkl - 1]++; ! 967: else ! 968: klocnt[0]--, klocnt[*pkl - 1]++; ! 969: v0 = v; ! 970: for (i = 0; i < *pkl; i++) { ! 971: if (pte == pte0) ! 972: goto cont; ! 973: if (rw == B_WRITE) { ! 974: mlock(pte->pg_pfnum); ! 975: if (anycl(pte, pg_m)) { ! 976: pte->pg_vreadm = 1; ! 977: pte->pg_m = 0; ! 978: } ! 979: pte->pg_swapm = 0; ! 980: distcl(pte); ! 981: if (type == CTEXT) ! 982: distpte(p->p_textp, vtotp(p, v), pte); ! 983: } else { ! 984: struct pte opte; ! 985: int pf; ! 986: ! 987: opte = *pte; ! 988: if (memall(pte, CLSIZE, p, type) == 0) ! 989: panic("kluster"); ! 990: pte->pg_prot = opte.pg_prot; ! 991: pf = pte->pg_pfnum; ! 992: cmap[pgtocm(pf)].c_intrans = 1; ! 993: distcl(pte); ! 994: if (type == CTEXT) { ! 995: p->p_textp->x_rssize += CLSIZE; ! 996: distpte(p->p_textp, vtotp(p, v), pte); ! 997: } else ! 998: p->p_rssize += CLSIZE; ! 999: /* if (opte.pg_fod == 0) */ ! 1000: pte->pg_vreadm = opte.pg_vreadm; ! 1001: distcl(pte); ! 1002: } ! 1003: cont: ! 1004: pte += CLSIZE; ! 1005: v += CLSIZE; ! 1006: } ! 1007: return (v0); ! 1008: } ! 1009: ! 1010: klok(pte, rw) ! 1011: register struct pte *pte; ! 1012: int rw; ! 1013: { ! 1014: register struct cmap *c; ! 1015: ! 1016: if (rw == B_WRITE) { ! 1017: if (pte->pg_fod) ! 1018: return (0); ! 1019: if (pte->pg_pfnum == 0) ! 1020: return (0); ! 1021: c = &cmap[pgtocm(pte->pg_pfnum)]; ! 1022: if (c->c_lock || c->c_intrans) ! 1023: return (0); ! 1024: if (!dirtycl(pte)) ! 1025: return (0); ! 1026: return (1); ! 1027: } else { ! 1028: if (pte->pg_fod) ! 1029: return (0); ! 1030: if (pte->pg_pfnum) ! 1031: return (0); ! 1032: return (1); ! 1033: } ! 1034: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.