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