![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vm_pt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / kern|
Return to vm_pt.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1989 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution is only permitted until one year after the first shipment ! 6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and ! 7: * binary forms are permitted provided that: (1) source distributions retain ! 8: * this entire copyright notice and comment, and (2) distributions including ! 9: * binaries display the following acknowledgement: This product includes ! 10: * software developed by the University of California, Berkeley and its ! 11: * contributors'' in the documentation or other materials provided with the ! 12: * distribution and in all advertising materials mentioning features or use ! 13: * of this software. Neither the name of the University nor the names of ! 14: * its contributors may be used to endorse or promote products derived from ! 15: * this software without specific prior written permission. ! 16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 19: * ! 20: * @(#)vm_pt.c 7.14 (Berkeley) 6/30/90 ! 21: */ ! 22: #include "machine/pte.h" ! 23: #include "machine/mtpr.h" ! 24: ! 25: #include "param.h" ! 26: #include "systm.h" ! 27: #include "user.h" ! 28: #include "proc.h" ! 29: #include "map.h" ! 30: #include "cmap.h" ! 31: #include "vm.h" ! 32: #include "buf.h" ! 33: #include "text.h" ! 34: #include "vnode.h" ! 35: #include "kernel.h" ! 36: ! 37: /* ! 38: * Get page tables for process p. Allocator ! 39: * for memory is argument; process must be locked ! 40: * from swapping if vmemall is used; if memall is ! 41: * used, call will return w/o waiting for memory. ! 42: * In any case an error return results if no user ! 43: * page table space is available. ! 44: */ ! 45: vgetpt(p, pmemall) ! 46: register struct proc *p; ! 47: int (*pmemall)(); ! 48: { ! 49: register long a; ! 50: register int szpt = p->p_szpt; ! 51: ! 52: if (szpt == 0) ! 53: panic("vgetpt"); ! 54: #if defined(hp300) || defined(i386) ! 55: /* ! 56: * Allocate a single page segment/paage directory table as well ! 57: * as page tables. ! 58: */ ! 59: szpt++; ! 60: #endif ! 61: /* ! 62: * Allocate space in the kernel map for this process. ! 63: * Then allocate page table pages, and initialize the ! 64: * process' p0br and addr pointer to be the kernel ! 65: * virtual addresses of the base of the page tables and ! 66: * the pte for the process pcb (at the base of the u.). ! 67: */ ! 68: a = rmalloc(kernelmap, (long)szpt); ! 69: if (a == 0) ! 70: return (0); ! 71: if ((*pmemall)(&Usrptmap[a], szpt, p, CSYS) == 0) { ! 72: rmfree(kernelmap, (long)szpt, a); ! 73: return (0); ! 74: } ! 75: p->p_p0br = kmxtob(a); ! 76: p->p_addr = uaddr(p); ! 77: /* ! 78: * Now validate the system page table entries for the ! 79: * user page table pages, flushing old translations ! 80: * for these kernel virtual addresses. Clear the new ! 81: * page table pages for clean post-mortems. ! 82: */ ! 83: vmaccess(&Usrptmap[a], (caddr_t)p->p_p0br, szpt); ! 84: bzero((caddr_t) p->p_p0br, (unsigned) (szpt * NBPG)); ! 85: #if defined(hp300) ! 86: /* cache inhibit page tables pages so HW set bits are always valid */ ! 87: for (szpt = a + szpt - 1; szpt >= a; --szpt) ! 88: Usrptmap[szpt].pg_ci = 1; ! 89: initsegt(p); ! 90: #endif ! 91: #if defined(i386) ! 92: initpdt(p); ! 93: #endif ! 94: return (1); ! 95: } ! 96: ! 97: /* ! 98: * Initialize text portion of page table. ! 99: */ ! 100: vinitpt(p) ! 101: struct proc *p; ! 102: { ! 103: register struct text *xp; ! 104: register struct proc *q; ! 105: register struct pte *pte; ! 106: register int i; ! 107: struct pte proto; ! 108: ! 109: xp = p->p_textp; ! 110: if (xp == 0) ! 111: return; ! 112: pte = tptopte(p, 0); ! 113: /* ! 114: * If there is another instance of same text in core ! 115: * then just copy page tables from other process. ! 116: */ ! 117: if (q = xp->x_caddr) { ! 118: bcopy((caddr_t)tptopte(q, 0), (caddr_t)pte, ! 119: (unsigned) (sizeof(struct pte) * xp->x_size)); ! 120: goto done; ! 121: } ! 122: if (xp->x_flag & XLOAD || (xp->x_flag & XPAGV) == 0) { ! 123: /* ! 124: * Initialize text page tables, zfod if we are loading ! 125: * the text now; unless the process is demand loaded, ! 126: * this will suffice as the text will henceforth either be ! 127: * read from a file or demand paged in. ! 128: */ ! 129: *(int *)&proto = PG_URKR; ! 130: if (xp->x_flag & XLOAD) { ! 131: proto.pg_fod = 1; ! 132: ((struct fpte *)&proto)->pg_fileno = PG_FZERO; ! 133: } ! 134: for (i = 0; i < xp->x_size; i++) ! 135: *pte++ = proto; ! 136: if ((xp->x_flag & XPAGV) == 0) ! 137: goto done; ! 138: } ! 139: /* ! 140: * Text is demand loaded. If process is not loaded (i.e. being ! 141: * swapped in) then retrieve page tables from swap area. Otherwise ! 142: * this is the first time and we must initialize the page tables ! 143: * from the blocks in the file system. ! 144: */ ! 145: if (xp->x_flag & XLOAD) ! 146: vinifod(p, (struct fpte *)tptopte(p, 0), PG_FTEXT, xp->x_vptr, ! 147: (daddr_t)1, xp->x_size); ! 148: else ! 149: (void) swap(p, xp->x_ptdaddr, (caddr_t)tptopte(p, 0), ! 150: (int)(xp->x_size * sizeof (struct pte)), B_READ, ! 151: B_PAGET, swapdev_vp, 0); ! 152: done: ! 153: /* ! 154: * In the case where we are overlaying ourself with new page ! 155: * table entries, old user-space translations should be flushed. ! 156: */ ! 157: if (p == u.u_procp) ! 158: newptes(tptopte(p, 0), tptov(p, 0), (int)xp->x_size); ! 159: else ! 160: p->p_flag |= SPTECHG; ! 161: } ! 162: ! 163: /* ! 164: * Update the page tables of all processes linked ! 165: * to a particular text segment, by distributing ! 166: * dpte to the the text page at virtual frame v. ! 167: * ! 168: * Note that invalidation in the translation buffer for ! 169: * the current process is the responsibility of the caller. ! 170: */ ! 171: distpte(xp, tp, dpte) ! 172: struct text *xp; ! 173: register unsigned tp; ! 174: register struct pte *dpte; ! 175: { ! 176: register struct proc *p; ! 177: register struct pte *pte; ! 178: register int i; ! 179: ! 180: for (p = xp->x_caddr; p; p = p->p_xlink) { ! 181: pte = tptopte(p, tp); ! 182: p->p_flag |= SPTECHG; ! 183: if (pte != dpte) ! 184: for (i = 0; i < CLSIZE; i++) ! 185: pte[i] = dpte[i]; ! 186: } ! 187: } ! 188: ! 189: /* ! 190: * Release page tables of process p. ! 191: */ ! 192: vrelpt(p) ! 193: register struct proc *p; ! 194: { ! 195: register int a; ! 196: register int szpt = p->p_szpt; ! 197: ! 198: if (szpt == 0) ! 199: return; ! 200: a = btokmx(p->p_p0br); ! 201: #if defined(hp300) ! 202: flushustp(initustp(p)); ! 203: /* don't forget the segment table */ ! 204: szpt++; ! 205: #endif ! 206: #if defined(i386) ! 207: /* don't forget the page directory table */ ! 208: szpt++; ! 209: #endif ! 210: (void) vmemfree(&Usrptmap[a], szpt); ! 211: rmfree(kernelmap, (long)szpt, (long)a); ! 212: } ! 213: ! 214: #define Xu(a) t = up->u_pcb.a; up->u_pcb.a = uq ->u_pcb.a; uq->u_pcb.a = t; ! 215: #define Xup(a) tp = up->u_pcb.a; up->u_pcb.a = uq ->u_pcb.a; uq->u_pcb.a = tp; ! 216: #define Xp(a) t = p->a; p->a = q->a; q->a = t; ! 217: #define Xpp(a) tp = p->a; p->a = q->a; q->a = tp; ! 218: ! 219: /* ! 220: * Pass the page tables of process p to process q. ! 221: * Used during vfork(). P and q are not symmetric; ! 222: * p is the giver and q the receiver; after calling vpasspt ! 223: * p will be ``cleaned out''. Thus before vfork() we call vpasspt ! 224: * with the child as q and give it our resources; after vfork() we ! 225: * call vpasspt with the child as p to steal our resources back. ! 226: * We are cognizant of whether we are p or q because we have to ! 227: * be careful to keep our u. area and restore the other u. area from ! 228: * umap after we temporarily put our u. area in both p and q's page tables. ! 229: */ ! 230: vpasspt(p, q, up, uq, umap) ! 231: register struct proc *p, *q; ! 232: register struct user *up, *uq; ! 233: struct pte *umap; ! 234: { ! 235: int t; ! 236: int s; ! 237: struct pte *tp; ! 238: register int i; ! 239: ! 240: s = splhigh(); /* conservative, and slightly paranoid */ ! 241: Xu(pcb_szpt); Xu(pcb_p0lr); Xu(pcb_p1lr); ! 242: #if defined(tahoe) ! 243: Xu(pcb_p2lr); ! 244: #endif ! 245: Xup(pcb_p0br); Xup(pcb_p1br); ! 246: #if defined(tahoe) ! 247: Xup(pcb_p2br); ! 248: #endif ! 249: #if defined(hp300) ! 250: Xu(pcb_ustp); Xu(pcb_flags); ! 251: #endif ! 252: #if defined(i386) ! 253: Xu(pcb_cr3); Xu(pcb_flags); ! 254: #endif ! 255: ! 256: /* ! 257: * The u. area is contained in the process' p1 region. ! 258: * Thus we map the current u. area into the process virtual space ! 259: * of both sets of page tables we will deal with so that it ! 260: * will stay with us as we rearrange memory management. ! 261: */ ! 262: for (i = 0; i < UPAGES; i++) ! 263: if (up == &u) ! 264: q->p_addr[i] = p->p_addr[i]; ! 265: else ! 266: p->p_addr[i] = q->p_addr[i]; ! 267: #if defined(vax) || defined(tahoe) ! 268: mtpr(TBIA, 0); ! 269: #endif ! 270: /* ! 271: * Now have u. double mapped, and have flushed ! 272: * any stale translations to new u. area. ! 273: * Switch the page tables. ! 274: */ ! 275: Xpp(p_p0br); Xp(p_szpt); Xpp(p_addr); ! 276: #if defined(vax) || defined(tahoe) ! 277: mtpr(P0BR, u.u_pcb.pcb_p0br); ! 278: #if defined(vax) ! 279: mtpr(P0LR, u.u_pcb.pcb_p0lr &~ AST_CLR); ! 280: #else ! 281: mtpr(P0LR, u.u_pcb.pcb_p0lr); ! 282: #endif ! 283: mtpr(P1BR, u.u_pcb.pcb_p1br); ! 284: mtpr(P1LR, u.u_pcb.pcb_p1lr); ! 285: #if defined(tahoe) ! 286: mtpr(P2BR, u.u_pcb.pcb_p2br); ! 287: mtpr(P2LR, u.u_pcb.pcb_p2lr); ! 288: #endif ! 289: #endif ! 290: #if defined(hp300) ! 291: loadustp(u.u_pcb.pcb_ustp); ! 292: #endif ! 293: #if defined(i386) ! 294: load_cr3(u.u_pcb.pcb_cr3); ! 295: #endif ! 296: /* ! 297: * Now running on the ``other'' set of page tables. ! 298: * Flush translation to insure that we get correct u. ! 299: * Resurrect the u. for the other process in the other ! 300: * (our old) set of page tables. Thus the other u. has moved ! 301: * from its old (our current) set of page tables to our old ! 302: * (its current) set of page tables, while we have kept our ! 303: * u. by mapping it into the other page table and then keeping ! 304: * the other page table. ! 305: */ ! 306: #if defined(vax) || defined(tahoe) ! 307: mtpr(TBIA, 0); ! 308: #endif ! 309: for (i = 0; i < UPAGES; i++) { ! 310: int pf; ! 311: struct pte *pte; ! 312: if (up == &u) { ! 313: pf = umap[i].pg_pfnum; ! 314: pte = &q->p_addr[i]; ! 315: pte->pg_pfnum = pf; ! 316: } else { ! 317: pf = umap[i].pg_pfnum; ! 318: pte = &p->p_addr[i]; ! 319: pte->pg_pfnum = pf; ! 320: } ! 321: } ! 322: #if defined(vax) || defined(tahoe) ! 323: mtpr(TBIA, 0); ! 324: #endif ! 325: #if defined(hp300) ! 326: TBIA(); ! 327: #endif ! 328: #if defined(i386) ! 329: tlbflush(); ! 330: #endif ! 331: splx(s); ! 332: } ! 333: ! 334: /* ! 335: * Compute number of pages to be allocated to the u. area ! 336: * and data and stack area page tables, which are stored on the ! 337: * disk immediately after the u. area. ! 338: */ ! 339: /*ARGSUSED*/ ! 340: vusize(p, utl) ! 341: register struct proc *p; ! 342: struct user *utl; ! 343: { ! 344: register int tsz = p->p_tsize / NPTEPG; ! 345: ! 346: /* ! 347: * We do not need page table space on the disk for page ! 348: * table pages wholly containing text. This is well ! 349: * understood in the code in vmswap.c. ! 350: */ ! 351: return (clrnd(UPAGES + ptsize(p) - tsz)); ! 352: } ! 353: ! 354: /* ! 355: * Get u area for process p. If a old u area is given, ! 356: * then copy the new area from the old, else ! 357: * swap in as specified in the proc structure. ! 358: * ! 359: * Since argument map/newu is potentially shared ! 360: * when an old u. is provided we have to be careful not ! 361: * to block after beginning to use them in this case. ! 362: * (This is not true when called from swapin() with no old u.) ! 363: */ ! 364: vgetu(p, palloc, map, newu, oldu) ! 365: register struct proc *p; ! 366: int (*palloc)(); ! 367: register struct pte *map; ! 368: register struct user *newu; ! 369: struct user *oldu; ! 370: { ! 371: register int i; ! 372: ! 373: if ((*palloc)(p->p_addr, clrnd(UPAGES), p, CSYS) == 0) ! 374: return (0); ! 375: /* ! 376: * New u. pages are to be accessible in map/newu as well ! 377: * as in process p's virtual memory. ! 378: */ ! 379: for (i = 0; i < UPAGES; i++) { ! 380: map[i] = p->p_addr[i]; ! 381: *(int *)(p->p_addr + i) |= PG_URKW | PG_V; ! 382: } ! 383: setredzone(p->p_addr, (caddr_t)0); ! 384: vmaccess(map, (caddr_t)newu, UPAGES); ! 385: /* ! 386: * New u.'s come from forking or inswap. ! 387: */ ! 388: if (oldu) { ! 389: bcopy((caddr_t)oldu, (caddr_t)newu, (unsigned) UPAGES * NBPG); ! 390: newu->u_procp = p; ! 391: } else { ! 392: #if defined(vax) || defined(hp300) || defined(i386) ! 393: (void) swap(p, p->p_swaddr, (caddr_t)0, ctob(UPAGES), ! 394: #else ! 395: (void) swap(p, p->p_swaddr, (caddr_t)&u, ctob(UPAGES), ! 396: #endif ! 397: B_READ, B_UAREA, swapdev_vp, 0); ! 398: if ( ! 399: #if defined(vax) ! 400: newu->u_pcb.pcb_ssp != -1 || newu->u_pcb.pcb_esp != -1 || ! 401: #endif ! 402: newu->u_tsize != p->p_tsize || newu->u_dsize != p->p_dsize || ! 403: newu->u_ssize != p->p_ssize || newu->u_procp != p) ! 404: panic("vgetu"); ! 405: } ! 406: /* ! 407: * Initialize the pcb copies of the p0 and p1 region bases and ! 408: * software page table size from the information in the proc structure. ! 409: */ ! 410: newu->u_pcb.pcb_p0br = p->p_p0br; ! 411: #if defined(vax) ! 412: newu->u_pcb.pcb_p1br = initp1br(p->p_p0br + p->p_szpt * NPTEPG); ! 413: #endif ! 414: #if defined(tahoe) ! 415: newu->u_pcb.pcb_p2br = initp2br(p->p_p0br + p->p_szpt * NPTEPG); ! 416: #endif ! 417: #if defined(hp300) ! 418: newu->u_pcb.pcb_p1br = initp1br(p->p_p0br + p->p_szpt * NPTEPG); ! 419: newu->u_pcb.pcb_ustp = initustp(p); ! 420: #endif ! 421: #if defined(i386) ! 422: newu->u_pcb.pcb_p1br = initp1br(p->p_p0br + p->p_szpt * NPTEPG); ! 423: newu->u_pcb.pcb_cr3 = initpdt(p); ! 424: #endif ! 425: newu->u_pcb.pcb_szpt = p->p_szpt; ! 426: return (1); ! 427: } ! 428: ! 429: /* ! 430: * Release swap space for a u. area. ! 431: */ ! 432: vrelswu(p, utl) ! 433: struct proc *p; ! 434: struct user *utl; ! 435: { ! 436: ! 437: rmfree(swapmap, (long)ctod(vusize(p, utl)), p->p_swaddr); ! 438: /* p->p_swaddr = 0; */ /* leave for post-mortems */ ! 439: } ! 440: ! 441: /* ! 442: * Get swap space for a u. area. ! 443: */ ! 444: vgetswu(p, utl) ! 445: struct proc *p; ! 446: struct user *utl; ! 447: { ! 448: ! 449: p->p_swaddr = rmalloc(swapmap, (long)ctod(vusize(p, utl))); ! 450: return (p->p_swaddr); ! 451: } ! 452: ! 453: /* ! 454: * Release u. area, swapping it out if desired. ! 455: */ ! 456: vrelu(p, swapu) ! 457: register struct proc *p; ! 458: { ! 459: register int i; ! 460: struct pte uu[UPAGES]; ! 461: ! 462: if (swapu) ! 463: #if defined(vax) || defined(hp300) || defined(i386) ! 464: (void) swap(p, p->p_swaddr, (caddr_t)0, ctob(UPAGES), ! 465: #else ! 466: (void) swap(p, p->p_swaddr, (caddr_t)&u, ctob(UPAGES), ! 467: #endif ! 468: B_WRITE, B_UAREA, swapdev_vp, 0); ! 469: for (i = 0; i < UPAGES; i++) ! 470: uu[i] = p->p_addr[i]; ! 471: /* ! 472: * If freeing the user structure and kernel stack ! 473: * for the current process, have to run a bit longer ! 474: * using the pages which have already been freed... ! 475: * block memory allocation from the network by raising ipl. ! 476: */ ! 477: if (p == u.u_procp) ! 478: (void) splimp(); /* XXX */ ! 479: (void) vmemfree(uu, clrnd(UPAGES)); ! 480: } ! 481: ! 482: #ifdef DIAGNOSTIC ! 483: int ptforceswap; ! 484: #endif ! 485: /* ! 486: * Expand a page table, assigning new kernel virtual ! 487: * space and copying the page table entries over both ! 488: * in the system map and as necessary in the user page table space. ! 489: * IMPORTANT NOTE: ! 490: * ! 491: * On the HPs, excess PTEs will *always* be zero. This is critical ! 492: * since we don't have length registers. We guarentee this for ! 493: * expansion here by zeroing new PT pages, and for shrinking in ! 494: * setptlr() which zeroes excess PTEs. ! 495: * ! 496: * On the VAX and TAHOE, the state of excess PTEs is less important ! 497: * as the length registers dictate the actual bounds. As a result ! 498: * the state of these PTEs is random. New pages are zeroed unless ! 499: * they come about due to a PT expansion swap in which case they ! 500: * have garbage. Page table splitting (either here or as part of ! 501: * an expansion swap) can lead to duplicate PTEs. When shrinking, ! 502: * expand() sets excess PTEs to PG_UW (not zero). ! 503: */ ! 504: ptexpand(change, ods, omms, oss) ! 505: register int change; ! 506: segsz_t ods, omms, oss; ! 507: { ! 508: register struct pte *p1, *p2; ! 509: register int i; ! 510: #if defined(vax) || defined(hp300) || defined(i386) ! 511: register int spages, ss = P1PAGES - u.u_pcb.pcb_p1lr; ! 512: #endif ! 513: #if defined(tahoe) ! 514: register int spages, ss = P2PAGES - u.u_pcb.pcb_p2lr; ! 515: #endif ! 516: register int kold = btokmx(u.u_pcb.pcb_p0br); ! 517: int knew, tdpages; ! 518: int szpt = u.u_pcb.pcb_szpt; ! 519: caddr_t a; ! 520: int s; ! 521: ! 522: if (change <= 0 || change % CLSIZE) ! 523: panic("ptexpand"); ! 524: #if defined(hp300) || defined(i386) ! 525: /* ! 526: * ++ to account for segment/page directory table. We reallocate ! 527: * a segment table PTE so that it is virtually contiguous with ! 528: * the page tables. ! 529: * This way we can locate it relative to p_p0br (see initustp()). ! 530: * Reallocation also reduces fragmentation of Usrptmap. ! 531: */ ! 532: szpt++; ! 533: #endif ! 534: /* ! 535: * Change is the number of new page table pages needed. ! 536: * Kold is the old index in the kernelmap of the page tables. ! 537: * Allocate a new kernel map segment of size szpt+change for ! 538: * the page tables, and the new page table pages in the ! 539: * middle of this new region. ! 540: */ ! 541: top: ! 542: #if defined(hp300) || defined(i386) ! 543: /* ! 544: * Consider segment/page directory table as part of stack ptes ! 545: * Note we use ctopt() since we don't pack page tables ! 546: */ ! 547: spages = ctopt(ss) + 1; ! 548: #else ! 549: spages = ss/NPTEPG; ! 550: #endif ! 551: tdpages = szpt - spages; ! 552: #ifdef DIAGNOSTIC ! 553: if (ptforceswap) ! 554: goto bad; ! 555: #endif ! 556: if ((knew=rmalloc(kernelmap, (long)(szpt+change))) == 0) ! 557: goto bad; ! 558: if (memall(&Usrptmap[knew+tdpages], change, u.u_procp, CSYS) == 0) { ! 559: rmfree(kernelmap, (long)(szpt+change), (long)knew); ! 560: goto bad; ! 561: } ! 562: ! 563: /* ! 564: * Spages pages of u.+stack page tables go over unchanged. ! 565: * Tdpages of text+data page table may contain a few stack ! 566: * pages which need to go in one of the newly allocated pages; ! 567: * this is a rough cut. ! 568: * ! 569: * NOTE: The last statement is not true on HPs, text/data and ! 570: * stack are seperate page tables. We really cannot "pack" page ! 571: * tables since we have no length register, and packing would ! 572: * result in some pages being accessible at two different addrs. ! 573: */ ! 574: kmcopy(knew, kold, tdpages); ! 575: kmcopy(knew+tdpages+change, kold+tdpages, spages); ! 576: ! 577: /* ! 578: * Validate and clear the newly allocated page table pages in the ! 579: * center of the new region of the kernelmap. ! 580: */ ! 581: i = knew + tdpages; ! 582: p1 = &Usrptmap[i]; ! 583: a = (caddr_t) kmxtob(i); ! 584: p2 = p1 + change; ! 585: while (p1 < p2) { ! 586: #if defined(hp300) ! 587: /* mapin is overkill */ ! 588: *(u_int *)p1 |= PG_V|PG_KW|PG_CI; ! 589: #else ! 590: mapin(p1, (u_int) a, p1->pg_pfnum, (int)(PG_V|PG_KW)); ! 591: #endif ! 592: bzero(a, NBPG); ! 593: a += NBPG; ! 594: p1++; ! 595: } ! 596: ! 597: #if !defined(hp300) && !defined(i386) ! 598: /* ! 599: * Move the stack and u. pte's which are before the newly ! 600: * allocated pages into the last of the newly allocated pages. ! 601: * They are taken from the end of the current p1 region, ! 602: * and moved to the end of the new p1 region. ! 603: */ ! 604: #if defined(vax) ! 605: p1 = u.u_pcb.pcb_p1br + u.u_pcb.pcb_p1lr; ! 606: p2 = initp1br(kmxtob(knew+szpt+change)) + u.u_pcb.pcb_p1lr; ! 607: #endif ! 608: #if defined(tahoe) ! 609: p1 = u.u_pcb.pcb_p2br + u.u_pcb.pcb_p2lr; ! 610: p2 = initp2br(kmxtob(knew+szpt+change)) + u.u_pcb.pcb_p2lr; ! 611: #endif ! 612: bcopy((caddr_t) p1, (caddr_t) p2, ! 613: (unsigned)((caddr_t)kmxtob(kold + tdpages) - (caddr_t)p1)); ! 614: #endif ! 615: ! 616: /* ! 617: * Now switch to the new page tables. ! 618: */ ! 619: s = splhigh(); /* conservative */ ! 620: u.u_procp->p_p0br = kmxtob(knew); ! 621: setp0br(u.u_procp->p_p0br); ! 622: #if defined(vax) ! 623: u.u_pcb.pcb_p1br = initp1br(kmxtob(knew+szpt+change)); ! 624: setp1br(u.u_pcb.pcb_p1br); ! 625: #endif ! 626: #if defined(tahoe) ! 627: u.u_pcb.pcb_p1br = kmxtob(knew); ! 628: setp1br(u.u_pcb.pcb_p1br); ! 629: u.u_pcb.pcb_p2br = initp2br(kmxtob(knew+szpt+change)); ! 630: setp2br(u.u_pcb.pcb_p2br); ! 631: #endif ! 632: #if defined(hp300) || defined(i386) ! 633: u.u_pcb.pcb_p1br = initp1br(kmxtob(knew+szpt-1+change)); ! 634: setp1br(u.u_pcb.pcb_p1br); ! 635: #endif ! 636: u.u_pcb.pcb_szpt += change; ! 637: u.u_procp->p_szpt += change; ! 638: u.u_procp->p_addr = uaddr(u.u_procp); ! 639: #if defined(vax) || defined(tahoe) ! 640: mtpr(TBIA, 0); ! 641: #endif ! 642: #if defined(hp300) ! 643: u.u_pcb.pcb_ustp = initustp(u.u_procp); ! 644: initsegt(u.u_procp); ! 645: TBIA(); ! 646: #endif ! 647: #if defined(i386) ! 648: u.u_pcb.pcb_cr3 = initpdt(u.u_procp); ! 649: tlbflush(); ! 650: #endif ! 651: splx(s); ! 652: ! 653: /* ! 654: * Finally, free old kernelmap. ! 655: */ ! 656: if (szpt) ! 657: rmfree(kernelmap, (long)szpt, (long)kold); ! 658: return; ! 659: ! 660: bad: ! 661: /* ! 662: * Swap out the process so that the unavailable ! 663: * resource will be allocated upon swapin. ! 664: * ! 665: * When resume is executed for the process, ! 666: * here is where it will resume. ! 667: */ ! 668: resume(pcbb(u.u_procp)); ! 669: if (savectx(&u.u_ssave)) { ! 670: #if defined(hp300) || defined(i386) ! 671: /* ! 672: * New page table pages will contain garbage since ! 673: * the page table was expanded on disk without the ! 674: * new pages being zeroed. ! 675: */ ! 676: bzero((caddr_t)u.u_procp->p_p0br+tdpages*NBPG, change*NBPG); ! 677: #endif ! 678: return; ! 679: } ! 680: if (swapout(u.u_procp, ods, omms, oss) == 0) { ! 681: /* ! 682: * No space to swap... it is inconvenient to try ! 683: * to exit, so just wait a bit and hope something ! 684: * turns up. Could deadlock here. ! 685: * ! 686: * SOMEDAY REFLECT ERROR BACK THROUGH expand TO CALLERS ! 687: * (grow, sbreak) SO CAN'T DEADLOCK HERE. ! 688: */ ! 689: sleep((caddr_t)&lbolt, PRIBIO); ! 690: goto top; ! 691: } ! 692: /* ! 693: * Set SSWAP bit, so that when process is swapped back in ! 694: * swapin will set u.u_pcb.pcb_sswap to u_sswap and force a ! 695: * return from the savectx() above. ! 696: */ ! 697: u.u_procp->p_flag |= SSWAP; ! 698: swtch(); ! 699: /* NOTREACHED */ ! 700: } ! 701: ! 702: kmcopy(to, from, count) ! 703: int to; ! 704: int from; ! 705: register int count; ! 706: { ! 707: register struct pte *tp = &Usrptmap[to]; ! 708: register struct pte *fp = &Usrptmap[from]; ! 709: u_int a; ! 710: ! 711: a = (u_int) kmxtob(to); ! 712: while (count != 0) { ! 713: #if defined(hp300) ! 714: mapin(tp, a, fp->pg_pfnum, ! 715: (int)(*((int *)fp) & (PG_V|PG_PROT|PG_CI))); ! 716: #else ! 717: mapin(tp, a, fp->pg_pfnum, ! 718: (int)(*((int *)fp) & (PG_V|PG_PROT))); ! 719: #endif ! 720: #if defined(tahoe) ! 721: mtpr(P1DC, a); ! 722: #endif ! 723: tp++; ! 724: fp++; ! 725: a += NBPG; ! 726: count--; ! 727: } ! 728: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.