![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vmswap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys.vax / sys|
Return to vmswap.c CVS log | Up to [Research Unix] / researchv9 / sys.vax / sys |
1.1 ! root 1: /* vmswap.c 4.3 81/06/11 */ ! 2: ! 3: #include "../h/param.h" ! 4: #include "../h/systm.h" ! 5: #include "../h/dir.h" ! 6: #include "../h/user.h" ! 7: #include "../h/proc.h" ! 8: #include "../h/text.h" ! 9: #include "../h/map.h" ! 10: #include "../h/buf.h" ! 11: #include "../h/pte.h" ! 12: #include "../h/mtpr.h" ! 13: #include "../h/cmap.h" ! 14: #include "../h/vm.h" ! 15: ! 16: /* ! 17: * Swap a process in. ! 18: */ ! 19: swapin(p) ! 20: register struct proc *p; ! 21: { ! 22: register struct text *xp; ! 23: register int i, s; ! 24: ! 25: if (xp = p->p_textp) ! 26: xlock(xp); ! 27: p->p_szpt = clrnd(ctopt(p->p_ssize+p->p_dsize+p->p_tsize+UPAGES)); ! 28: if (vgetpt(p, memall) == 0) ! 29: goto nomem; ! 30: if (vgetu(p, memall, Swapmap, &swaputl, (struct user *)0) == 0) { ! 31: vrelpt(p); ! 32: goto nomem; ! 33: } ! 34: ! 35: swdspt(p, &swaputl, B_READ); ! 36: /* ! 37: * Make sure swdspt didn't smash u. pte's ! 38: */ ! 39: for (i = 0; i < UPAGES; i++) { ! 40: if (Swapmap[i].pg_pfnum != p->p_addr[i].pg_pfnum) ! 41: panic("swapin"); ! 42: } ! 43: vrelswu(p, &swaputl); ! 44: if (xp) { ! 45: xlink(p); ! 46: xunlock(xp); ! 47: } ! 48: ! 49: p->p_rssize = 0; ! 50: s = spl6(); ! 51: if (p->p_stat == SRUN) ! 52: setrq(p); ! 53: p->p_flag |= SLOAD; ! 54: if (p->p_flag & SSWAP) { ! 55: swaputl.u_pcb.pcb_sswap = u.u_ssav; ! 56: p->p_flag &= ~SSWAP; ! 57: } ! 58: splx(s); ! 59: p->p_time = 0; ! 60: multprog++; ! 61: cnt.v_swpin++; ! 62: if (p->p_flag&SPROCIO) wakeup((caddr_t)&p->p_addr); ! 63: return (1); ! 64: ! 65: nomem: ! 66: if (xp) ! 67: xunlock(xp); ! 68: return (0); ! 69: } ! 70: ! 71: int xswapwant, xswaplock; ! 72: /* ! 73: * Swap out process p. ! 74: * ds and ss are the old data size and the stack size ! 75: * of the process, and are supplied during page table ! 76: * expansion swaps. ! 77: */ ! 78: swapout(p, ds, ss) ! 79: register struct proc *p; ! 80: size_t ds, ss; ! 81: { ! 82: register struct pte *map; ! 83: register struct user *utl; ! 84: register int a; ! 85: int s; ! 86: int rc = 1; ! 87: ! 88: s = 1; ! 89: map = Xswapmap; ! 90: utl = &xswaputl; ! 91: if (xswaplock & s) ! 92: if ((xswaplock & 2) == 0) { ! 93: s = 2; ! 94: map = Xswap2map; ! 95: utl = &xswap2utl; ! 96: } ! 97: a = spl6(); ! 98: while (xswaplock & s) { ! 99: xswapwant |= s; ! 100: sleep((caddr_t)map, PSWP); ! 101: } ! 102: xswaplock |= s; ! 103: splx(a); ! 104: uaccess(p, map, utl); ! 105: if (vgetswu(p, utl) == 0) { ! 106: swkill(p, "swapout"); ! 107: rc = 0; ! 108: goto out; ! 109: } ! 110: utl->u_vm.vm_nswap++; ! 111: utl->u_odsize = ds; ! 112: utl->u_ossize = ss; ! 113: p->p_flag |= SLOCK; ! 114: if (p->p_textp) { ! 115: if (p->p_textp->x_ccount == 1) ! 116: p->p_textp->x_swrss = p->p_textp->x_rssize; ! 117: xccdec(p->p_textp, p); ! 118: } ! 119: p->p_swrss = p->p_rssize; ! 120: vsswap(p, dptopte(p, 0), CDATA, 0, ds, &utl->u_dmap); ! 121: vsswap(p, sptopte(p, CLSIZE-1), CSTACK, 0, ss, &utl->u_smap); ! 122: if (p->p_rssize != 0) ! 123: panic("swapout rssize"); ! 124: ! 125: swdspt(p, utl, B_WRITE); ! 126: vrelu(p, 1); ! 127: if ((p->p_flag & SLOAD) && (p->p_stat != SRUN || p != u.u_procp)) ! 128: panic("swapout"); ! 129: p->p_flag &= ~SLOAD; ! 130: vrelpt(p); ! 131: p->p_flag &= ~SLOCK; ! 132: p->p_time = 0; ! 133: ! 134: multprog--; ! 135: cnt.v_swpout++; ! 136: ! 137: if(runout) { ! 138: runout = 0; ! 139: wakeup((caddr_t)&runout); ! 140: } ! 141: out: ! 142: xswaplock &= ~s; ! 143: if (xswapwant & s) { ! 144: xswapwant &= ~s; ! 145: wakeup((caddr_t)map); ! 146: } ! 147: if (rc == 0) { ! 148: a = spl6(); ! 149: p->p_flag |= SLOAD; ! 150: if (p != u.u_procp && p->p_stat == SRUN) ! 151: setrq(p); ! 152: splx(a); ! 153: } ! 154: return (rc); ! 155: } ! 156: ! 157: /* ! 158: * Swap the data and stack page tables in or out. ! 159: * Only hard thing is swapping out when new pt size is different than old. ! 160: * If we are growing new pt pages, then we must spread pages with 2 swaps. ! 161: * If we are shrinking pt pages, then we must merge stack pte's into last ! 162: * data page so as not to lose them (and also do two swaps). ! 163: */ ! 164: swdspt(p, utl, rdwri) ! 165: register struct proc *p; ! 166: register struct user *utl; ! 167: { ! 168: register int szpt, tsz, ssz; ! 169: int tdlast, slast, tdsz; ! 170: register struct pte *pte; ! 171: register int i; ! 172: ! 173: szpt = clrnd(ctopt(p->p_tsize+p->p_dsize+p->p_ssize+UPAGES)); ! 174: tsz = p->p_tsize / NPTEPG; ! 175: if (szpt == p->p_szpt) { ! 176: swptstat.pteasy++; ! 177: swpt(rdwri, p, 0, tsz, ! 178: (p->p_szpt - tsz) * NBPG - UPAGES * sizeof (struct pte)); ! 179: goto check; ! 180: } ! 181: if (szpt < p->p_szpt) ! 182: swptstat.ptshrink++; ! 183: else ! 184: swptstat.ptexpand++; ! 185: ssz = clrnd(ctopt(utl->u_ossize+UPAGES)); ! 186: if (szpt < p->p_szpt && utl->u_odsize && (utl->u_ossize+UPAGES)) { ! 187: /* ! 188: * Page tables shrinking... see if last text+data and ! 189: * last stack page must be merged... if so, copy ! 190: * stack pte's from last stack page to end of last ! 191: * data page, and decrease size of stack pt to be swapped. ! 192: */ ! 193: tdlast = (p->p_tsize + utl->u_odsize) % (NPTEPG * CLSIZE); ! 194: slast = (utl->u_ossize + UPAGES) % (NPTEPG * CLSIZE); ! 195: if (tdlast && slast && tdlast + slast <= (NPTEPG * CLSIZE)) { ! 196: swptstat.ptpack++; ! 197: tdsz = clrnd(ctopt(p->p_tsize + utl->u_odsize)); ! 198: bcopy((caddr_t)sptopte(p, utl->u_ossize - 1), ! 199: (caddr_t)&p->p_p0br[tdsz * NPTEPG - slast], ! 200: (unsigned)(slast * sizeof (struct pte))); ! 201: ssz -= CLSIZE; ! 202: } ! 203: } ! 204: if (ssz) ! 205: swpt(rdwri, p, szpt - ssz - tsz, p->p_szpt - ssz, ssz * NBPG); ! 206: if (utl->u_odsize) ! 207: swpt(rdwri, p, 0, tsz, ! 208: (clrnd(ctopt(p->p_tsize + utl->u_odsize)) - tsz) * NBPG); ! 209: check: ! 210: for (i = 0; i < utl->u_odsize; i++) { ! 211: pte = dptopte(p, i); ! 212: if (pte->pg_v || pte->pg_fod == 0 && (pte->pg_pfnum||pte->pg_m)) ! 213: panic("swdspt"); ! 214: } ! 215: for (i = 0; i < utl->u_ossize; i++) { ! 216: pte = sptopte(p, i); ! 217: if (pte->pg_v || pte->pg_fod == 0 && (pte->pg_pfnum||pte->pg_m)) ! 218: panic("swdspt"); ! 219: } ! 220: } ! 221: ! 222: swpt(rdwri, p, doff, a, n) ! 223: int rdwri; ! 224: struct proc *p; ! 225: int doff, a, n; ! 226: { ! 227: ! 228: if (n <= 0) ! 229: return; ! 230: swap(p, p->p_swaddr + ctod(UPAGES) + doff, ! 231: (caddr_t)&p->p_p0br[a * NPTEPG], n, rdwri, B_PAGET, swapdev, 0); ! 232: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.