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