![[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 [Plan 9 NeXT] / lucent / sys / src / 9 / port|
Return to swap.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port |
1.1 root 1: #include "u.h"
2: #include "../port/lib.h"
3: #include "mem.h"
4: #include "dat.h"
5: #include "fns.h"
6: #include "../port/error.h"
7:
8: int canflush(Proc *p, Segment*);
9: void executeio(void);
10: int needpages(void*);
11: void pageout(Proc *p, Segment*);
12: void pagepte(int, Page**);
13: void pager(void*);
14:
15: Image swapimage;
16: static int swopen;
17: static Page **iolist;
18: static int ioptr;
19: static int maxpages;
20:
21: void
22: swapinit(void)
23: {
24: swapalloc.swmap = xalloc(conf.nswap);
25: swapalloc.top = &swapalloc.swmap[conf.nswap];
26: swapalloc.alloc = swapalloc.swmap;
27: swapalloc.last = swapalloc.swmap;
28: swapalloc.free = conf.nswap;
29: maxpages = SEGMAXSIZE/BY2PG;
30: if(maxpages > conf.nswap/2)
31: maxpages = conf.nswap/2;
32: iolist = xalloc(maxpages*sizeof(Page*));
33: if(swapalloc.swmap == 0 || iolist == 0)
34: panic("swapinit: not enough memory");
35: }
36:
37: ulong
38: newswap(void)
39: {
40: uchar *look;
41:
42: lock(&swapalloc);
43: if(swapalloc.free == 0)
44: panic("out of swap space");
45:
46: look = memchr(swapalloc.last, 0, swapalloc.top-swapalloc.last);
47: if(look == 0)
48: panic("inconsistent swap");
49:
50: *look = 1;
51: swapalloc.last = look;
52: swapalloc.free--;
53: unlock(&swapalloc);
54: return (look-swapalloc.swmap) * BY2PG;
55: }
56:
57: void
58: putswap(Page *p)
59: {
60: uchar *idx;
61:
62: lock(&swapalloc);
63: idx = &swapalloc.swmap[((ulong)p)/BY2PG];
64: if(--(*idx) == 0) {
65: swapalloc.free++;
66: if(idx < swapalloc.last)
67: swapalloc.last = idx;
68: }
69: unlock(&swapalloc);
70: }
71:
72: void
73: dupswap(Page *p)
74: {
75: lock(&swapalloc);
76: swapalloc.swmap[((ulong)p)/BY2PG]++;
77: unlock(&swapalloc);
78: }
79:
80: void
81: kickpager(void)
82: {
83: static int started;
84:
85: if(started)
86: wakeup(&swapalloc.r);
87: else {
88: kproc("pager", pager, 0);
89: started = 1;
90: }
91: }
92:
93: void
94: pager(void *junk)
95: {
96: int i;
97: Proc *p, *ep;
98: Segment *s, *ts;
99:
100: if(waserror())
101: panic("pager: os error\n");
102:
103: USED(junk);
104: p = proctab(0);
105: ep = &p[conf.nproc];
106:
107: loop:
108: u->p->psstate = "Idle";
109: sleep(&swapalloc.r, needpages, 0);
110:
111: while(needpages(junk)) {
112: p++;
113: if(p >= ep)
114: p = proctab(0);
115:
116: if(p->state == Dead || p->kp)
117: continue;
118:
119: /* don't swap out programs from devroot.c - they
120: * supply important system services
121: */
122: ts = p->seg[TSEG];
123: if(ts && ts->image && devchar[ts->image->c->type] == '/')
124: continue;
125:
126: if(swapimage.c) {
127: for(i = 0; i < NSEG; i++) {
128: if(!needpages(junk))
129: goto loop;
130:
131: if(s = p->seg[i]) {
132: switch(s->type&SG_TYPE) {
133: default:
134: break;
135: case SG_TEXT:
136: pageout(p, s);
137: break;
138: case SG_DATA:
139: case SG_BSS:
140: case SG_STACK:
141: case SG_SHARED:
142: u->p->psstate = "Pageout";
143: pageout(p, s);
144: if(ioptr != 0) {
145: u->p->psstate = "I/O";
146: executeio();
147: }
148: }
149: }
150: }
151: continue;
152: }
153:
154: if(palloc.freecount < swapalloc.highwater) {
155: if(!cpuserver)
156: freebroken(); /* can use the memory */
157:
158: /* Emulate the old system if no swap channel */
159: print("no physical memory\n");
160: tsleep(&swapalloc.r, return0, 0, 1000);
161: wakeup(&palloc.r);
162: }
163: }
164: goto loop;
165: }
166:
167: void
168: pageout(Proc *p, Segment *s)
169: {
170: int type, i;
171: Pte *l;
172: Page **pg, *entry;
173:
174: if(!canqlock(&s->lk)) /* We cannot afford to wait, we will surely deadlock */
175: return;
176:
177: if(s->steal) { /* Protected by /dev/proc */
178: qunlock(&s->lk);
179: return;
180: }
181:
182: if(!canflush(p, s)) { /* Able to invalidate all tlbs with references */
183: qunlock(&s->lk);
184: putseg(s);
185: return;
186: }
187:
188: if(waserror()) {
189: qunlock(&s->lk);
190: putseg(s);
191: return;
192: }
193:
194: /* Pass through the pte tables looking for memory pages to swap out */
195: type = s->type&SG_TYPE;
196: for(i = 0; i < SEGMAPSIZE; i++) {
197: l = s->map[i];
198: if(l == 0)
199: continue;
200: for(pg = l->first; pg < l->last; pg++) {
201: entry = *pg;
202: if(pagedout(entry))
203: continue;
204:
205: if(entry->modref & PG_REF) {
206: entry->modref &= ~PG_REF;
207: continue;
208: }
209:
210: while(swapalloc.free == 0) {
211: if(ioptr != 0)
212: goto out;
213:
214: print("out of swap space\n");
215: tsleep(&swapalloc.r, return0, 0, 1000);
216: }
217:
218: pagepte(type, pg);
219:
220: if(ioptr >= maxpages)
221: goto out;
222: }
223: }
224: out:
225: poperror();
226: qunlock(&s->lk);
227: putseg(s);
228: wakeup(&palloc.r);
229: }
230:
231: int
232: canflush(Proc *p, Segment *s)
233: {
234: int i;
235: Proc *ep;
236:
237: lock(s);
238: if(s->ref == 1) { /* Easy if we are the only user */
239: s->ref++;
240: unlock(s);
241: return canpage(p);
242: }
243: s->ref++;
244: unlock(s);
245:
246: /* Now we must do hardwork to ensure all processes which have tlb
247: * entries for this segment will be flushed if we suceed in pageing it out
248: */
249: p = proctab(0);
250: ep = &p[conf.nproc];
251: while(p < ep) {
252: if(p->state != Dead) {
253: for(i = 0; i < NSEG; i++)
254: if(p->seg[i] == s)
255: if(!canpage(p))
256: return 0;
257: }
258: p++;
259: }
260: return 1;
261: }
262:
263: void
264: pagepte(int type, Page **pg)
265: {
266: ulong daddr;
267: Page *outp;
268:
269: outp = *pg;
270: switch(type) {
271: case SG_TEXT: /* Revert to demand load */
272: putpage(outp);
273: *pg = 0;
274: break;
275:
276: case SG_DATA:
277: case SG_BSS:
278: case SG_STACK:
279: case SG_SHARED:
280: case SG_SHDATA:
281: daddr = newswap();
282: cachedel(&swapimage, daddr);
283: lock(outp);
284: outp->ref++;
285: uncachepage(outp);
286: unlock(outp);
287:
288: /* Enter swap page into cache before segment is unlocked so that
289: * a fault will cause a cache recovery rather than a pagein on a
290: * partially written block.
291: */
292: outp->daddr = daddr;
293: cachepage(outp, &swapimage);
294: *pg = (Page*)(daddr|PG_ONSWAP);
295:
296: /* Add me to IO transaction list */
297: iolist[ioptr++] = outp;
298: }
299: }
300:
301: void
302: executeio(void)
303: {
304: Page *out;
305: int i, n;
306: Chan *c;
307: char *kaddr;
308: KMap *k;
309:
310: c = swapimage.c;
311:
312: for(i = 0; i < ioptr; i++) {
313: out = iolist[i];
314: k = kmap(out);
315: kaddr = (char*)VA(k);
316:
317: if(waserror())
318: panic("executeio: page out I/O error");
319:
320: n = (*devtab[c->type].write)(c, kaddr, BY2PG, out->daddr);
321: if(n != BY2PG)
322: nexterror();
323:
324: kunmap(k);
325: poperror();
326:
327: /* Free up the page after I/O */
328: lock(out);
329: out->ref--;
330: unlock(out);
331: putpage(out);
332: }
333: ioptr = 0;
334: }
335:
336: int
337: needpages(void *p)
338: {
339: USED(p);
340: return palloc.freecount < swapalloc.headroom;
341: }
342:
343: void
344: setswapchan(Chan *c)
345: {
346: if(swapimage.c) {
347: if(swapalloc.free != conf.nswap)
348: error(Einuse);
349: close(swapimage.c);
350: }
351: incref(c);
352: swapimage.c = c;
353: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.