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