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