![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to swap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / coh.386|
Return to swap.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / coh.386 |
1.1 ! root 1: /* $Header: /y/coh.386/RCS/swap.c,v 1.3 93/04/14 10:07:55 root Exp $ */ ! 2: /* (lgl- ! 3: * The information contained herein is a trade secret of Mark Williams ! 4: * Company, and is confidential information. It is provided under a ! 5: * license agreement, and may be copied or disclosed only under the ! 6: * terms of that agreement. Any reproduction or disclosure of this ! 7: * material without the express written authorization of Mark Williams ! 8: * Company or persuant to the license agreement is unlawful. ! 9: * ! 10: * COHERENT Version 2.3.37 ! 11: * Copyright (c) 1982, 1983, 1984. ! 12: * An unpublished work by Mark Williams Company, Chicago. ! 13: * All rights reserved. ! 14: -lgl) */ ! 15: /* ! 16: * Coherent. ! 17: * Swapper. ! 18: * ! 19: * $Log: swap.c,v $ ! 20: * Revision 1.3 93/04/14 10:07:55 root ! 21: * r75 ! 22: * ! 23: * Revision 1.2 92/01/06 12:00:30 hal ! 24: * Compile with cc.mwc. ! 25: * ! 26: * Revision 1.1 88/03/24 16:19:51 src ! 27: * Initial revision ! 28: * ! 29: * 87/01/05 Allan Cornish /usr/src/sys/ker/swap.c ! 30: * Swap() now waits for all processes to be swapped in before exit on signal. ! 31: */ ! 32: #include <sys/coherent.h> ! 33: #include <sys/proc.h> ! 34: #include <sys/sched.h> ! 35: #include <sys/seg.h> ! 36: #include <sys/buf.h> ! 37: ! 38: /* ! 39: * Functions. ! 40: */ ! 41: SEG *xmalloc(); ! 42: SEG *xdalloc(); ! 43: ! 44: swap() ! 45: { ! 46: register SEG *sp; ! 47: register PROC *pp1; ! 48: register PROC *pp2; ! 49: register PROC *pp3; ! 50: register unsigned s; ! 51: register unsigned n; ! 52: register unsigned t; ! 53: register unsigned v; ! 54: register unsigned m; ! 55: register int i; ! 56: static unsigned ltimer; ! 57: ! 58: if (sexflag != 0) ! 59: uexit(1); ! 60: sexflag++; ! 61: while (1) { ! 62: lock(pnxgate); ! 63: t = (utimer-ltimer)/NSUTICK; ! 64: v = t*SVCLOCK; ! 65: ltimer += t*NSUTICK; ! 66: m = 0; ! 67: pp2 = NULL; ! 68: for (pp1=procq.p_nback; pp1!=&procq; pp1=pp1->p_nback) { ! 69: if ((pp1->p_flags&PFCORE) != 0) { ! 70: pp1->p_sval >>= t; ! 71: pp1->p_ival -= t; ! 72: if (pp1->p_ival < -30000) ! 73: pp1->p_ival = -30000; ! 74: continue; ! 75: } ! 76: addu(pp1->p_sval, v); ! 77: if (pp1->p_state != PSRUN) ! 78: continue; ! 79: s = 0; ! 80: for (i=0; i<NUSEG+1; i++) ! 81: if ((sp=pp1->p_segp[i]) != NULL) ! 82: if ((sp->s_flags&SFCORE) == 0) ! 83: s += sp->s_size; ! 84: if ((s=ctokrd(s)) == 0) ! 85: s = 1; ! 86: n = (pp1->p_sval+pp1->p_rval)/s; ! 87: if (n > m) { ! 88: m = n; ! 89: pp2 = pp1; ! 90: } ! 91: } ! 92: unlock(pnxgate); ! 93: if (pp2 == NULL) { ! 94: if ( SELF->p_ssig != 0 ) ! 95: break; ! 96: goto con; ! 97: } ! 98: #if MONITOR ! 99: if (swmflag) ! 100: printf("Swapin(%p, %d)\n", pp2, pp2->p_pid); ! 101: #endif ! 102: xxx: ! 103: while (testcore(pp2)==0 || proccore(pp2)!=0) { ! 104: if ((pp2->p_flags&PFAUXM) != 0) { ! 105: auxmdisk(pp2); ! 106: goto xxx; ! 107: } ! 108: procdisk(pp2); ! 109: i = 32767; ! 110: pp3 = NULL; ! 111: lock(pnxgate); ! 112: for (pp1=procq.p_nforw; pp1!=&procq; pp1=pp1->p_nforw){ ! 113: if (pp1->p_flags&(PFSWIO|PFLOCK|PFKERN)) ! 114: continue; ! 115: if ((pp1->p_flags&PFAUXM) != 0) { ! 116: auxmdisk(pp1); ! 117: unlock(pnxgate); ! 118: goto xxx; ! 119: } ! 120: if ((pp1->p_flags&PFCORE) == 0) { ! 121: if (procdisk(pp1) != 0) { ! 122: unlock(pnxgate); ! 123: goto xxx; ! 124: } ! 125: continue; ! 126: } ! 127: if (pp1->p_ival>-64 && pp1->p_sval!=0) ! 128: continue; ! 129: if (pp1->p_ival < i) { ! 130: i = pp1->p_ival; ! 131: pp3 = pp1; ! 132: } ! 133: } ! 134: unlock(pnxgate); ! 135: if (pp3 == NULL) { ! 136: #if MONITOR ! 137: if (swmflag) ! 138: printf("No one to swap out\n"); ! 139: #endif ! 140: break; ! 141: } ! 142: if (i > 0) { ! 143: #if MONITOR ! 144: if (swmflag) ! 145: printf("Dispatch(%p, %d)\n", ! 146: pp3, pp3->p_pid); ! 147: #endif ! 148: pp3->p_flags |= PFDISP; ! 149: break; ! 150: } ! 151: #if MONITOR ! 152: if (swmflag) ! 153: printf("Swapout(%p, %d)\n", pp3, pp3->p_pid); ! 154: #endif ! 155: procdisk(pp3); ! 156: } ! 157: #if MONITOR ! 158: if (swmflag) ! 159: printf("Swapdone\n"); ! 160: #endif ! 161: con: ! 162: timeout(&stimer, NSRTICK, wakeup, (char *)&stimer); ! 163: v_sleep((char *)&stimer, CVSWAP, IVSWAP, SVSWAP, "swap"); ! 164: /* Unknown sleep in swapper. */ ! 165: } ! 166: --sexflag; ! 167: uexit(1); ! 168: } ! 169: ! 170: /* ! 171: * Swap all segments associated with a particular process into core. ! 172: * The number of segments still swapped out is returned. ! 173: */ ! 174: proccore(pp) ! 175: register PROC *pp; ! 176: { ! 177: register SEG *sp; ! 178: register int i; ! 179: register int n; ! 180: register int f; ! 181: ! 182: n = 0; ! 183: f = pp->p_flags&PFSWAP; ! 184: for (i=0; i<NUSEG+1; i++) { ! 185: if ((sp=pp->p_segp[i]) == NULL) ! 186: continue; ! 187: if (f != 0) ! 188: sp->s_lrefc++; ! 189: if ((sp->s_flags&SFCORE)==0 && segcore(sp)==0) ! 190: n++; ! 191: } ! 192: if (n == 0) ! 193: pp->p_flags |= PFCORE; ! 194: pp->p_flags &= ~PFSWAP; ! 195: return (n); ! 196: } ! 197: ! 198: /* ! 199: * Swap out all segments associated with a given process. ! 200: */ ! 201: procdisk(pp) ! 202: register PROC *pp; ! 203: { ! 204: register SEG *sp; ! 205: register int i; ! 206: register int f; ! 207: int n; ! 208: ! 209: n = 0; ! 210: f = pp->p_flags&PFSWAP; ! 211: pp->p_flags &= ~PFCORE; ! 212: for (i=0; i<NUSEG+1; i++) { ! 213: if ((sp=pp->p_segp[i]) == NULL) ! 214: continue; ! 215: if (f == 0) ! 216: --sp->s_lrefc; ! 217: if ((sp->s_flags&SFCORE) == 0) ! 218: continue; ! 219: if (sp->s_lrefc == 0) ! 220: if (segdisk(sp) != 0) ! 221: n++; ! 222: } ! 223: pp->p_flags |= PFSWAP; ! 224: return (n); ! 225: } ! 226: ! 227: /* ! 228: * Swap out all auxiliary segments used by a process. ! 229: */ ! 230: auxmdisk(pp) ! 231: register PROC *pp; ! 232: { ! 233: register SEG *sp; ! 234: register int i; ! 235: register int f; ! 236: register int m; ! 237: SEG *segl[NUSEG]; ! 238: ! 239: #if MONITOR ! 240: if (swmflag) ! 241: printf("Auxiliary(%p, %d)\n", pp, pp->p_pid); ! 242: #endif ! 243: sp = pp->p_segp[SIUSERP]; ! 244: if ((sp->s_flags&SFCORE) == 0) { ! 245: panic("We may be in trouble"); ! 246: return; ! 247: } ! 248: m = pp->p_flags&PFCORE; ! 249: f = pp->p_flags&PFAUXM; ! 250: pp->p_flags &= ~(PFAUXM|PFCORE); ! 251: skcopy(sp, offset(uproc, u_sege[0]), segl, sizeof(u.u_sege)); ! 252: for (i=0; i<NUSEG; i++) { ! 253: if ((sp=segl[i]) == NULL) ! 254: continue; ! 255: if (f != 0) ! 256: --sp->s_lrefc; ! 257: if ((sp->s_flags&SFCORE) == 0) ! 258: continue; ! 259: if (sp->s_lrefc == 0) ! 260: segdisk(sp); ! 261: } ! 262: pp->p_flags |= m; ! 263: } ! 264: ! 265: /* ! 266: * Swap the given segment into core. ! 267: */ ! 268: segcore(sp1) ! 269: register SEG *sp1; ! 270: { ! 271: register SEG *sp2; ! 272: ! 273: lock(seglink); ! 274: sp2 = xmalloc(sp1->s_size); ! 275: unlock(seglink); ! 276: if (sp2 == NULL) ! 277: return (0); ! 278: sp1->s_lrefc++; ! 279: swapio(0, sp2->s_mbase, sp1->s_dbase, sp2->s_size); ! 280: lock(seglink); ! 281: sp1->s_back->s_forw = sp1->s_forw; ! 282: sp1->s_forw->s_back = sp1->s_back; ! 283: sp2->s_back->s_forw = sp1; ! 284: sp1->s_back = sp2->s_back; ! 285: sp2->s_forw->s_back = sp1; ! 286: sp1->s_forw = sp2->s_forw; ! 287: sp1->s_flags |= SFCORE; ! 288: sp1->s_mbase = sp2->s_mbase; ! 289: --sp1->s_lrefc; ! 290: unlock(seglink); ! 291: return (1); ! 292: } ! 293: ! 294: /* ! 295: * Swap the given segment out onto disk. ! 296: */ ! 297: segdisk(sp1) ! 298: register SEG *sp1; ! 299: { ! 300: register SEG *sp2; ! 301: ! 302: lock(seglink); ! 303: sp2 = xdalloc(sp1->s_size); ! 304: unlock(seglink); ! 305: if (sp2 == NULL) ! 306: return (0); ! 307: sp1->s_lrefc++; ! 308: swapio(1, sp1->s_mbase, sp2->s_dbase, sp1->s_size); ! 309: lock(seglink); ! 310: sp1->s_back->s_forw = sp1->s_forw; ! 311: sp1->s_forw->s_back = sp1->s_back; ! 312: sp2->s_back->s_forw = sp1; ! 313: sp1->s_back = sp2->s_back; ! 314: sp2->s_forw->s_back = sp1; ! 315: sp1->s_forw = sp2->s_forw; ! 316: sp1->s_flags &= ~SFCORE; ! 317: sp1->s_dbase = sp2->s_dbase; ! 318: --sp1->s_lrefc; ! 319: unlock(seglink); ! 320: return (1); ! 321: } ! 322: ! 323: /* ! 324: * Allocate a segment on disk that is `n' clicks long. ! 325: * The `seglink' gate should be locked before this routine is called. ! 326: * This routine is the same as `sdalloc' except that we can't run out of ! 327: * alloc space to allocate the segment and we allocate in high regions. ! 328: */ ! 329: SEG * ! 330: xdalloc(s) ! 331: saddr_t s; ! 332: { ! 333: register SEG *sp1; ! 334: register SEG *sp2; ! 335: register daddr_t d; ! 336: register daddr_t d1; ! 337: register daddr_t d2; ! 338: ! 339: d = stod(s); ! 340: d2 = swaptop; ! 341: sp1 = &segdq; ! 342: do { ! 343: if ((sp1=sp1->s_back) != &segdq) ! 344: d1 = sp1->s_dbase + stod(sp1->s_size); ! 345: else ! 346: d1 = swapbot; ! 347: if (d2-d1 >= d) { ! 348: sp2 = &segswap; ! 349: kclear((char *)sp2, sizeof(SEG)); ! 350: sp1->s_forw->s_back = sp2; ! 351: sp2->s_forw = sp1->s_forw; ! 352: sp1->s_forw = sp2; ! 353: sp2->s_back = sp1; ! 354: sp2->s_urefc = 1; ! 355: sp2->s_lrefc = 1; ! 356: sp2->s_size = s; ! 357: sp2->s_dbase = d2 - d; ! 358: return (sp2); ! 359: } ! 360: d2 = sp1->s_dbase; ! 361: } while (sp1 != &segdq); ! 362: return (NULL); ! 363: } ! 364: ! 365: /* ! 366: * Allocate a segment in memory that is `n' clicks long. ! 367: * The `seglink' gate should be locked before this routine is called. ! 368: * This routine is the same as `smalloc' except that we can't run out of ! 369: * alloc space to allocate the segment. ! 370: */ ! 371: SEG * ! 372: xmalloc(s) ! 373: register saddr_t s; ! 374: { ! 375: register SEG *sp1; ! 376: register SEG *sp2; ! 377: register saddr_t s1; ! 378: register saddr_t s2; ! 379: ! 380: s1 = corebot; ! 381: sp1 = &segmq; ! 382: do { ! 383: if ((sp1=sp1->s_forw) != &segmq) ! 384: s2 = sp1->s_mbase; ! 385: else ! 386: s2 = coretop; ! 387: if (s2-s1 >= s) { ! 388: sp2 = &segswap; ! 389: kclear((char *)sp2, sizeof(SEG)); ! 390: sp1->s_back->s_forw = sp2; ! 391: sp2->s_back = sp1->s_back; ! 392: sp1->s_back = sp2; ! 393: sp2->s_forw = sp1; ! 394: sp2->s_urefc = 1; ! 395: sp2->s_lrefc = 1; ! 396: sp2->s_size = s; ! 397: sp2->s_mbase = s1; ! 398: return (sp2); ! 399: } ! 400: s1 = sp1->s_mbase + sp1->s_size; ! 401: } while (sp1 != &segmq); ! 402: return (NULL); ! 403: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.