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