![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vmpage.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / vm|
Return to vmpage.c CVS log | Up to [Research Unix] / researchv10no / sys / vm |
1.1 root 1: #include "sys/param.h"
2: #include "sys/systm.h"
3: #include "sys/inode.h"
4: #include "sys/user.h"
5: #include "sys/proc.h"
6: #include "sys/pte.h"
7: #include "sys/buf.h"
8: #include "sys/text.h"
9: #include "sys/mtpr.h"
10: #include "sys/cmap.h"
11: #include "sys/vm.h"
12:
13: struct pte *Pushmap;
14: struct user *pushutl;
15:
16: int nohash = 0;
17: /*
18: * Handle a page fault.
19: *
20: * Basic outline
21: * If page is allocated, but just not valid:
22: * Wait if intransit, else just revalidate
23: * Done
24: * Compute <dev,bn> from which page operation would take place
25: * If page is text page, and filling from file system or swap space:
26: * If in free list cache, reattach it and then done
27: * Allocate memory for page in
28: * If block here, restart because we could have swapped, etc.
29: * Lock process from swapping for duration
30: * Update pte's to reflect that page is intransit.
31: * If page is zero fill on demand:
32: * Clear pages and flush free list cache of stale cacheing
33: * for this swap page (e.g. before initializing again due
34: * to 407/410 exec).
35: * If page is fill from file and in buffer cache:
36: * Copy the page from the buffer cache.
37: * If not a fill on demand:
38: * Determine swap address and cluster to page in
39: * Do the swap to bring the page in
40: * Instrument the pagein
41: * After swap validate the required new page
42: * Leave prepaged pages reclaimable (not valid)
43: * Update shared copies of text page tables
44: * Complete bookkeeping on pages brought in:
45: * No longer intransit
46: * Hash text pages into core hash structure
47: * Unlock pages (modulo raw i/o requirements)
48: * Flush translation buffer
49: * Process pagein is done
50: */
51: int preptofree = 1; /* send pre-paged pages to free list */
52: static struct cmap dbcmap; /* debug */
53:
54: pagein(virtaddr,uu)
55: caddr_t virtaddr;
56: register struct user *uu;
57: {
58: register struct proc *p;
59: register struct pte *pte;
60: register unsigned v;
61: unsigned pf;
62: int type, fileno, prot;
63: struct pte opte;
64: struct buf *bp;
65: dev_t dev;
66: register int i;
67: int klsize;
68: unsigned vsave;
69: struct cmap *c;
70: int j;
71: daddr_t bn, bncache, bnswap;
72: int otime, olbolt, oicr, a, s;
73:
74: s = spl6();
75: otime = time, olbolt = lbolt, oicr = mfpr(ICR);
76: cnt.v_faults++;
77: /*
78: * Classify faulted page into a segment and get a pte
79: * for the faulted page.
80: */
81: vsave = v = clbase(btop((unsigned int)virtaddr));
82: p = uu->u_procp;
83: if (isatsv(p, v))
84: type = CTEXT;
85: else if (isassv(p, v))
86: type = CSTACK;
87: else
88: type = CDATA;
89: pte = vtopte(p, v);
90: if (pte->pg_v)
91: panic("pagein");
92:
93: /*
94: * If page is reclaimable, reclaim it.
95: * If page is text and intransit, sleep while it is intransit,
96: * If it is valid after the sleep, we are done.
97: * Otherwise we have to start checking again, since page could
98: * even be reclaimable now (we may have swapped for a long time).
99: */
100: restart:
101: if (pte->pg_fod == 0 && pte->pg_pfnum) {
102: if (type == CTEXT && cmap[pgtocm(pte->pg_pfnum)].c_intrans) {
103: sleep((caddr_t)p->p_textp, PSWP+1);
104: pte = vtopte(p, v);
105: if (pte->pg_v) {
106: valid:
107: if (p->p_flag & SDLYU) {
108: mlock(pte->pg_pfnum);
109: if (!pte->pg_v) {
110: munlock(pte->pg_pfnum);
111: goto restart;
112: }
113: }
114: tbiscl(v);
115: cnt.v_intrans++;
116: return;
117: }
118: goto restart;
119: }
120: /*
121: * If page is in the free list, then take
122: * it back into the resident set, updating
123: * the size recorded for the resident set.
124: */
125: if (cmap[pgtocm(pte->pg_pfnum)].c_free) {
126: munlink(pte->pg_pfnum);
127: cnt.v_pgfrec++;
128: if (type == CTEXT)
129: p->p_textp->x_rssize += CLSIZE;
130: else
131: p->p_rssize += CLSIZE;
132: }
133: pte->pg_v = 1;
134: if (anycl(pte, pg_m))
135: pte->pg_m = 1;
136: distcl(pte);
137: if (type == CTEXT)
138: distpte(p->p_textp, vtotp(p, v), pte);
139: if (p->p_flag & SDLYU) {
140: mlock(pte->pg_pfnum);
141: if (!pte->pg_v) {
142: munlock(pte->pg_pfnum);
143: goto restart;
144: }
145: }
146: uu->u_vm.vm_minflt++;
147: cnt.v_pgrec++;
148: tbiscl(v);
149: a = vmtime(otime, olbolt, oicr);
150: rectime += a;
151: if (a >= 0)
152: vmfltmon(rmon, a, rmonmin, rres, NRMON);
153: splx(s);
154: return;
155: }
156: splx(s);
157: /*
158: * <dev,bn> is where data comes from/goes to.
159: * <dev,bncache> is where data is cached from/to.
160: * <swapdev,bnswap> is where data will eventually go.
161: */
162: if (pte->pg_fod == 0) {
163: fileno = -1;
164: bnswap = bncache = bn = dbtofsb(swapdev,
165: vtod(p, v, &uu->u_dmap, &uu->u_smap));
166: dev = swapdev;
167: } else {
168: fileno = ((struct fpte *)pte)->pg_source;
169: bn = ((struct fpte *)pte)->pg_blkno;
170: bnswap = dbtofsb(swapdev, vtod(p, v, &uu->u_dmap, &uu->u_smap));
171: if (fileno == PG_FTEXT) {
172: if (p->p_textp == 0)
173: panic("pagein PG_FTEXT");
174: dev = p->p_textp->x_iptr->i_dev;
175: bncache = bn;
176: } else { /* PG_FZERO */
177: dev = swapdev;
178: bncache = bnswap;
179: }
180: }
181: klsize = 1;
182: opte = *pte;
183:
184: /*
185: * Check for text detached but in free list.
186: * This can happen only if the page is filling
187: * from a inode or from the swap device, (e.g. not when reading
188: * in 407/410 execs to a zero fill page.)
189: * honour lock bit to avoid race with pageout
190: */
191: if (type == CTEXT && fileno != PG_FZERO && !nohash) {
192: while ((c = mfind(getfsx(dev), bncache)) != 0) {
193: pf = cmtopg(c - cmap);
194: if (c->c_lock == 0)
195: break;
196: mlock(pf);
197: munlock(pf);
198: }
199: if (c) {
200: dbcmap = *c;
201: if (c->c_type != CTEXT || c->c_gone == 0 ||
202: c->c_free == 0)
203: panic("pagein mfind");
204: p->p_textp->x_rssize += CLSIZE;
205: /*
206: * Following code mimics memall().
207: */
208: pf = cmtopg(c - cmap);
209: munlink(pf);
210: for (j = 0; j < CLSIZE; j++) {
211: *(int *)pte = pf++;
212: pte->pg_prot = opte.pg_prot;
213: pte++;
214: }
215: pte -= CLSIZE;
216: c->c_free = 0;
217: c->c_gone = 0;
218: if (c->c_intrans || c->c_want)
219: panic("pagein intrans|want");
220: c->c_lock = 1;
221: if (c->c_page != vtotp(p, v))
222: panic("pagein c_page chgd");
223: c->c_ndx = p->p_textp - &text[0];
224: if (dev == swapdev)
225: cnt.v_xsfrec++;
226: else
227: cnt.v_xifrec++;
228: cnt.v_pgrec++;
229: uu->u_vm.vm_minflt++;
230: if (dev != swapdev) {
231: c = mfind(MSWAPX, bnswap);
232: if (c)
233: munhash(MSWAPX, bnswap);
234: pte->pg_swapm = 1;
235: }
236: goto skipswap;
237: }
238: }
239:
240: /*
241: * Wasn't reclaimable or reattachable.
242: * Have to prepare to bring the page in.
243: * We allocate the page before locking so we will
244: * be swappable if there is no free memory.
245: * If we block we have to start over, since anything
246: * could have happened.
247: */
248: if (freemem < CLSIZE * KLMAX) {
249: while (freemem < CLSIZE * KLMAX)
250: sleep((caddr_t)&freemem, PSWP+2);
251: pte = vtopte(p, v);
252: if (pte->pg_v)
253: goto valid;
254: goto restart;
255: }
256:
257: /*
258: * Now can get memory and committed to bringing in the page.
259: * Lock this process, get a page,
260: * construct the new pte, and increment
261: * the (process or text) resident set size.
262: */
263: p->p_flag |= SPAGE;
264: (void) memall(pte, CLSIZE, p, type);
265: pte->pg_prot = opte.pg_prot;
266: pf = pte->pg_pfnum;
267: cmap[pgtocm(pf)].c_intrans = 1;
268: distcl(pte);
269: if (type == CTEXT) {
270: p->p_textp->x_rssize += CLSIZE;
271: distpte(p->p_textp, vtotp(p, v), pte);
272: } else
273: p->p_rssize += CLSIZE;
274:
275: /*
276: * Two cases: either fill on demand (zero or text)
277: * or from swap space.
278: */
279: if (opte.pg_fod) {
280: pte->pg_swapm = 1;
281: if (fileno == PG_FZERO || fileno == PG_FTEXT) {
282: /*
283: * Flush any previous text page use of this
284: * swap device block.
285: */
286: if (type == CTEXT) {
287: c = mfind(MSWAPX, bnswap);
288: if (c)
289: munhash(MSWAPX, bnswap);
290: }
291: /*
292: * If zero fill, short-circuit hard work
293: * by just clearing pages.
294: */
295: if (fileno == PG_FZERO) {
296: for (i = 0; i < CLSIZE; i++)
297: clearseg(pf+i);
298: if (type != CTEXT)
299: cnt.v_zfod += CLSIZE;
300: goto skipswap;
301: }
302: cnt.v_exfod += CLSIZE;
303: } else
304: /*
305: * Vreading block... whoops
306: */
307: panic("pagein, vrpages ref'd");
308: /*
309: * Check that block is not in file system buffer cache.
310: * The way the cache is handled now, this
311: * happens only once every 2 days.
312: */
313: if (bp = baddr(dev, bn)) {
314: pte->pg_v = 1;
315: prot = *(int *)pte & PG_PROT;
316: pte->pg_prot = 0;
317: *(int *)pte |= PG_UW;
318: distcl(pte);
319: tbiscl(v);
320: /* THIS ASSUMES THAT CLSIZE*NBPG==BSIZE */
321: bcopy(bp->b_un.b_addr, ptob(v), BSIZE(dev));
322: brelse(bp);
323: pte->pg_prot = 0;
324: *(int *)pte |= prot;
325: goto skipswap;
326: }
327: } else {
328: if (opte.pg_pfnum)
329: panic("pagein pfnum");
330: /*
331: * Fill from swap area. Try to find adjacent
332: * pages to bring in also.
333: */
334: v = kluster(p, v, pte, B_READ, &klsize,
335: (type == CTEXT) ? kltxt :
336: ((p->p_flag & SSEQL) ? klseql : klin), bn);
337: /* THIS COULD BE COMPUTED INCREMENTALLY... */
338: bncache = bn = dbtofsb(swapdev, vtod(p, v, &uu->u_dmap, &uu->u_smap));
339: }
340:
341: distcl(pte);
342: swap(p, fsbtodb(dev, bn), ptob(v), klsize * ctob(CLSIZE),
343: B_READ, B_PGIN, dev, 0);
344:
345: /*
346: * Instrumentation.
347: */
348: uu->u_vm.vm_majflt++;
349: cnt.v_pgin++;
350: cnt.v_pgpgin += klsize * CLSIZE;
351: a = vmtime(otime, olbolt, oicr) / 100;
352: pgintime += a;
353: if (a >= 0)
354: vmfltmon(pmon, a, pmonmin, pres, NPMON);
355:
356: skipswap:
357: /*
358: * Fix page table entries.
359: *
360: * Only page requested in is validated, and rest of pages
361: * can be ``reclaimed''. This allows system to reclaim prepaged pages
362: * quickly if they are not used and memory is tight.
363: */
364: pte = vtopte(p, vsave);
365: pte->pg_v = 1;
366: distcl(pte);
367: if (type == CTEXT) {
368: distpte(p->p_textp, vtotp(p, vsave), pte);
369: if (opte.pg_fod)
370: p->p_textp->x_flag |= XWRIT;
371: wakeup((caddr_t)p->p_textp);
372: }
373:
374: /*
375: * Memall returned page(s) locked. Unlock all
376: * pages in cluster. If locking pages for raw i/o
377: * leave the page which was required to be paged in locked,
378: * but still unlock others.
379: * If text pages, hash into the cmap situation table.
380: */
381: pte = vtopte(p, v);
382: for (i = 0; i < klsize; i++) {
383: c = &cmap[pgtocm(pte->pg_pfnum)];
384: c->c_intrans = 0;
385: if (type == CTEXT && c->c_blkno == 0 && bncache && !nohash) {
386: mhash(c, getfsx(dev), bncache);
387: bncache++;
388: }
389: if (v != vsave || (p->p_flag & SDLYU) == 0)
390: munlock(pte->pg_pfnum);
391: if (v != vsave && type != CTEXT && preptofree) {
392: /*
393: * Throw pre-paged data/stack pages at the
394: * bottom of the free list.
395: */
396: p->p_rssize -= CLSIZE;
397: memfree(pte, CLSIZE, 0);
398: }
399: tbiscl(v); /* conservative ? */
400: v += CLSIZE;
401: pte += CLSIZE;
402: }
403:
404: /*
405: * All done.
406: */
407: p->p_flag &= ~SPAGE;
408: if (p->p_flag & SPROCWT) {
409: register s = spl6();
410: p->p_flag &= ~SPROCWT;
411: p->p_usrpri = 127;
412: wakeup((caddr_t)&(p->p_stat));
413: ++runrun;
414: splx(s);
415: }
416:
417: /*
418: * If process is declared fifo, memory is tight,
419: * and this was a data page-in, free memory
420: * klsdist pagein clusters away from the current fault.
421: */
422: if ((p->p_flag&SSEQL) && freemem < lotsfree &&
423: type == CDATA && p == u.u_procp) {
424: int k = (vtodp(p, vsave) / CLSIZE) / klseql;
425: #ifdef notdef
426: if (vsave > uu->u_vsave)
427: k -= klsdist;
428: else
429: k += klsdist;
430: dpageout(p, k * klseql * CLSIZE, klout*CLSIZE);
431: uu->u_vsave = vsave;
432: #else
433: dpageout(p, (k - klsdist) * klseql * CLSIZE, klout*CLSIZE);
434: dpageout(p, (k + klsdist) * klseql * CLSIZE, klout*CLSIZE);
435: #endif
436: }
437: }
438:
439: #if defined(BERT)
440: int dmod = 1000000;
441: int dcnt;
442: #endif
443: /*
444: * Take away n pages of data space
445: * starting at data page dp.
446: * Used to take pages away from sequential processes.
447: * Mimics pieces of code in pageout() below.
448: */
449: dpageout(p, dp, n)
450: struct proc *p;
451: int dp, n;
452: {
453: register struct cmap *c;
454: int i, klsize;
455: register struct pte *pte;
456: unsigned v;
457: daddr_t daddr;
458:
459: if (dp < 0) {
460: n += dp;
461: dp = 0;
462: }
463: if (dp + n > p->p_dsize)
464: n = p->p_dsize - dp;
465: #if defined(BERT)
466: if (++dcnt % dmod == 0)
467: printf("dp %d, n %d\n", dp, n);
468: #endif
469: for (i = 0; i < n; i += CLSIZE, dp += CLSIZE) {
470: pte = dptopte(p, dp);
471: if (pte->pg_fod || pte->pg_pfnum == 0)
472: continue;
473: c = &cmap[pgtocm(pte->pg_pfnum)];
474: if (c->c_lock || c->c_free)
475: continue;
476: if (pte->pg_v) {
477: pte->pg_v = 0;
478: if (anycl(pte, pg_m))
479: pte->pg_m = 1;
480: distcl(pte);
481: }
482: if (dirtycl(pte)) {
483: if (bswlist.av_forw == NULL)
484: continue;
485: mlock(pte->pg_pfnum);
486: if (anycl(pte, pg_m)) {
487: pte->pg_m = 0;
488: }
489: pte->pg_swapm = 0;
490: distcl(pte);
491: p->p_poip++;
492: v = kluster(p, dptov(p, dp), pte, B_WRITE,
493: &klsize, klout, (daddr_t)0);
494: /* THIS ASSUMES THAT p == u.u_procp */
495: daddr = vtod(p, v, &u.u_dmap, &u.u_smap);
496: swap(p, daddr, ptob(v), klsize * ctob(CLSIZE),
497: B_WRITE, B_DIRTY, swapdev, pte->pg_pfnum);
498: } else {
499: if (c->c_gone == 0)
500: p->p_rssize -= CLSIZE;
501: memfree(pte, CLSIZE, 0);
502: cnt.v_seqfree += CLSIZE;
503: }
504: }
505: }
506:
507: int fifo = 0;
508: /*
509: * The page out daemon, which runs as process 2.
510: *
511: * As long as there are at least lotsfree pages,
512: * this process is not run. When the number of free
513: * pages stays in the range desfree to lotsfree,
514: * this daemon runs through the pages in the loop
515: * at a rate determined in vmsched(), simulating the missing
516: * hardware reference bit, and cleaning pages and transferring
517: * them to the free list.
518: */
519: int hand;
520: pageout()
521: {
522: register struct proc *rp;
523: register struct text *xp;
524: register struct cmap *c;
525: register struct pte *pte;
526: int count, pushes;
527: swblk_t daddr;
528: unsigned v;
529: int maxhand = pgtocm(maxfree);
530: int klsize;
531:
532: loop:
533: /*
534: * Before sleeping, look to see if there are any swap I/O headers
535: * in the ``cleaned'' list that correspond to dirty
536: * pages that have been pushed asynchronously. If so,
537: * empty the list by calling cleanup().
538: *
539: * N.B.: We guarantee never to block while the cleaned list is nonempty.
540: */
541: (void) spl6();
542: if (bclnlist != NULL)
543: cleanup();
544: sleep((caddr_t)&proc[PAGEPID], PSWP+1);
545: (void) spl0();
546: count = 0;
547: pushes = 0;
548: while (nscan < desscan && freemem < lotsfree) {
549: top:
550: /*
551: * An iteration of the clock pointer (hand) around the loop.
552: * Look at the page at hand. If it is a
553: * locked (for physical i/o e.g.), system (u., page table)
554: * or free, then leave it alone.
555: * Otherwise, find a process and text pointer for the
556: * page, and a virtual page number in either the
557: * process or the text image.
558: */
559: c = &cmap[hand];
560: if (c->c_lock || c->c_free)
561: goto skip;
562: switch (c->c_type) {
563:
564: case CSYS:
565: goto skip;
566:
567: case CTEXT:
568: xp = &text[c->c_ndx];
569: rp = xp->x_caddr;
570: v = tptov(rp, c->c_page);
571: pte = tptopte(rp, c->c_page);
572: break;
573:
574: case CDATA:
575: case CSTACK:
576: rp = &proc[c->c_ndx];
577: /* xp = rp->p_textp; */
578: if (c->c_type == CDATA) {
579: v = dptov(rp, c->c_page);
580: pte = dptopte(rp, c->c_page);
581: } else {
582: v = sptov(rp, c->c_page);
583: pte = sptopte(rp, c->c_page);
584: }
585: break;
586: }
587: if (pte->pg_pfnum != cmtopg(hand))
588: panic("bad c_page");
589: /*
590: * If page is valid; make invalid but reclaimable.
591: * If this pte is not valid, then it must be reclaimable
592: * and we can add it to the free list.
593: */
594: if (pte->pg_v) {
595: pte->pg_v = 0;
596: if (anycl(pte, pg_m))
597: pte->pg_m = 1;
598: distcl(pte);
599: if (c->c_type == CTEXT)
600: distpte(xp, vtotp(rp, v), pte);
601: if ((rp->p_flag & (SSEQL|SUANOM)) || fifo ||
602: rp->p_rssize > rp->p_maxrss)
603: goto take;
604: } else {
605: take:
606: if (c->c_type != CTEXT) {
607: /*
608: * Guarantee a minimal investment in data
609: * space for jobs in balance set.
610: */
611: if (rp->p_rssize < saferss - rp->p_slptime)
612: goto skip;
613: }
614:
615: /*
616: * If the page is currently dirty, we
617: * have to arrange to have it cleaned before it
618: * can be freed. We mark it clean immediately.
619: * If it is reclaimed while being pushed, then modified
620: * again, we are assured of the correct order of
621: * writes because we lock the page during the write.
622: * This guarantees that a swap() of this process (and
623: * thus this page), initiated in parallel, will,
624: * in fact, push the page after us.
625: *
626: * The most general worst case here would be for
627: * a reclaim, a modify and a swapout to occur
628: * all before the single page transfer completes.
629: */
630: if (dirtycl(pte)) {
631: /*
632: * Limit pushes to avoid saturating
633: * pageout device.
634: *
635: * MAGIC 4 BECAUSE WE RUN EVERY 1/4 SEC (clock)
636: */
637: if (pushes > maxpgio / 4)
638: goto skip;
639: pushes++;
640: /*
641: * If the process is being swapped out
642: * or about to exit, do not bother with its
643: * dirty pages
644: */
645: if (rp->p_flag & (SLOCK|SWEXIT))
646: goto skip;
647:
648: /*
649: * Now carefully make sure that there will
650: * be a header available for the push so that
651: * we will not block waiting for a header in
652: * swap(). The reason this is important is
653: * that we (proc[PAGEPID]) are the one who cleans
654: * dirty swap headers and we could otherwise
655: * deadlock waiting for ourselves to clean
656: * swap headers. The sleep here on &proc[PAGEPID]
657: * is actually (effectively) a sleep on both
658: * ourselves and &bswlist, and this is known
659: * to iodone and swap in bio.c. That is,
660: * &proc[PAGEPID] will be awakened both when dirty
661: * headers show up and also to get the pageout
662: * daemon moving.
663: */
664: (void) spl6();
665: if (bclnlist != NULL)
666: cleanup();
667: if (bswlist.av_forw == NULL) {
668: bswlist.b_flags |= B_WANTED;
669: sleep((caddr_t)&proc[PAGEPID], PSWP+2);
670: (void) spl0();
671: /*
672: * Page disposition may have changed
673: * since process may have exec'ed,
674: * forked, exited or just about
675: * anything else... try this page
676: * frame again, from the top.
677: */
678: goto top;
679: }
680: (void) spl0();
681:
682: mlock((unsigned)cmtopg(hand));
683: uaccess(rp, Pushmap, pushutl);
684: /*
685: * Now committed to pushing the page...
686: */
687: if (anycl(pte, pg_m)) {
688: pte->pg_m = 0;
689: }
690: pte->pg_swapm = 0;
691: distcl(pte);
692: if (c->c_type == CTEXT) {
693: xp->x_poip++;
694: distpte(xp, vtotp(rp, v), pte);
695: } else
696: rp->p_poip++;
697: v = kluster(rp, v, pte, B_WRITE, &klsize, klout, (daddr_t)0);
698: if (klsize == 0)
699: panic("pageout klsize");
700: daddr = vtod(rp, v, &pushutl->u_dmap, &pushutl->u_smap);
701: swap(rp, daddr, ptob(v), klsize * ctob(CLSIZE),
702: B_WRITE, B_DIRTY, swapdev, pte->pg_pfnum);
703: /*
704: * The cleaning of this page will be
705: * completed later, in cleanup() called
706: * (synchronously) by us (proc[PAGEPID]). In
707: * the meantime, the page frame is locked
708: * so no havoc can result.
709: */
710: goto skip;
711:
712: }
713: /*
714: * Decrement the resident set size of the current
715: * text object/process, and put the page in the
716: * free list. Note that we don't give memfree the
717: * pte as its argument, since we don't want to destroy
718: * the pte. If it hasn't already been discarded
719: * it may yet have a chance to be reclaimed from
720: * the free list.
721: */
722: if (c->c_gone == 0)
723: if (c->c_type == CTEXT)
724: xp->x_rssize -= CLSIZE;
725: else
726: rp->p_rssize -= CLSIZE;
727: memfree(pte, CLSIZE, 0);
728: cnt.v_dfree += CLSIZE;
729:
730: /*
731: * We managed to add a page to the free list,
732: * so we give ourselves another couple of trips
733: * around the loop.
734: */
735: count = 0;
736: }
737: skip:
738: cnt.v_scan++;
739: nscan++;
740: if (++hand >= maxhand) {
741: hand = 0;
742: cnt.v_rev++;
743: if (count > 2) {
744: /*
745: * Extremely unlikely, but we went around
746: * the loop twice and didn't get anywhere.
747: * Don't cycle, stop till the next clock tick.
748: */
749: goto loop;
750: }
751: count++;
752: }
753: }
754: goto loop;
755: }
756:
757: /*
758: * Process the ``cleaned'' list.
759: *
760: * Scan through the linked list of swap I/O headers
761: * and free the corresponding pages that have been
762: * cleaned by being written back to the paging area.
763: * If the page has been reclaimed during this time,
764: * we do not free the page. As they are processed,
765: * the swap I/O headers are removed from the cleaned
766: * list and inserted into the free list.
767: */
768: cleanup()
769: {
770: register struct buf *bp;
771: register struct proc *rp;
772: register struct text *xp;
773: register struct cmap *c;
774: register struct pte *pte;
775: unsigned pf;
776: register int i;
777: int s;
778:
779: for (;;) {
780: s = spl6();
781: if ((bp = bclnlist) == NULL) {
782: splx(s);
783: break;
784: }
785: bclnlist = bp->av_forw;
786: splx(s);
787: pte = dptopte(&proc[PAGEPID], btop(bp->b_un.b_addr));
788: for (i = 0; i < bp->b_bcount; i += CLSIZE * NBPG) {
789: pf = pte->pg_pfnum;
790: munlock(pf);
791: c = &cmap[pgtocm(pf)];
792: if (c->c_gone) {
793: memfree(pte, CLSIZE, 0);
794: cnt.v_dfree += CLSIZE;
795: }
796: pte += CLSIZE;
797: }
798: c = &cmap[pgtocm(bp->b_pfcent)];
799: switch (c->c_type) {
800:
801: case CSYS:
802: panic("cleanup CSYS");
803:
804: case CTEXT:
805: xp = &text[c->c_ndx];
806: xp->x_poip--;
807: if (xp->x_poip == 0)
808: wakeup((caddr_t)&xp->x_poip);
809: break;
810:
811: case CDATA:
812: case CSTACK:
813: rp = &proc[c->c_ndx];
814: rp->p_poip--;
815: if (rp->p_poip == 0)
816: wakeup((caddr_t)&rp->p_poip);
817: break;
818: }
819: if (c->c_gone == 0) {
820: switch (c->c_type) {
821:
822: case CTEXT:
823: pte = tptopte(xp->x_caddr, c->c_page);
824: break;
825:
826: case CDATA:
827: pte = dptopte(rp, c->c_page);
828: break;
829:
830: case CSTACK:
831: pte = sptopte(rp, c->c_page);
832: break;
833: }
834: if (pte->pg_v == 0) {
835: if (c->c_type == CTEXT)
836: xp->x_rssize -= CLSIZE;
837: else
838: rp->p_rssize -= CLSIZE;
839: memfree(pte, CLSIZE, 0);
840: cnt.v_dfree += CLSIZE;
841: }
842: }
843: bp->b_flags = 0;
844: bp->av_forw = bswlist.av_forw;
845: bswlist.av_forw = bp;
846: if (bswlist.b_flags & B_WANTED) {
847: bswlist.b_flags &= ~B_WANTED;
848: wakeup((caddr_t)&bswlist);
849: }
850: }
851: }
852:
853: /*
854: * Kluster locates pages adjacent to the argument pages
855: * that are immediately available to include in the pagein/pageout,
856: * and given the availability of memory includes them.
857: * It knows that the process image is contiguous in chunks;
858: * an assumption here is that CLSIZE * KLMAX is a divisor of dmmin,
859: * so that by looking at KLMAX chunks of pages, all such will
860: * necessarily be mapped swap contiguous.
861: */
862: int noklust;
863: int klicnt[KLMAX];
864: int klocnt[KLMAX];
865:
866: kluster(p, v, pte0, rw, pkl, klsize, bn0)
867: register struct proc *p;
868: unsigned v;
869: struct pte *pte0;
870: int rw, *pkl, klsize;
871: daddr_t bn0;
872: {
873: int type, cl, clmax;
874: int kloff, k, klmax;
875: register struct pte *pte;
876: int klback, klforw;
877: register int i;
878: unsigned v0;
879: daddr_t bn;
880:
881: if (rw == B_READ)
882: klicnt[0]++;
883: else
884: klocnt[0]++;
885: *pkl = 1;
886: if (noklust || klsize <= 1 || klsize > KLMAX || (klsize & (klsize - 1)))
887: return (v);
888: if (rw == B_READ && freemem < CLSIZE * KLMAX)
889: return (v);
890: if (isassv(p, v)) {
891: type = CSTACK;
892: cl = vtosp(p, v) / CLSIZE;
893: clmax = p->p_ssize / CLSIZE;
894: } else if (isadsv(p, v)) {
895: type = CDATA;
896: cl = vtodp(p, v) / CLSIZE;
897: clmax = p->p_dsize / CLSIZE;
898: } else {
899: type = CTEXT;
900: cl = vtotp(p, v) / CLSIZE;
901: clmax = p->p_textp->x_size / CLSIZE;
902: }
903: kloff = cl & (klsize - 1);
904: pte = pte0;
905: bn = bn0;
906: for (k = kloff; --k >= 0;) {
907: if (type == CSTACK)
908: pte += CLSIZE;
909: else
910: pte -= CLSIZE;
911: if (type == CTEXT && rw == B_READ && bn) {
912: bn--;
913: if (mfind(MSWAPX, bn))
914: break;
915: }
916: if (!klok(pte, rw))
917: break;
918: }
919: klback = (kloff - k) - 1;
920: pte = pte0;
921: if ((cl - kloff) + klsize > clmax)
922: klmax = clmax - (cl - kloff);
923: else
924: klmax = klsize;
925: bn = bn0;
926: for (k = kloff; ++k < klmax;) {
927: if (type == CSTACK)
928: pte -= CLSIZE;
929: else
930: pte += CLSIZE;
931: if (type == CTEXT && rw == B_READ && bn) {
932: bn++;
933: if (mfind(MSWAPX, bn))
934: break;
935: }
936: if (!klok(pte, rw))
937: break;
938: }
939: klforw = (k - kloff) - 1;
940: if (klforw + klback == 0)
941: return (v);
942: pte = pte0;
943: if (type == CSTACK) {
944: pte -= klforw * CLSIZE;
945: v -= klforw * CLSIZE;
946: } else {
947: pte -= klback * CLSIZE;
948: v -= klback * CLSIZE;
949: }
950: *pkl = klforw + klback + 1;
951: if (rw == B_READ)
952: klicnt[0]--, klicnt[*pkl - 1]++;
953: else
954: klocnt[0]--, klocnt[*pkl - 1]++;
955: v0 = v;
956: for (i = 0; i < *pkl; i++) {
957: if (pte == pte0)
958: goto cont;
959: if (rw == B_WRITE) {
960: mlock(pte->pg_pfnum);
961: if (anycl(pte, pg_m)) {
962: pte->pg_m = 0;
963: }
964: pte->pg_swapm = 0;
965: distcl(pte);
966: if (type == CTEXT)
967: distpte(p->p_textp, vtotp(p, v), pte);
968: } else {
969: struct pte opte;
970: int pf;
971:
972: opte = *pte;
973: if (memall(pte, CLSIZE, p, type) == 0)
974: panic("kluster");
975: pte->pg_prot = opte.pg_prot;
976: pf = pte->pg_pfnum;
977: cmap[pgtocm(pf)].c_intrans = 1;
978: distcl(pte);
979: if (type == CTEXT) {
980: p->p_textp->x_rssize += CLSIZE;
981: distpte(p->p_textp, vtotp(p, v), pte);
982: } else
983: p->p_rssize += CLSIZE;
984: distcl(pte);
985: }
986: cont:
987: pte += CLSIZE;
988: v += CLSIZE;
989: }
990: return (v0);
991: }
992:
993: klok(pte, rw)
994: register struct pte *pte;
995: int rw;
996: {
997: register struct cmap *c;
998:
999: if (rw == B_WRITE) {
1000: if (pte->pg_fod)
1001: return (0);
1002: if (pte->pg_pfnum == 0)
1003: return (0);
1004: c = &cmap[pgtocm(pte->pg_pfnum)];
1005: if (c->c_lock || c->c_intrans)
1006: return (0);
1007: if (!dirtycl(pte))
1008: return (0);
1009: return (1);
1010: } else {
1011: if (pte->pg_fod)
1012: return (0);
1013: if (pte->pg_pfnum)
1014: return (0);
1015: return (1);
1016: }
1017: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.