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