1992/0625/port/swap.c (diff list | history)

port/swap.c on 1991/0705
1991/0705		#include "u.h"
1992/0321		#include "../port/lib.h"
1991/0705		#include "mem.h" #include "dat.h" #include "fns.h"
1992/0111		#include "../port/error.h"
1991/0705		/* Predeclaration */ void pageout(Proc *p, Segment*);
1992/0304		void pagepte(int, Segment*, Page**);
1991/0705		int needpages(void*); void pager(void*); void executeio(void); int canflush(Proc *p, Segment*); enum {
1992/0303		Maxpages = 500, /* Max number of pageouts per segment pass */
1991/0705		}; Image swapimage; static int swopen; Page *iolist[Maxpages]; int ioptr; void swapinit(void) {
1992/0619		swapalloc.swmap = xalloc(conf.nswap);
1991/0705		swapalloc.top = &swapalloc.swmap[conf.nswap]; swapalloc.alloc = swapalloc.swmap; swapalloc.free = conf.nswap; } ulong newswap(void) { char *look; int n; lock(&swapalloc); if(swapalloc.free == 0) panic("out of swap space"); n = swapalloc.top - swapalloc.alloc; look = swapalloc.alloc; while(n && *look) { n--; look++; } if(n == 0) { look = swapalloc.swmap; while(*look) look++; } if(look == swapalloc.top) swapalloc.alloc = swapalloc.swmap; else swapalloc.alloc = look+1; *look = 1;
1991/0928		swapalloc.free--;
1991/0705		unlock(&swapalloc); return (look-swapalloc.swmap) * BY2PG; } void putswap(Page *p) { lock(&swapalloc); if(--swapalloc.swmap[((ulong)p)/BY2PG] == 0) swapalloc.free++; unlock(&swapalloc); } void dupswap(Page *p) { lock(&swapalloc); swapalloc.swmap[((ulong)p)/BY2PG]++; unlock(&swapalloc); } void kickpager(void) { static int started; if(started) wakeup(&swapalloc.r); else { kproc("pager", pager, 0); started = 1; } } void pager(void *junk) { Proc *p, *ep; Segment *s;
1992/0304		int i, type;
1991/0705
1992/0303		if(waserror()) panic("pager: os error\n");
1991/1115		USED(junk);
1991/0705		p = proctab(0); ep = &p[conf.nproc];
1992/0303		loop: u->p->psstate = "Idle"; sleep(&swapalloc.r, needpages, 0); u->p->psstate = "Pageout";
1992/0301
1992/0303		for(;;) { p++; if(p > ep) p = proctab(0);
1991/0705
1992/0303		if(p->state == Dead || p->kp) continue;
1992/0130
1992/0303		if(swapimage.c) { for(i = 0; i < NSEG; i++) { if(!needpages(junk)) goto loop; if(s = p->seg[i]) {
1992/0304		type = s->type&SG_TYPE; switch(type) { default: break; case SG_TEXT: case SG_DATA: case SG_BSS: case SG_STACK: case SG_SHARED: pageout(p, s); executeio(); }
1992/0303		}
1991/0705		} }
1992/0303		else if(palloc.freecount < swapalloc.highwater) { /* Rob made me do it ! */ if(conf.cntrlp == 0) freebroken();
1991/0705
1992/0303		/* Emulate the old system if no swap channel */ print("no physical memory\n"); tsleep(&swapalloc.r, return0, 0, 1000); wakeup(&palloc.r); }
1991/0705		}
1992/0303		goto loop;
1991/0705		} void pageout(Proc *p, Segment *s) {
1992/0302		Pte **sm, **endsm, *l; Page **pg, *entry;
1992/0304		int type;
1991/0705		if(!canqlock(&s->lk)) /* We cannot afford to wait, we will surely deadlock */ return;
1992/0304		if(s->steal) { /* Protected by /dev/proc */
1991/0705		qunlock(&s->lk); putseg(s); return; }
1992/0304		if(!canflush(p, s)) { /* Able to invalidate all tlbs with references */
1992/0303		qunlock(&s->lk); putseg(s); return; }
1991/0705		if(waserror()) { qunlock(&s->lk); putseg(s); return; } /* Pass through the pte tables looking for memory pages to swap out */ type = s->type&SG_TYPE; endsm = &s->map[SEGMAPSIZE];
1992/0302		for(sm = s->map; sm < endsm; sm++) { l = *sm; if(l == 0) continue; for(pg = l->first; pg < l->last; pg++) { entry = *pg; if(pagedout(entry)) continue;
1992/0303		if(entry->modref & PG_REF)
1992/0302		entry->modref &= ~PG_REF; else pagepte(type, s, pg);
1991/0705
1992/0302		if(ioptr >= Maxpages) goto out; } } out:
1991/0705		poperror(); qunlock(&s->lk); putseg(s); wakeup(&palloc.r); } int canflush(Proc *p, Segment *s) { Proc *ep; int i; lock(s); if(s->ref == 1) { /* Easy if we are the only user */ s->ref++; unlock(s); return canpage(p); } s->ref++; unlock(s); /* Now we must do hardwork to ensure all processes which have tlb
1991/0706		* entries for this segment will be flushed if we suceed in pageing it out
1991/0705		*/ p = proctab(0); ep = &p[conf.nproc];
1992/0302		while(p < ep) { if(p->state != Dead) {
1991/0705		for(i = 0; i < NSEG; i++) if(p->seg[i] == s) if(!canpage(p)) return 0;
1992/0302		} p++; }
1991/0705		return 1; }
1992/0304		void
1991/0705		pagepte(int type, Segment *s, Page **pg) { ulong daddr; Page *outp; outp = *pg; switch(type) { case SG_TEXT: /* Revert to demand load */ putpage(outp); *pg = 0; break;
1992/0302
1991/0705		case SG_DATA: case SG_BSS: case SG_STACK: case SG_SHARED:
1992/0307		case SG_SHDATA:
1992/0625		lock(outp);
1991/0705		outp->ref++; uncachepage(outp);
1992/0625		unlock(outp);
1991/0705		daddr = newswap(); outp->daddr = daddr; /* Enter swap page into cache before segment is unlocked so that * a fault will cause a cache recovery rather than a pagein on a * partially written block. */ cachepage(outp, &swapimage); *pg = (Page*)(daddr|PG_ONSWAP); /* Add me to IO transaction list */ iolist[ioptr++] = outp; } } void executeio(void) { Page *out; int i, n; Chan *c; char *kaddr; KMap *k; c = swapimage.c; for(i = 0; i < ioptr; i++) { out = iolist[i];
1992/0303
1991/0705		k = kmap(out); kaddr = (char*)VA(k); qlock(&c->wrl); if(waserror()) panic("executeio: page out I/O error"); n = (*devtab[c->type].write)(c, kaddr, BY2PG, out->daddr); if(n != BY2PG) nexterror(); qunlock(&c->wrl); kunmap(k); poperror(); /* Free up the page after I/O */
1992/0625		lock(out);
1991/0705		out->ref--;
1992/0625		unlock(out);
1991/0705		putpage(out); } ioptr = 0; } int needpages(void *p) {
1991/1115		USED(p);
1992/0303		return palloc.freecount < swapalloc.headroom;
1991/0705		} void setswapchan(Chan *c) { if(swapimage.c) { if(swapalloc.free != conf.nswap)
1992/0114		error(Einuse);
1991/0705		close(swapimage.c); } incref(c); swapimage.c = c; }