55 files changed, 3000 insertions(+), 1901 deletions(-)

M gnot/dat.h
M gnot/fault68020.c
M gnot/fns.h
M gnot/lock.c
M gnot/main.c
M gnot/mem.h
M gnot/mmu.c
A gnot/segment.h
M gnot/trap.c
M pc/clock.c
M pc/fns.h
M pc/io.h
M pc/kbd.c
M pc/l.s
M pc/main.c
M pc/mem.h
M pc/trap.c
M port/chan.c
M port/devcons.c
M port/devdup.c
M port/devenv.c
M port/devip.c
M port/deviproute.c
M port/devproc.c
M port/devscsi.c
M port/devsrv.c
M port/devwren.c
M port/fault.c
M port/ipdat.h
M port/page.c
M port/pgrp.c
M port/portdat.h
M port/portfns.h
M port/proc.c
M port/qlock.c
M port/queue.c
A port/segment.c
M port/stream.c
M port/sturp.c
A port/swap.c
M port/sysfile.c
M port/sysproc.c
M port/tcpinput.c
M power/boot.h
M power/conf.h
M power/dat.h
M power/faultmips.c
M power/fns.h
M power/l.s
M power/lock.c
M power/main.c
M power/mem.h
M power/mmu.c
A power/segment.h
M power/trap.c

@@ 72,12 72,13 @@ struct Conf
 	int	npgrp;		/* process groups */
 	ulong	npage0;		/* total physical pages of memory, bank 0 */
 	ulong	npage1;		/* total physical pages of memory, bank 1 */
+	ulong	npage;
 	ulong	base0;		/* base of bank 0 */
 	ulong	base1;		/* base of bank 1 */
-	ulong	npage;		/* total physical pages of memory */
-	ulong	norig;		/* origins */
-	ulong	npte;		/* contiguous page table entries */
-	ulong	nmod;		/* single (modifying) page table entries */
+	ulong	nseg;		/* number of segments */
+	ulong	nimage;		/* number of page cache image headers */
+	ulong 	npagetab;	/* number of pte tables */
+	ulong	nswap;		/* number of swap blocks */
 	int	nalarm;		/* alarms */
 	int	nchan;		/* channels */
 	int	nenv;		/* distinct environment values */


@@ 200,7 201,6 @@ struct Scsi
 
 #define	NERR	15
 #define	NNOTE	5
-#define	NFD	100
 struct User
 {
 	Proc	*p;


@@ 211,8 211,6 @@ struct User
 	char	elem[NAMELEN];		/* last name element from namec */
 	Chan	*slash;
 	Chan	*dot;
-	Chan	*fd[NFD];
-	int	maxfd;			/* highest fd in use */
 	/*
 	 * Rest of structure controlled by devproc.c and friends.
 	 * lock(&p->debug) to modify.

@@ 73,14 73,17 @@ fault68020(Ureg *ur, FFrame *f)
 			panic("prefetch pagefault");
 	}else
 		panic("prefetch format");
+
 	addr &= VAMASK;
 	badvaddr = addr;
 	addr &= ~(BY2PG-1);
 	user = !(ur->sr&SUPER);
+
 	if(f->ssw & DF)
 		read = (f->ssw&READ) && !(f->ssw&RM);
 	else
 		read = f->ssw&(FB|FC);
+
 /* print("fault pc=%lux addr=%lux read %d\n", ur->pc, badvaddr, read); /**/
 
 	if(fault(addr, read) < 0){

@@ 22,6 22,7 @@ void	fpregrestore(char*);
 void	fpregsave(char*);
 void	fprestore(FPsave*);
 void	fpsave(FPsave*);
+#define icflush(a, b)
 void	incontoggle(void);
 KMap*	kmap(Page*);
 void	kmapinit(void);

@@ 66,14 66,3 @@ unlock(Lock *l)
 	if(u && u->p)
 		u->p->hasspin = 0;
 }
-
-void
-mklockseg(Seg *s)
-{
-	error(Esegaddr);
-}
-
-Page*
-lkpage(Orig* o, ulong va)
-{
-}

@@ 46,13 46,15 @@ main(void)
 	print("bank 0: %dM  bank 1: %dM\n", bank[0], bank[1]);
 	flushmmu();
 	procinit0();
-	pgrpinit();
+	initseg();
+	grpinit();
 	chaninit();
 	alarminit();
 	chandevreset();
 	streaminit();
 /*	serviceinit(); /**/
 /*	filsysinit(); /**/
+	swapinit();
 	pageinit();
 	kmapinit();
 	userinit();


@@ 89,7 91,7 @@ mmuinit(void)
 	 * Invalidate user addresses
 	 */
 	for(l=0; l<4*1024*1024; l+=BY2PG)
-		putmmu(l, INVALIDPTE);
+		putmmu(l, INVALIDPTE, 0);
 	/*
 	 * Four meg of usable memory, with top 256K for screen
 	 */


@@ 129,6 131,8 @@ init0(void)
 		close(c);
 	}
 	poperror();
+
+	kickpager();
 	touser();
 }
 


@@ 138,23 142,25 @@ void
 userinit(void)
 {
 	Proc *p;
-	Seg *s;
+	Segment *s;
 	User *up;
 	KMap *k;
 
 	p = newproc();
 	p->pgrp = newpgrp();
+	p->egrp = newegrp();
+	p->fgrp = newfgrp();
+
 	strcpy(p->text, "*init*");
 	strcpy(p->pgrp->user, user);
 	p->fpstate = FPinit;
-
 	/*
 	 * Kernel Stack
 	 */
 	p->sched.pc = (ulong)init0;
 	p->sched.sp = USERADDR+BY2PG-20;	/* BUG */
 	p->sched.sr = SUPER|SPL(0);
-	p->upage = newpage(0, 0, USERADDR|(p->pid&0xFFFF));
+	p->upage = newpage(1, 0, USERADDR|(p->pid&0xFFFF));
 
 	/*
 	 * User


@@ 167,25 173,18 @@ userinit(void)
 	/*
 	 * User Stack
 	 */
-	s = &p->seg[SSEG];
-	s->proc = p;
-	s->o = neworig(USTKTOP-BY2PG, 1, OWRPERM, 0);
-	s->minva = USTKTOP-BY2PG;
-	s->maxva = USTKTOP;
+	s = newseg(SG_STACK, USTKTOP-BY2PG, 1);
+	p->seg[SSEG] = s;
 
 	/*
 	 * Text
 	 */
-	s = &p->seg[TSEG];
-	s->proc = p;
-	s->o = neworig(UTZERO, 1, 0, 0);
-	s->o->pte[0].page = newpage(0, 0, UTZERO);
-	s->o->npage = 1;
-	k = kmap(s->o->pte[0].page);
+	s = newseg(SG_TEXT, UTZERO, 1);
+	p->seg[TSEG] = s;
+	segpage(s, newpage(1, 0, UTZERO));
+	k = kmap(s->map[0]->pages[0]);
 	memmove((ulong*)VA(k), initcode, sizeof initcode);
 	kunmap(k);
-	s->minva = UTZERO;
-	s->maxva = UTZERO+BY2PG;
 
 	ready(p);
 }


@@ 277,19 276,19 @@ banksize(int base)
 	if(&end > (int *)((KZERO|1024L*1024L)-BY2PG))
 		return 0;
 	va = UZERO;	/* user page 1 is free to play with */
-	putmmu(va, PTEVALID|(base+0)*1024L*1024L/BY2PG);
+	putmmu(va, PTEVALID|(base+0)*1024L*1024L/BY2PG, 0);
 	*(ulong*)va = 0;	/* 0 at 0M */
-	putmmu(va, PTEVALID|(base+1)*1024L*1024L/BY2PG);
+	putmmu(va, PTEVALID|(base+1)*1024L*1024L/BY2PG, 0);
 	*(ulong*)va = 1;	/* 1 at 1M */
-	putmmu(va, PTEVALID|(base+4)*1024L*1024L/BY2PG);
+	putmmu(va, PTEVALID|(base+4)*1024L*1024L/BY2PG, 0);
 	*(ulong*)va = 4;	/* 4 at 4M */
-	putmmu(va, PTEVALID|(base+0)*1024L*1024L/BY2PG);
+	putmmu(va, PTEVALID|(base+0)*1024L*1024L/BY2PG, 0);
 	if(*(ulong*)va == 0)
 		return 16;
-	putmmu(va, PTEVALID|(base+1)*1024L*1024L/BY2PG);
+	putmmu(va, PTEVALID|(base+1)*1024L*1024L/BY2PG, 0);
 	if(*(ulong*)va == 1)
 		return 4;
-	putmmu(va, PTEVALID|(base+0)*1024L*1024L/BY2PG);
+	putmmu(va, PTEVALID|(base+0)*1024L*1024L/BY2PG, 0);
 	if(*(ulong*)va == 4)
 		return 1;
 	return 0;


@@ 314,11 313,12 @@ confinit(void)
 	conf.maxialloc = (4*1024*1024-256*1024-BY2PG);
 	mul = 1 + (conf.npage1>0);
 	conf.nproc = 50*mul;
+	conf.nseg = conf.nproc*4;
+	conf.npagetab = conf.nseg*2;
+	conf.nswap = 4096;
+	conf.nimage = 50;
 	conf.npgrp = 20*mul;
-	conf.npte = 700*mul;
-	conf.nmod = 400*mul;
 	conf.nalarm = 1000;
-	conf.norig = 150*mul;
 	conf.nchan = 200*mul;
 	conf.nenv = 100*mul;
 	conf.nenvchar = 8000*mul;

@@ 13,6 13,7 @@
 #define	WD2PG		(BY2PG/BY2WD)		/* words per page */
 #define	PGSHIFT		13			/* log(BY2PG) */
 #define PGROUND(s)	(((s)+(BY2PG-1))&~(BY2PG-1))
+#define ICACHESIZE	0
 
 #define	MAXMACH		1			/* max # cpus system can run */
 


@@ 74,6 75,10 @@
 #define	PTEKERNEL	(1<<15)
 #define PTEUNCACHED	0
 #define	INVALIDPTE	0
+#define PTEMAPMEM	(1024*1024)	
+#define	PTEPERTAB	(PTEMAPMEM/BY2PG)
+#define SEGMAPSIZE	16
+
 #define	PPN(pa)		((pa>>13)&0x1FFF)
 
 #define	KMAP	((unsigned long *)0xD0000000)

@@ 22,6 22,7 @@ mapstack(Proc *p)
 	ulong next;
 	MMU *mm, *mn, *me;
 
+
 	if(p->upage->va != (USERADDR|(p->pid&0xFFFF)))
 		panic("mapstack %d 0x%lux 0x%lux", p->pid, p->upage->pa, p->upage->va);
 	tlbvirt = USERADDR;


@@ 29,6 30,12 @@ mapstack(Proc *p)
 	putkmmu(tlbvirt, tlbphys);
 	u = (User*)USERADDR;
 
+	if(p->newtlb) {
+		flushmmu();
+		clearmmucache();
+		p->newtlb = 0;
+	}
+
 	/*
 	 *  if not a kernel process and this process was not the 
 	 *  last process on this machine, flush & preload mmu


@@ 69,7 76,7 @@ putkmmu(ulong tlbvirt, ulong tlbphys)
 }
 
 void
-putmmu(ulong tlbvirt, ulong tlbphys)
+putmmu(ulong tlbvirt, ulong tlbphys, Page *p)
 {
 	if(tlbvirt&KZERO)
 		panic("putmmu");


@@ 101,7 108,7 @@ void
 clearmmucache(void)
 {
 	if(u == 0)
-		panic("flushmmucache");
+		panic("clearmmucache");
 	u->mc.next = 0;
 }
 

@@ 0,0 1,20 @@
+/*
+ * Attach segment types
+ */
+
+typedef struct Physseg Physseg;
+struct Physseg
+{
+	ulong	attr;			/* Segment attributes */
+	char	*name;			/* Attach name */
+	ulong	pa;			/* Physical address */
+	ulong	size;			/* Maximum segment size in pages */
+	Page	*(*pgalloc)(ulong);	/* Allocation if we need it */
+	void	(*pgfree)(Page*);
+}physseg[] = {
+	{ SG_SHARED,	"lock",		0,	SEGMAXSIZE,	&snewpage, 	&putpage },
+	{ SG_SHARED,	"shared",	0,	SEGMAXSIZE,	&snewpage, 	&putpage },
+	{ SG_PHYSICAL,	"kmem",		KZERO,	SEGMAXSIZE,	0,		0 	},
+	{ SG_BSS,	"memory",	0,	SEGMAXSIZE,	&snewpage,	&putpage },
+	{ 0,		0,		0,	0,		0,		0 	},
+};

@@ 91,13 91,14 @@ trap(Ureg *ur)
 	if(u)
 		u->p->pc = ur->pc;		/* BUG */
 	if(user){
-		sprint(buf, "sys: trap: pc=0x%lux %s", ur->pc, excname(ur->vo));
+		sprint(buf, "sys: %s pc=0x%lux", excname(ur->vo), ur->pc);
 		postnote(u->p, 1, buf, NDebug);
 	}else{
 		print("kernel trap vo=0x%ux pc=0x%lux\n", ur->vo, ur->pc);
 		dumpregs(ur);
 		exit();
 	}
+
 	if(user && u->nnote)
 		notify(ur);
 }


@@ 130,6 131,7 @@ dumpregs(Ureg *ur)
 	l = &ur->r0;
 	for(i=0; i<sizeof regname/sizeof(char*); i+=2, l+=2)
 		print("%s\t%.8lux\t%s\t%.8lux\n", regname[i], l[0], regname[i+1], l[1]);
+	for(;;);
 	dumpstack();
 }
 


@@ 212,6 214,7 @@ Syscall	sysr1, sysfork, sysexec, sysgetpid, syssleep, sysexits, sysdeath, syswai
 Syscall	sysopen, sysclose, sysread, syswrite, sysseek, syserrstr, sysaccess, sysstat, sysfstat;
 Syscall sysdup, syschdir, sysforkpgrp, sysbind, sysmount, syspipe, syscreate;
 Syscall	sysbrk_, sysremove, syswstat, sysfwstat, sysnotify, sysnoted, sysalarm;
+Syscall syssegattach, syssegdetach, syssegfree, syssegflush, syssegbrk;
 
 Syscall *systab[]={
 	sysr1,


@@ 226,7 229,7 @@ Syscall *systab[]={
 	sysfork,
 	sysforkpgrp,
 	sysfstat,
-	sysdeath,
+	syssegbrk,
 	sysmount,
 	sysopen,
 	sysread,


@@ 244,7 247,10 @@ Syscall *systab[]={
 	sysfwstat,
 	sysnotify,
 	sysnoted,
-	sysdeath,	/* sysfilsys */
+	syssegattach,
+	syssegdetach,
+	syssegfree,
+	syssegflush,
 };
 
 long


@@ 289,7 295,8 @@ syscall(Ureg *aur)
 			error(Ebadarg);
 		}
 		if(sp & (BY2WD-1)){
-			pprint("odd sp in sys call pc %lux sp %lux\n", ((Ureg*)UREGADDR)->pc, ((Ureg*)UREGADDR)->sp);
+			pprint("odd sp in sys call pc %lux sp %lux\n", 
+				((Ureg*)UREGADDR)->pc, ((Ureg*)UREGADDR)->sp);
 			msg = "sys: odd stack";
 			goto Bad;
 		}


@@ 298,14 305,19 @@ syscall(Ureg *aur)
 		ret = (*systab[r0])((ulong*)(sp+BY2WD));
 		poperror();
 	}
+
+#ifdef Check
 	if(u->nerrlab){
-		print("unbalanced error stack: %d extra\n", u->nerrlab);
+		print("bad errstack [%d]: %d extra\n", r0, u->nerrlab);
 		for(i = 0; i < NERR; i++)
 			print("sp=%lux pc=%lux\n", u->errlab[i].sp, u->errlab[i].pc);
 		panic("bad rob");
 	}
+#endif
+
 	u->p->insyscall = 0;
-	if(r0 == NOTED)	/* ugly hack */
+
+	if(r0 == NOTED)		/* ugly hack */
 		noted(aur);	/* doesn't return */
 	if(u->nnote){
 		ur->r0 = ret;

@@ 4,7 4,18 @@
 #include	"dat.h"
 #include	"fns.h"
 #include	"io.h"
-#include	"ureg.h"
+
+/*
+ *  8253 timer
+ */
+enum
+{
+	Timerctl=	0x43,		/* control port */
+	Timercnt=	0x40,		/* timer count port (outb count-1) */
+	Timericnt=	0x41,		/* timer count input port */
+
+	Timerlatch=	0x40,		/* latch count into Timericnt */
+};
 
 void
 clockinit(void)


@@ 12,3 23,11 @@ clockinit(void)
 	setvec(Clockvec, clock, SEGIG);
 }
 
+void
+clock(void *arg)
+{
+	m->ticks++;
+	if((m->ticks%185)==0)
+		print("%d secs\n", TK2SEC(m->ticks));
+	INT0ENABLE;
+}

@@ 1,5 1,7 @@
 #include "../port/portfns.h"
 
+void	clock(void*);
+void	clockinit(void);
 void	delay(int);
 int	inb(int);
 void	intr0(void);


@@ 31,8 33,6 @@ void	screeninit(void);
 void	screenputc(int);
 void	screenputs(char*, int);
 void	setvec(int, void (*)(void*), int);
-void	spllo(void);
-void	splhi(void);
 void	systrap(void);
 void	trapinit(void);
 int	tas(Lock*);

@@ 18,18 18,6 @@ enum
 #define	INT1ENABLE	outb(Int1ctl, Intena)
 
 /*
- *  8253 timer
- */
-enum
-{
-	Timerctl=	0x43,		/* control port */
-	Timercnt=	0x40,		/* timer count port (outb count-1) */
-	Timericnt=	0x41,		/* timer count input port */
-
-	Timerlatch=	0x40,		/* latch count into Timericnt */
-};
-
-/*
  *  8237 dma controllers
  */
 enum


@@ 46,5 34,5 @@ enum
 	 */
 	Dma1=		0xC0,
 	Dma1status=	Dma1+2*0x8,	/* status port */
-	Dma0reset=	Dma1+2*0xD,	/* reset port */
+	Dma1reset=	Dma1+2*0xD,	/* reset port */
 };

@@ 378,6 378,6 @@ kbdintr(void *a)
 	}
 	kbdputc(&kbdq, c);
 out:
-	INTENABLE;			/* reenable interrupt */
+	INT0ENABLE;			/* reenable interrupt */
 	return;
 }

@@ 305,3 305,9 @@ TEXT	spllo(SB),$0
 TEXT	splhi(SB),$0
 	CLI
 	RET
+
+/*
+ *  set interrupt level
+ */
+TEXT	splx(SB),$0
+	RET

@@ 11,7 11,7 @@ main(void)
 	print("traps inited\n");
 	kbdinit();
 	print("kbd inited\n");
-	sti();
+	spllo();
 	for(;;);
 }
 


@@ 54,3 54,8 @@ panic(char *fmt, ...)
 	screenputs(buf, n);
 	for(;;);
 }
+
+void
+sched(void)
+{
+}

@@ 17,15 17,15 @@
 #define	MAXMACH		1			/* max # cpus system can run */
 
 /*
- * Time (???)
- * Clock frequency is 68.3900 HZ
+ * Time
+ * Clock frequency is ??? HZ
  */
 
-#define	HZ		(68)			/* clock frequency */
-#define	MS2HZ		(1000/HZ)		/* millisec per clock tick */
-#define	TK2SEC(t)	((t)*100/6839)		/* ticks to seconds */
-#define	TK2MS(t)	((((ulong)(t))*100000)/6839)	/* ticks to milliseconds */
-#define	MS2TK(t)	((((ulong)(t))*6839)/100000)	/* milliseconds to ticks */
+#define	HZ		(18)			/* clock frequency */
+#define	MS2HZ		(54)			/* millisec per clock tick */
+#define	TK2SEC(t)	((t)*10/185)		/* ticks to seconds */
+#define	TK2MS(t)	((((ulong)(t))*10000)/185)	/* ticks to milliseconds */
+#define	MS2TK(t)	((((ulong)(t))*185)/10000)	/* milliseconds to ticks */
 
 /*
  * Fundamental addresses

@@ 75,11 75,11 @@ trapinit(void)
 	 *	 IBM technical reference manual.  I just
 	 *	 changed the vector.
 	 */
-	outb(I8259ctl, 0x11);		/* ICW1 - edge, master, ICW4 */
-	outb(I8259aux, I8259vec);	/* ICW2 - interrupt vector */
-	outb(I8259aux, 0x04);		/* ICW3 - master level 2 */
-	outb(I8259aux, 0x01);		/* ICW4 - master, 8086 mode */
-	outb(I8259aux, 0x00);		/* mask - all enabled */
+	outb(Int0ctl, 0x11);		/* ICW1 - edge, master, ICW4 */
+	outb(Int0aux, Int0vec);		/* ICW2 - interrupt vector */
+	outb(Int0aux, 0x04);		/* ICW3 - master level 2 */
+	outb(Int0aux, 0x01);		/* ICW4 - master, 8086 mode */
+	outb(Int0aux, 0x00);		/* mask - all enabled */
 }
 
 

@@ 30,6 30,8 @@ decref(Ref *r)
 	lock(r);
 	x = --r->ref;
 	unlock(r);
+	if(x < 0)
+		panic("decref");
 	return x;
 }
 

@@ 159,7 159,7 @@ pprint(char *fmt, ...)
 	Chan *c;
 	int n;
 
-	c = u->fd[2];
+	c = u->p->fgrp->fd[2];
 	if(c==0 || (c->mode!=OWRITE && c->mode!=ORDWR))
 		return 0;
 	n = sprint(buf, "%s %d: ", u->p->text, u->p->pid);


@@ 294,6 294,7 @@ enum{
 	Qmsec,
 	Qclock,
 	Qsysstat,
+	Qswap,
 };
 
 Dirtab consdir[]={


@@ 312,6 313,7 @@ Dirtab consdir[]={
 	"msec",		{Qmsec},	NUMSIZE,	0400,
 	"clock",	{Qclock},	2*NUMSIZE,	0400,
 	"sysstat",	{Qsysstat},	0,		0600,
+	"swap",		{Qswap},	0,		0666,
 };
 
 #define	NCONS	(sizeof consdir/sizeof(Dirtab))


@@ 581,6 583,12 @@ consread(Chan *c, void *buf, long n, ulong offset)
 		}
 		return readstr(offset, buf, n, xbuf);
 
+	case Qswap:
+		sprint(xbuf, "%d/%d memory %d/%d swap\n",
+				palloc.user-palloc.freecount, palloc.user, 
+				conf.nswap-swapalloc.free, conf.nswap);
+
+		return readstr(offset, buf, n, xbuf);
 	default:
 		panic("consread %lux\n", c->qid);
 		return 0;


@@ 637,7 645,8 @@ conswrite(Chan *c, void *va, long n, ulong offset)
 	long l, m;
 	char *a = va;
 	Mach *mp;
-	int id;
+	int id, fd;
+	Chan *swc;
 
 	switch(c->qid.path){
 	case Qrcons:


@@ 710,6 719,16 @@ conswrite(Chan *c, void *va, long n, ulong offset)
 		}
 		break;
 
+	case Qswap:
+		if(n >= sizeof buf)
+			error(Egreg);
+		memmove(buf, va, n);	/* so we can NUL-terminate */
+		buf[n] = 0;
+		fd = strtoul(buf, 0, 0);
+		swc = fdtochan(fd, -1);
+		setswapchan(swc);
+		return n;
+
 	default:
 		error(Egreg);
 	}

@@ 12,12 12,13 @@ int
 dupgen(Chan *c, Dirtab *tab, int ntab, int s, Dir *dp)
 {
 	char buf[8];
+	Fgrp *fgrp = u->p->fgrp;
 	Chan *f;
 	static int perm[] = { 0400, 0200, 0600, 0 };
 
 	if(s >= NFD)
 		return -1;
-	if((f=u->fd[s]) == 0)
+	if((f=fgrp->fd[s]) == 0)
 		return 0;
 	sprint(buf, "%ld", s);
 	devdir(c, (Qid){s, 0}, buf, 0, perm[f->mode&3], dp);


@@ 72,7 73,7 @@ dupopen(Chan *c, int omode)
 		return c;
 	}
 	fdtochan(c->qid.path, openmode(omode));	/* error check only */
-	f = u->fd[c->qid.path];
+	f = u->p->fgrp->fd[c->qid.path];
 	close(c);
 	incref(f);
 	if(omode & OCEXEC)

@@ 211,15 211,15 @@ int
 envgen(Chan *c, Dirtab *tab, int ntab, int s, Dir *dp)
 {
 	Env *e;
-	Pgrp *pg;
+	Egrp *eg;
 	int ans;
 
-	pg = u->p->pgrp;
-	lock(pg);
-	if(s >= pg->nenv)
+	eg = u->p->egrp;
+	lock(eg);
+	if(s >= eg->nenv)
 		ans = -1;
 	else{
-		e = pg->etab[s].env;
+		e = eg->etab[s].env;
 		if(e == 0)
 			ans = 0;
 		else{


@@ 229,7 229,7 @@ envgen(Chan *c, Dirtab *tab, int ntab, int s, Dir *dp)
 			ans = 1;
 		}
 	}
-	unlock(pg);
+	unlock(eg);
 	return ans;
 }
 


@@ 242,13 242,13 @@ envattach(char *spec)
 Chan*
 envclone(Chan *c, Chan *nc)
 {
-	Pgrp *pg;
+	Egrp *eg;
 
 	if(!(c->qid.path&CHDIR)){
-		pg = u->p->pgrp;
-		lock(pg);
-		pg->etab[c->qid.path-1].chref++;
-		unlock(pg);
+		eg = u->p->egrp;
+		lock(eg);
+		eg->etab[c->qid.path-1].chref++;
+		unlock(eg);
 	}
 	return devclone(c, nc);
 }


@@ 256,14 256,14 @@ envclone(Chan *c, Chan *nc)
 int
 envwalk(Chan *c, char *name)
 {
-	Pgrp *pg;
+	Egrp *eg;
 
 	if(devwalk(c, name, 0, 0, envgen)){
 		if(!(c->qid.path&CHDIR)){
-			pg = u->p->pgrp;
-			lock(pg);
-			pg->etab[c->qid.path-1].chref++;
-			unlock(pg);
+			eg = u->p->egrp;
+			lock(eg);
+			eg->etab[c->qid.path-1].chref++;
+			unlock(eg);
 			return 1;
 		}
 	}


@@ 281,17 281,17 @@ envopen(Chan *c, int omode)
 {
 	Env *e, *ne;
 	Envp *ep;
-	Pgrp *pg;
+	Egrp *eg;
 
 	if(omode & (OWRITE|OTRUNC)){
 		if(c->qid.path & CHDIR)
 			error(Eperm);
-		pg = u->p->pgrp;
-		lock(pg);
-		ep = &pg->etab[c->qid.path-1];
+		eg = u->p->egrp;
+		lock(eg);
+		ep = &eg->etab[c->qid.path-1];
 		e = ep->env;
 		if(!e){
-			unlock(pg);
+			unlock(eg);
 			error(Egreg);
 		}
 		lock(&envalloc);


@@ 299,7 299,7 @@ envopen(Chan *c, int omode)
 		if(waserror()){
 			unlock(e);
 			unlock(&envalloc);
-			unlock(pg);
+			unlock(eg);
 			nexterror();
 		}
 		if(e->pgref == 0)


@@ 318,7 318,7 @@ envopen(Chan *c, int omode)
 		poperror();
 		unlock(e);
 		unlock(&envalloc);
-		unlock(pg);
+		unlock(eg);
 	}
 	c->mode = openmode(omode);
 	c->flag |= COPEN;


@@ 330,17 330,17 @@ void
 envcreate(Chan *c, char *name, int omode, ulong perm)
 {
 	Env *e;
-	Pgrp *pg;
+	Egrp *eg;
 	int i;
 
 	if(c->qid.path != CHDIR)
 		error(Eperm);
-	pg = u->p->pgrp;
-	lock(pg);
+	eg = u->p->egrp;
+	lock(eg);
 	lock(&envalloc);
 	if(waserror()){
 		unlock(&envalloc);
-		unlock(pg);
+		unlock(eg);
 		nexterror();
 	}
 	e = envalloc.efree;


@@ 352,21 352,21 @@ envcreate(Chan *c, char *name, int omode, ulong perm)
 	e->next = 0;
 	e->pgref = 1;
 	strncpy(e->name, name, NAMELEN);
-	if(pg->nenv == conf.npgenv){
-		for(i = 0; i<pg->nenv; i++)
-			if(pg->etab[i].chref == 0)
+	if(eg->nenv == conf.npgenv){
+		for(i = 0; i<eg->nenv; i++)
+			if(eg->etab[i].chref == 0)
 				break;
-		if(i == pg->nenv){
-			print("out of pgroup envs\n");
+		if(i == eg->nenv){
+			print("out of egroup envs\n");
 			error(Enoenv);
 		}
 	}else
-		i = pg->nenv++;
+		i = eg->nenv++;
 	c->qid.path = i+1;
-	pg->etab[i].env = e;
-	pg->etab[i].chref = 1;
+	eg->etab[i].env = e;
+	eg->etab[i].chref = 1;
 	unlock(&envalloc);
-	unlock(pg);
+	unlock(eg);
 	c->offset = 0;
 	c->mode = openmode(omode);
 	poperror();


@@ 378,22 378,22 @@ envremove(Chan *c)
 {
 	Env *e;
 	Envp *ep;
-	Pgrp *pg;
+	Egrp *eg;
 
 	if(c->qid.path & CHDIR)
 		error(Eperm);
-	pg = u->p->pgrp;
-	lock(pg);
-	ep = &pg->etab[c->qid.path-1];
+	eg = u->p->egrp;
+	lock(eg);
+	ep = &eg->etab[c->qid.path-1];
 	e = ep->env;
 	if(!e){
-		unlock(pg);
+		unlock(eg);
 		error(Enonexist);
 	}
 	ep->env = 0;
 	ep->chref--;
 	envpgclose(e);
-	unlock(pg);
+	unlock(eg);
 }
 
 void


@@ 407,14 407,14 @@ envwstat(Chan *c, char *db)
 void
 envclose(Chan * c)
 {
-	Pgrp *pg;
+	Egrp *eg;
 
 	if(c->qid.path & CHDIR)
 		return;
-	pg = u->p->pgrp;
-	lock(pg);
-	pg->etab[c->qid.path-1].chref--;
-	unlock(pg);
+	eg = u->p->egrp;
+	lock(eg);
+	eg->etab[c->qid.path-1].chref--;
+	unlock(eg);
 }
 
 void


@@ 441,16 441,16 @@ envread(Chan *c, void *va, long n, ulong offset)
 	Envval *ev;
 	char *p;
 	long vn;
-	Pgrp *pg;
+	Egrp *eg;
 	char *a = va;
 
 	if(c->qid.path & CHDIR)
 		return devdirread(c, a, n, 0, 0, envgen);
-	pg = u->p->pgrp;
-	lock(pg);
-	e = pg->etab[c->qid.path-1].env;
+	eg = u->p->egrp;
+	lock(eg);
+	e = eg->etab[c->qid.path-1].env;
 	if(!e){
-		unlock(pg);
+		unlock(eg);
 		error(Eio);
 	}
 	lock(e);


@@ 463,7 463,7 @@ envread(Chan *c, void *va, long n, ulong offset)
 	else
 		memmove(a, ev->dat+offset, n);
 	unlock(e);
-	unlock(pg);
+	unlock(eg);
 	return n;
 }
 


@@ 474,16 474,16 @@ envwrite(Chan *c, void *va, long n, ulong offset)
 	char *p;
 	Envval *ev;
 	long vn;
-	Pgrp *pg;
+	Egrp *eg;
 	char *a = va;
 
 	if(n <= 0)
 		return 0;
-	pg = u->p->pgrp;
-	lock(pg);
-	e = pg->etab[c->qid.path-1].env; /* caller checks for CHDIR */
+	eg = u->p->egrp;
+	lock(eg);
+	e = eg->etab[c->qid.path-1].env; /* caller checks for CHDIR */
 	if(!e){
-		unlock(pg);
+		unlock(eg);
 		error(Eio);
 	}
 	lock(&envalloc);


@@ 491,7 491,7 @@ envwrite(Chan *c, void *va, long n, ulong offset)
 	if(waserror()){
 		unlock(e);
 		unlock(&envalloc);
-		unlock(pg);
+		unlock(eg);
 		nexterror();
 	}
 	if(e->pgref>1)


@@ 506,7 506,7 @@ envwrite(Chan *c, void *va, long n, ulong offset)
 	poperror();
 	unlock(e);
 	unlock(&envalloc);
-	unlock(pg);
+	unlock(eg);
 	return n;
 }
 


@@ 516,12 516,12 @@ dumpenv(void)
 	Env *e;
 	Envp *ep;
 	Envval *ev;
-	Pgrp *pg;
+	Egrp *eg;
 	int i;
 	char hold;
 
-	pg = u->p->pgrp;
-	for(ep=pg->etab, i=0; i<pg->nenv; i++, ep++)
+	eg = u->p->egrp;
+	for(ep=eg->etab, i=0; i<eg->nenv; i++, ep++)
 		print("P%d(%lux %d)",i, ep->env, ep->chref);
 	for(e=envalloc.earena; e<&envalloc.earena[conf.nenv]; e++)
 		if(e->pgref){

@@ 71,6 71,7 @@ ipreset(void)
 	}
 
 	initfrag(conf.frag);
+	tcpinit();
 }
 
 void

@@ 190,7 190,7 @@ enum{
 	Qdata,
 };
 Dirtab iproutetab[]={
-	"iproute",		{Qdata},		0,	0666,
+	"iproute",		{Qdata},		0,	0600,
 };
 #define Niproutetab (sizeof(iproutetab)/sizeof(Dirtab))
 

@@ 14,6 14,7 @@ enum{
 	Qnote,
 	Qnotepg,
 	Qproc,
+	Qsegment,
 	Qstatus,
 	Qtext,
 };


@@ 24,10 25,20 @@ Dirtab procdir[]={
 	"note",		{Qnote},	0,			0600,
 	"notepg",	{Qnotepg},	0,			0200,
 	"proc",		{Qproc},	sizeof(Proc),		0600,
+	"segment",	{Qsegment},	0,			0400,
 	"status",	{Qstatus},	NAMELEN+12+6*12,	0600,
 	"text",		{Qtext},	0,			0600,
 };
 
+char *sname[]={ 			/* Segment type from portdat.h */
+	"Text", 
+	"Data", 
+	"Bss", 
+	"Stack", 
+	"Shared", 
+	"Phys",
+};
+
 /*
  * Qids are, in path:
  *	 4 bits of file type (qids above)


@@ 47,7 58,7 @@ procgen(Chan *c, Dirtab *tab, int ntab, int s, Dir *dp)
 {
 	Proc *p;
 	char buf[NAMELEN];
-	ulong pid;
+	ulong pid, path;
 
 	if(c->qid.path == CHDIR){
 		if(s >= conf.nproc)


@@ 65,7 76,8 @@ procgen(Chan *c, Dirtab *tab, int ntab, int s, Dir *dp)
 	if(tab)
 		panic("procgen");
 	tab = &procdir[s];
-	devdir(c, (Qid){(~CHDIR)&(c->qid.path|tab->qid.path), c->qid.vers},
+	path = c->qid.path&~(CHDIR|((1<<QSHIFT)-1));	/* slot component */
+	devdir(c, (Qid){path|tab->qid.path, c->qid.vers},
 		tab->name, tab->length, tab->perm, dp);
 	return 1;
 }


@@ 112,7 124,7 @@ procopen(Chan *c, int omode)
 {
 	Proc *p;
 	Pgrp *pg;
-	Orig *o;
+	Segment *s;
 	Chan *tc;
 
 	if(c->qid.path == CHDIR){


@@ 129,11 141,11 @@ procopen(Chan *c, int omode)
 
 	switch(QID(c->qid)){
 	case Qtext:
-		o = p->seg[TSEG].o;
-		if(o==0 || p->state==Dead) 
+		s = p->seg[TSEG];
+		if(s==0 || p->state==Dead || s->image==0) 
 			goto Died;
 
-		tc = o->chan;
+		tc = s->image->c;
 		if(tc == 0)
 			goto Died;
 


@@ 154,6 166,7 @@ procopen(Chan *c, int omode)
 		return tc;
 	case Qctl:
 	case Qnote:
+	case Qsegment:
 		break;
 
 	case Qnotepg:


@@ 213,17 226,18 @@ long
 procread(Chan *c, void *va, long n, ulong offset)
 {
 	char *a = va, *b;
-	char statbuf[2*NAMELEN+12+6*12];
+	char statbuf[NSEG*32];
 	Proc *p;
-	Seg *s;
-	Orig *o;
+	Pte *pte;
+	Segment *s;
 	Page *pg;
 	KMap *k;
-	PTE *pte, *opte;
-	int i;
+	int i, j;
 	long l;
 	long pid;
 	User *up;
+	ulong soff;
+	Segment *sg;
 
 	if(c->qid.path & CHDIR)
 		return devdirread(c, a, n, 0, 0, procgen);


@@ 242,32 256,22 @@ procread(Chan *c, void *va, long n, ulong offset)
 		 */
 		if(((offset+n)&~(BY2PG-1)) != (offset&~(BY2PG-1)))
 			n = BY2PG - (offset&(BY2PG-1));
-		s = seg(p, offset);
+		s = seg(p, offset, 1);
 		if(s){
-			o = s->o;
-			if(o == 0)
-				error(Eprocdied);
-			lock(o);
-			if(s->o!=o || p->pid!=PID(c->qid)){
-				unlock(o);
+			if(p->pid!=PID(c->qid)){
+				qunlock(&s->lk);
 				error(Eprocdied);
 			}
-			if(seg(p, offset) != s){
-				unlock(o);
-				error(Egreg);
-			}
-			pte = &o->pte[(offset-o->va)>>PGSHIFT];
-			if(s->mod){
-				opte = pte;
-				while(pte = pte->nextmod)	/* assign = */
-					if(pte->proc == p)
-						break;
-				if(pte == 0)
-					pte = opte;
-			}
-			pg = pte->page;
-			unlock(o);
-			if(pg == 0){
+
+			soff = offset-s->base;
+			pte = s->map[soff/PTEMAPMEM];
+			pg = 0;
+			if(pte)
+				pg = pte->pages[(soff&(PTEMAPMEM-1))/BY2PG];
+
+			s->steal++;
+			qunlock(&s->lk);
+			if(pagedout(pg)){
 				pprint("nonresident page addr %lux (complain to rob)\n", offset);
 				memset(a, 0, n);
 			}else{


@@ 276,6 280,9 @@ procread(Chan *c, void *va, long n, ulong offset)
 				memmove(a, b+(offset&(BY2PG-1)), n);
 				kunmap(k);
 			}
+			qlock(&s->lk);
+			s->steal--;
+			qunlock(&s->lk);
 			return n;
 		}
 		/* u area */


@@ 355,6 362,19 @@ procread(Chan *c, void *va, long n, ulong offset)
 		}
 		memmove(a, statbuf+offset, n);
 		return n;
+	case Qsegment:
+		j = 0;
+		for(i = 0; i < NSEG; i++)
+			if(sg = p->seg[i])
+				j += sprint(&statbuf[j], "%-6s %c %.8lux %.8lux %4d\n",
+				sname[sg->type&SG_TYPE], sg->type&SG_RONLY ? 'R' : ' ',
+				sg->base, sg->top, sg->ref);
+		if(offset >= j)
+			return 0;
+		if(offset+n > j)
+			n = j-offset;
+		memmove(a, &statbuf[offset], n);
+		return n;
 	}
 	error(Egreg);
 }


@@ 404,11 424,31 @@ procwrite(Chan *c, void *va, long n, ulong offset)
 
 	switch(QID(c->qid)){
 	case Qctl:
-		if(p->state==Broken && n>=4 && strncmp(va, "exit", 4)==0)
-			ready(p);
+		if(n >= 4 && strncmp(va, "exit", 4) == 0) {
+			if(p->state == Broken) {
+				ready(p);
+				break;
+			}
+		}
 		else
-			error(Ebadctl);
-		break;
+		if(n >= 4 && strncmp(va, "stop", 4) == 0) {
+			p->procctl = Proc_stopme;
+			break;
+		}
+		else
+		if(n >= 5 && strncmp(va, "start", 5) == 0) {
+			if(p->state == Stopped) {
+				ready(p);
+				break;
+			}
+			errors("not stopped");
+		}
+		else
+		if(n >= 4 && strncmp(va, "kill", 4) == 0) {
+			p->procctl = Proc_exitme;
+			break;
+		}
+		error(Ebadctl);
 	case Qnote:
 		k = kmap(p->upage);
 		up = (User*)VA(k);

@@ 104,7 104,7 @@ scsiwalk(Chan *c, char *name)
 void
 scsistat(Chan *c, char *db)
 {
-	devstat(c, db, 0, 0, scsigeno);
+	devstat(c, db, 0, 0, scsigen);
 }
 
 Chan *


@@ 579,9 579,5 @@ scsictrlintr(void)
 		default:
 			panic("scsi status 0x%2.2ux", status);
 		}
-		kprint("resetting...");
-		PUT(Own_id, ownid);
-		PUT(Cmd, Reset);
-		break;
 	}
 }

@@ 275,8 275,7 @@ srvwrite(Chan *c, void *va, long n, ulong offset)
 	memmove(buf, va, n);	/* so we can NUL-terminate */
 	buf[n] = 0;
 	fd = strtoul(buf, 0, 0);
-	fdtochan(fd, -1);	/* error check only */
-	e->chan = u->fd[fd];
+	e->chan = fdtochan(fd, -1);
 	incref(e->chan);
 	unlock(e);
 	poperror();

@@ 150,7 150,7 @@ wrenattach(char *param)
 	d = &wren[dev];
 	d->blocksize = BGLONG(&buf[4]);
 
-	plen = BGLONG(&buf[0])+1;
+	plen = BGLONG(&buf[0]);
 	d->p[Npart].firstblock = 0;
 	d->p[Npart].maxblock = plen;
 	plen = plen/Npart;

@@ 6,227 6,211 @@
 #include	"ureg.h"
 #include	"errno.h"
 
+#define DPRINT
+
 int
 fault(ulong addr, int read)
 {
-	ulong mmuvirt, mmuphys, n;
-	Seg *s;
-	PTE *opte, *pte, *npte;
-	Orig *o;
-	char *l;
-	Page *pg;
-	int zeroed = 0, head = 1;
-	int i, touched = 0;
-	KMap *k, *k1;
+	ulong mmuphys=0, soff;
+	Segment *s;
+	Pte **p;
+	Page **pg, *lkp, *new = 0;
+	int type;
 
 	m->pfault++;
-	s = seg(u->p, addr);
-	if(s == 0){
-		if(addr > USTKTOP)
-			return -1;
-		s = &u->p->seg[SSEG];
-		if(s->o==0 || addr<s->maxva-USTKSIZE || addr>=s->maxva)
-			return -1;
-		/* grow stack */
-		o = s->o;
-		n = o->npte;
-		if(waserror()){
-			pprint("can't allocate stack page\n");
-			return -1;
-		}
-		growpte(o, (s->maxva-addr)>>PGSHIFT);
-		poperror();
-		/* stacks grown down, sigh */
-		lock(o);
-		memmove(o->pte+(o->npte-n), o->pte, n*sizeof(PTE));
-		memset(o->pte, 0, (o->npte-n)*sizeof(PTE));
-		unlock(o);
-		s->minva = addr;
-		o->va = addr;
-	}else
-		o = s->o;
-	if(!read && (o->flag&OWRPERM)==0)
+again:
+	s = seg(u->p, addr, 1);
+	if(s == 0)
+		return -1;
+
+	if(!read && (s->type&SG_RONLY)) {
+		qunlock(&s->lk);
 		return -1;
-	lock(o);
-	opte = &o->pte[(addr-o->va)>>PGSHIFT];
-	pte = opte;
-	if(s->mod){
-		while(pte = pte->nextmod)	/* assign = */
-			if(pte->proc == u->p){
-				if(pte->page==0 || pte->page->va!=addr)
-					panic("bad page %lux", pte->page);
-				head = 0;
-				break;
-			}
-		if(pte == 0)
-			pte = opte;
 	}
-	if(pte->page == 0){
-		touched = 1;
-		if(o->chan==0 || addr>(o->va+(o->maxca-o->minca))){
-			/* Make a new bss or lock segment page */
-			if(s - u->p->seg == LSEG) {
-				pte->page = lkpage(o, addr);
-				if(pte->page == 0) {
-					unlock(o);
-					return -1;
-				}
-			}
-			else
-				pte->page = newpage(0, o, addr);
-			zeroed = 1;
-			o->npage++;
-		}else{
-			/*
-			 * Demand load.  Release o because it could take a while.
-			 */
-			unlock(o);
-			n = (o->va+(o->maxca-o->minca)) - addr;
-			if(n > BY2PG)
-				n = BY2PG;
-			pg = newpage(1, o, addr);
-			k = kmap(pg);
-			qlock(&o->chan->rdl);
-			if(waserror()){
-				kunmap(k);
-				qunlock(&o->chan->rdl);
-				pg->o = 0;
-				pg->ref--;
-				pexit("demand load i/o error", 0);
-			}
-			l = (char*)VA(k);
-			if((*devtab[o->chan->type].read)(o->chan, l, n, (addr-o->va) + o->minca) != n)
-				error(Eioload);
-			flushpage(pg->pa);
-			qunlock(&o->chan->rdl);
-			if(n<BY2PG)
-				memset(l+n, 0, BY2PG-n);
-			lock(o);
-			kunmap(k);
-			poperror();
-			opte = &o->pte[(addr-s->minva)>>PGSHIFT];	/* could move */
-			pte = opte;
-			if(pte->page == 0){
-				pte->page = pg;
-				o->npage++;
-			}else{		/* someone beat us to it */
-				pg->o = 0;
-				pg->ref--;
-			}
+
+	addr &= ~(BY2PG-1);
+	soff = addr-s->base;
+	p = &s->map[soff/PTEMAPMEM];
+	if(*p == 0) 
+		*p = ptealloc();
+
+	pg = &(*p)->pages[(soff&(PTEMAPMEM-1))/BY2PG];
+	type = s->type&SG_TYPE;
+
+	switch(type) {
+	case SG_TEXT:
+		if(pagedout(*pg)) 		/* No data - must demand load */
+			pio(s, addr, soff, pg);
+		
+		mmuphys = PPN((*pg)->pa) | PTERONLY|PTEVALID;
+		(*pg)->modref = PG_REF;
+		break;
+	case SG_SHARED:
+	case SG_BSS:
+	case SG_STACK:	
+			/* Zero fill on demand */
+		if(*pg == 0) {			
+			if(new == 0 && (new = newpage(1, &s, addr)) && s == 0)
+				goto again;
+			*pg = new;
+			new = 0;
 		}
+						/* NO break */
+	case SG_DATA:
+		if(pagedout(*pg))
+			pio(s, addr, soff, pg);
+
+		if(type == SG_SHARED)
+			goto done;
+
+		if(read && conf.copymode == 0) {
+			mmuphys = PPN((*pg)->pa) | PTERONLY|PTEVALID;
+			(*pg)->modref |= PG_REF;
+			break;
+		}
+
+		lkp = *pg;
+		lockpage(lkp);
+		if(lkp->ref > 1) {
+			unlockpage(lkp);
+			if(new == 0 && (new = newpage(0, &s, addr)) && s == 0)
+				goto again;
+			*pg = new;
+			new = 0;
+			copypage(lkp, *pg);
+			putpage(lkp);
+		}
+		else {
+			/* put a duplicate of a text page back onto the free list */
+			if(lkp->image)     
+				duppage(lkp);	
+		
+			unlockpage(lkp);
+		}
+	done:
+		mmuphys = PPN((*pg)->pa) | PTEWRITE|PTEVALID;
+		(*pg)->modref = PG_MOD|PG_REF;
+		break;
+	case SG_PHYSICAL:
+		if(*pg == 0)
+			*pg = (*s->pgalloc)(addr);
+
+		mmuphys = PPN((*pg)->pa) | PTEWRITE|PTEUNCACHED|PTEVALID;
+		(*pg)->modref = PG_MOD|PG_REF;
+		break;
+	default:
+		panic("fault");
+	}
+
+	qunlock(&s->lk);
+	if(new)
+		putpage(new);
+
+	putmmu(addr, mmuphys, *pg);
+	return 0;
+}
+
+void
+pio(Segment *s, ulong addr, ulong soff, Page **p)
+{
+	Page *new;
+	KMap *k;
+	Chan *c;
+	int n, ask;
+	char *kaddr;
+	ulong daddr;
+	Page *loadrec;
+
+	loadrec = *p;
+	if(loadrec == 0) {
+		daddr = s->fstart+soff;			/* Compute disc address */
+		new = lookpage(s->image, daddr);
+	}
+	else {
+		daddr = swapaddr(loadrec);
+		new = lookpage(&swapimage, daddr);
+		if(new)
+			putswap(loadrec);
 	}
 
-	if(o->flag&OSHARED) {
-		/* BUG: Does not cover enough flag options to shared data */
-		mmuphys = PTERONLY;
-		if(o->flag & OWRPERM)
-			mmuphys = PTEWRITE;
+	if(new) {			/* Page found from cache */
+		*p = new;
+		return;
 	}
-	else if((o->flag&OWRPERM) && (conf.copymode || !read)
-	&& ((head && ((o->flag&OPURE) || o->nproc>1))
-	    || (!head && pte->page->ref>1))){
-		/*
-		 * Copy on reference (conf.copymode==1) or write (conf.copymode==0)
-		 */
-
-		if(!(o->flag&OISMEM))
-			panic("copy on ref/wr to non memory");
-		touched = 1;
-		/*
-		 * Look for the easy way out: are we the last non-modified?
-		 */
-		if(head && !(o->flag&OPURE)){
-			npte = opte;
-			for(i=0; npte; i++)
-				npte = npte->nextmod;
-			if(i == o->nproc)
-				goto easy;
+
+	qunlock(&s->lk);
+
+	new = newpage(0, 0, addr);
+	k = kmap(new);
+	kaddr = (char*)VA(k);
+	
+	if(loadrec == 0) {			/* This is demand load */
+		c = s->image->c;
+		qlock(&c->rdl);
+		if(waserror()) {
+			qunlock(&c->rdl);
+			kunmap(k);
+			putpage(new);
+			qlock(&s->lk);
+			qunlock(&s->lk);
+			pexit("demand load I/O error", 0);
 		}
-		if(head){
-			/*
-			 * Add to mod list
-			 */
-			pte = newmod(o);
-			pte->proc = u->p;
-			pte->page = opte->page;
-			pte->page->ref++;
-			o->npage++;
-			/*
-			 * Link into opte mod list (same va)
-			 */
-			pte->nextmod = opte->nextmod;
-			opte->nextmod = pte;
-			/*
-			 * Link into proc mod list (increasing va)
-			 */
-			npte = s->mod;
-			if(npte == 0){
-				s->mod = pte;
-				pte->nextva = 0;
-			}else{
-				while(npte->nextva && npte->nextva->page->va<addr)
-					npte = npte->nextva;
-				pte->nextva = npte->nextva;
-				npte->nextva = pte;
-			}
-			head = 0;
+
+		ask = s->flen-soff;
+		if(ask > BY2PG)
+			ask = BY2PG;
+		n = (*devtab[c->type].read)(c, kaddr, ask, daddr);
+		if(n != ask)
+			error(Eioload);
+		if(ask < BY2PG)
+			memset(kaddr+ask, 0, BY2PG-ask);
+
+		if((s->type&SG_TYPE) == SG_TEXT)
+			memset(new->cachectl, PG_TXTFLUSH, sizeof(new->cachectl));
+
+		poperror();
+		kunmap(k);
+		qunlock(&c->rdl);
+		qlock(&s->lk);
+		if(*p == 0) { 			/* Someone may have got there first */
+			new->daddr = daddr;
+			cachepage(new, s->image);
+			*p = new;
 		}
-		pg = pte->page;
-		/* when creating pages in the bss which are zfod we create a double
-		 * increment on the mod list which must be removed
-		 */
-		if(zeroed){
-			pg->ref--;
-			o->npage--;
-			opte->page = 0;
-		}else{		/* copy page */
-			pte->page = newpage(1, o, addr);
-			k = kmap(pte->page);
-			k1 = kmap(pg);
-			memmove((void*)VA(k), (void*)VA(k1), BY2PG);
+		else 
+			putpage(new);
+	}
+	else {					/* This is paged out */
+		c = swapimage.c;
+		qlock(&c->rdl);
+
+		if(waserror()) {
+			qunlock(&c->rdl);
 			kunmap(k);
-			kunmap(k1);
-			if(pg->ref <= 1)
-				panic("pg->ref <= 1");
-			pg->ref--;
+			putpage(new);
+			qlock(&s->lk);
+			qunlock(&s->lk);
+			pexit("page in I/O error", 0);
 		}
 
-    easy:
-		mmuphys = PTEWRITE;
-	}else{
-		mmuphys = PTERONLY;
-		if(o->flag & OWRPERM)
-			if(o->flag & OPURE){
-				if(!head && pte->page->ref==1)
-					mmuphys = PTEWRITE;
-			}else
-				if((head && o->nproc==1)
-	  			  || (!head && pte->page->ref==1))
-					mmuphys = PTEWRITE;
-	}
-	mmuvirt = addr;
-
-	/* Non memory is always uncached */
-	if(o->flag&OISMEM) {
-		mmuphys |= PPN(pte->page->pa) | PTEVALID;
-		usepage(pte->page, 1);
-	}else
-		mmuphys |= PPN(pte->page->pa) | PTEVALID | PTEUNCACHED;
-
-	if(pte->page->va != addr)
-		panic("wrong addr in tail %lux %lux", pte->page->va, addr);
-	if(pte->proc && pte->proc != u->p){
-		print("wrong proc in tail %d %s\n", head, u->p->text);
-		print("u->p %lux pte->proc %lux\n", u->p, pte->proc);
-		panic("addr %lux seg %d wrong proc in tail", addr, s-u->p->seg);
-	}
+		n = (*devtab[c->type].read)(c, kaddr, BY2PG, daddr);
+		if(n != BY2PG)
+			error(Eioload);
 
-	unlock(o);
-	if(touched == 0)
-		m->tlbfault++;
+		poperror();
+		kunmap(k);
+		qunlock(&c->rdl);
+		qlock(&s->lk);
 
-	putmmu(mmuvirt, mmuphys);
-	return 0;
+		if(pagedout(*p)) {
+			new->daddr = daddr;
+			cachepage(new, &swapimage);
+			putswap(*p);
+			*p = new;
+		}
+		else
+			putpage(new);
+	}
 }
 
 /*


@@ 235,36 219,35 @@ fault(ulong addr, int read)
 void
 validaddr(ulong addr, ulong len, int write)
 {
-	Seg *s, *ns;
+	Segment *s;
 
-	if((long)len < 0){
-    Err:
-		pprint("invalid address %lux in sys call pc %lux sp %lux\n", 
-			addr, ((Ureg*)UREGADDR)->pc, ((Ureg*)UREGADDR)->sp);
-		postnote(u->p, 1, "sys: bad address", NDebug);
-		error(Ebadarg);
-	}
-    Again:
-	s = seg(u->p, addr);
-	if(s==0){
-		s = &u->p->seg[SSEG];
-		if(s->o==0 || addr<s->maxva-USTKSIZE || addr>=s->maxva)
-			goto Err;
-	}
-	if(write && (s->o->flag&OWRPERM)==0)
-		goto Err;
-	if(addr+len > s->maxva){
-		len -= s->maxva - addr;
-		addr = s->maxva;
-		goto Again;
+	if((long)len >= 0) {
+		for(;;) {
+			s = seg(u->p, addr, 0);
+			if(s == 0 || (write && (s->type&SG_RONLY)))
+				break;
+
+			if(addr+len > s->top) {
+				len -= s->top - addr;
+				addr = s->top;
+				continue;
+			}
+			return;
+		}
 	}
-}
 
+	pprint("invalid address %lux in sys call pc %lux sp %lux\n", 
+			addr, ((Ureg*)UREGADDR)->pc, ((Ureg*)UREGADDR)->sp);
+
+	postnote(u->p, 1, "sys: bad address", NDebug);
+	error(Ebadarg);
+}
+  
 /*
  * &s[0] is known to be a valid address.
  */
 void*
-vmemchr(void *s, int c, ulong n)
+vmemchr(void *s, int c, int n)
 {
 	int m;
 	char *t;


@@ 272,32 255,37 @@ vmemchr(void *s, int c, ulong n)
 
 	a = (ulong)s;
 	m = BY2PG - (a & (BY2PG-1));
-	while(n){
-		if(n < m)
-			m = n;
-		t = memchr(s, c, m);
+	if(m < n){
+		t = vmemchr(s, c, m);
 		if(t)
 			return t;
-		if(n == m)
-			return 0;
 		if(!(a & KZERO))
 			validaddr(a+m, 1, 0);
-		n -= m;
-		a += m;
-		m = BY2PG;
+		return vmemchr((void*)(a+m), c, n-m);
 	}
-	return 0;
+	/*
+	 * All in one page
+	 */
+	return memchr(s, c, n);
 }
 
-Seg*
-seg(Proc *p, ulong addr)
+Segment*
+seg(Proc *p, ulong addr, int dolock)
 {
-	Seg *s, *et;
+	Segment **s, **et, *n;
 
 	et = &p->seg[NSEG];
-	for(s=p->seg; s < et; s++)
-		if(s->o && s->minva<=addr && addr<s->maxva)
-			return s;
+	for(s = p->seg; s < et; s++)
+		if(n = *s)
+		if(addr >= n->base && addr < n->top) {
+			if(dolock == 0)
+				return n;
+
+			qlock(&n->lk);
+			if(addr >= n->base && addr < n->top)
+				return n;
+			qunlock(&n->lk);
+		}
 
 	return 0;
 }

@@ 248,6 248,8 @@ struct Ipconv {
 #define TIMER_RUN	1
 #define TIMER_EXPIRE	2
 
+#define Nreseq		64
+
 #define	set_timer(t,x)	(((t)->start) = (x)/MSPTICK)
 #define	dur_timer(t)	((t)->start)
 #define	read_timer(t)	((t)->count)

@@ 6,48 6,49 @@
 #include	"ureg.h"
 #include	"errno.h"
 
-struct
-{
-	Lock;
-	ulong	addr;
-	int	active;
-	Page	*page;		/* base of Page structures, indexed by phys page number */
-	ulong	minppn;		/* index of first usable page */
-	Page	*head;		/* most recently used */
-	Page	*tail;		/* least recently used */
-}palloc;
-
-struct
-{
-	Lock;
-	Orig	*arena;
-	Orig	*free;
-}origalloc;
-
-typedef union PTEA	PTEA;
-union PTEA{
-	PTE;
-	struct{
-		ulong	n;	/* for growpte */
-		Orig	*o;	/* for growpte */
-		PTEA	*next;	/* for newmod */
-	};
-};
-
-struct
-{
-	Lock;
-	PTEA	*arena;
-	PTEA	*free;
-	PTEA	*end;
-}ptealloc;
+#define PGHFUN(x, y)	(((ulong)x^(ulong)y)%PGHSIZE)
+#define	pghash(s)	palloc.hash[PGHFUN(s->image, p->daddr)]
+
+struct Palloc palloc;
 
-struct{
+struct Ptealloc
+{
 	Lock;
-	PTEA	*free;
-}modalloc;
+	Pte	*free;
+	int	pages;
+}ptealloclk;
 
 extern long end;
+static Lock pglock;
+
+/* Multiplex a hardware lock for per page manipulations */
+void
+lockpage(Page *p)
+{	
+	int s;
+
+	for(;;) {
+		if(p->lock == 0) {
+			s = splhi();
+			lock(&pglock);
+			if(p->lock == 0) {
+				p->lock = 1;
+				unlock(&pglock);
+				splx(s);
+				return;
+			}
+			unlock(&pglock);
+			splx(s);
+		}
+		sched();
+	}
+}
+
+void
+unlockpage(Page *p)
+{
+	p->lock = 0;
+}
 
 /*
  * Called to allocate permanent data structures, before calling pageinit().


@@ 72,73 73,24 @@ ialloc(ulong n, int align)
 
 	if(palloc.addr >= conf.maxialloc)
 		panic("keep bill joy away");
-	return (void*)(p|KZERO);
-}
 
-void
-audit(char *s)
-{
-	int nf, nb;
-	Page *p;
-	static int here;
-
-	do;while(here);
-	here=1;
-	p = palloc.head;
-	nf = nb = 0;
-	while(p){
-		print("%lux %lux %d\n", p->pa, p->va, p->ref);
-		if(p->o){
-			print("\t%d %lux %c\n", p->o->nproc, p->o->qid, devchar[p->o->type]);
-			delay(100);	/* let it drain; there's a lot here */
-		}
-		nf++;
-		p = p->next;
-	}
-	p = palloc.tail;
-	while(p){
-		nb++;
-		p = p->prev;
-	}
-	print("%s: nf: %d nb: %d\n", s, nf, nb);
-	delay(1000);
-	here=0;
+	return (void*)(p|KZERO);
 }
 
 void
 pageinit(void)
 {
 	ulong pa, nb, ppn;
-	ulong i;
+	ulong i, vmem, pmem;
 	Page *p;
-	PTEA *pte;
-	Orig *o;
-
-	ptealloc.arena = ialloc(conf.npte*sizeof(PTEA), 0);
-	ptealloc.free = ptealloc.arena;
-	ptealloc.end = ptealloc.arena+conf.npte;
 
-	modalloc.free = ialloc(conf.nmod*sizeof(PTEA), 0);
-
-	pte = modalloc.free;
-	for(i=0; i<conf.nmod-1; i++,pte++)
-		pte->next = pte+1;
-	pte->next = 0;
-
-	origalloc.free = ialloc(conf.norig*sizeof(Orig), 0);
-	origalloc.arena = origalloc.free;
-
-	o = origalloc.free;
-	for(i=0; i<conf.norig-1; i++,o++)
-		o->next = o+1;
-	o->next = 0;
 	palloc.active = 1;
 
 	nb = (conf.npage<<PGSHIFT) - palloc.addr;
 	nb -= ((nb+(BY2PG-1))>>PGSHIFT)*sizeof(Page);	/* safe overestimate */
 	nb &= ~(BY2PG-1);
-	pa = (conf.npage<<PGSHIFT) - nb;	/* physical addr of first free page */
-	ppn = pa >> PGSHIFT;			/* physical page number of first free page */
+	pa = (conf.npage<<PGSHIFT) - nb; /* physical addr of first free page */
+	ppn = pa >> PGSHIFT;		 /* physical page number of first free page */
 	palloc.page = (Page *)((palloc.addr - ppn*sizeof(Page))|KZERO);
 	/*
 	 * Now palloc.page[ppn] describes first free page


@@ 149,7 101,12 @@ pageinit(void)
 	palloc.head = &palloc.page[ppn];
 	palloc.tail = &palloc.page[conf.npage-1];
 	memset(palloc.head, 0, (conf.npage-ppn)*sizeof(Page));
-	print("%lud free pages\n", conf.npage-ppn);
+
+	pmem = ((conf.npage-ppn)*BY2PG)/1024;
+	vmem = pmem + ((conf.nswap)*BY2PG)/1024;
+	palloc.user = conf.npage-ppn;
+	print("%lud free pages, %dK bytes, swap %dK bytes\n", palloc.user, pmem, vmem);
+
 	for(p=palloc.head; p<=palloc.tail; p++,ppn++){
 		p->next = p+1;
 		p->prev = p-1;


@@ 157,583 114,336 @@ pageinit(void)
 			p->pa = conf.base0+(ppn<<PGSHIFT);
 		else
 			p->pa = conf.base1+((ppn-conf.npage0)<<PGSHIFT);
+		palloc.freecount++;
 	}
 	palloc.head->prev = 0;
 	palloc.tail->next = 0;
 }
 
 Page*
-newpage(int noclear, Orig *o, ulong va)
+newpage(int clear, Segment **s, ulong va)
 {
 	Page *p;
-	Orig *o1;
 	KMap *k;
+	int i;
 
 	if(palloc.active == 0)
 		print("newpage inactive\n");
-loop:
+
 	lock(&palloc);
-	for(p=palloc.tail; p; p=p->prev){
-		if(p->ref == 0)
-			goto out;
-#ifdef asdf
-		if(p->ref == 1){	/* a pageout daemon should do this */
-			o1 = p->o;
-			if(o1 && o1->nproc==0 && canlock(o1)){
-				if(o1->nproc){
-					unlock(o1);
-					continue;
-				}
-				print("free %d pages va %lux %lux %c\n", o1->npage, o->va, o1->qid, devchar[o1->type]);
-				freepage(o1, 0);
-				/* neworig will free the orig and pte's later */
-				unlock(o1);
-				if(p->ref == 0)
-					goto out;
-				print("newpage ref != 0");
-			}
+
+	/* The kp test is a poor guard against the pager deadlocking */
+	while((palloc.freecount < HIGHWATER && u->p->kp == 0) || palloc.freecount == 0) {
+		palloc.wanted++;
+		unlock(&palloc);			
+		if(s && *s) {
+			qunlock(&((*s)->lk));
+			*s = 0;
 		}
-#endif
+		qlock(&palloc.pwait);			/* Hold memory requesters here */
+
+		kickpager();
+		tsleep(&palloc.r, ispages, 0, 1000);
+
+		qunlock(&palloc.pwait);
+		lock(&palloc);
+		palloc.wanted--;
 	}
+
+	p = palloc.head;
+	if(palloc.head = p->next)		/* = Assign */
+		palloc.head->prev = 0;
+	else
+		palloc.tail = 0;
+
+	palloc.freecount--;
 	unlock(&palloc);
-	if(freebroken())
-		goto loop;
-	if(u == 0)
+
+	lockpage(p);
+
+	if(p->ref != 0)
 		panic("newpage");
-	print("no physical memory\n");
-	pprint("no physical memory\n");
-	u->p->state = Wakeme;
-	alarm(1000, wakeme, u->p);
-	sched();
-	goto loop;
-    out:
-	if(p->o){
-		print("page in use %lux %lux %lux %lux\n", p, p->va, p->o, origalloc.arena);
-		print("%c %lux %lux, %d %d %d\n", devchar[p->o->type], p->o->va, p->o->qid, p->o->flag, p->o->nproc, p->o->npte);
-		panic("shit");
-	}
-	p->ref = 1;
-	usepage(p, 0);
-	unlock(&palloc);
-	if(!noclear){
+
+	uncachepage(p);
+	p->ref++;
+	p->va = va;
+	p->modref = 0;
+	for(i = 0; i < MAXMACH; i++)
+		p->cachectl[i] = PG_NOFLUSH;
+	unlockpage(p);
+
+	if(clear){
 		k = kmap(p);
 		memset((void*)VA(k), 0, BY2PG);
 		kunmap(k);
 	}
-	p->o = o;
-	p->va = va;
 
 	return p;
 }
 
-/*
- * Move page to head of list
- */
-void
-usepage(Page *p, int dolock)
+int
+ispages(void *p)
 {
-	if(dolock)
-		lock(&palloc);
-	/*
-	 * Unlink
-	 */
-	if(p->prev)
-		p->prev->next = p->next;
-	else
-		palloc.head = p->next;
-	if(p->next)
-		p->next->prev = p->prev;
-	else
-		palloc.tail = p->prev;
-	/*
-	 * Link
-	 */
-	p->next = palloc.head;
-	p->prev = 0;
-	if(p->next)
-		p->next->prev = p;
-	else
-		palloc.tail = p;
-	palloc.head = p;
-	if(dolock)
-		unlock(&palloc);
+	return palloc.freecount >= HIGHWATER;
 }
 
-/*
- * Move page to tail of list
- */
 void
-unusepage(Page *p, int dolock)
+putpage(Page *p)
 {
-	if(dolock)
-		lock(&palloc);
-	/*
-	 * Unlink
-	 */
-	if(p->prev)
-		p->prev->next = p->next;
-	else
-		palloc.head = p->next;
-	if(p->next)
-		p->next->prev = p->prev;
-	else
-		palloc.tail = p->prev;
-	/*
-	 * Link
-	 */
-	p->prev = palloc.tail;
-	p->next = 0;
-	if(p->prev)
-		p->prev->next = p;
-	else
-		palloc.head = p;
-	palloc.tail = p;
-	if(dolock)
-		unlock(&palloc);
-}
+	int count;
 
-Orig*
-lookorig(ulong va, ulong npte, int flag, Chan *c)
-{
-	Orig *o;
-	ulong i;
-
-	for(o=origalloc.arena,i=0; i<conf.norig; i++,o++)
-		if(o->npage && o->qid.path==c->qid.path && o->va==va){
-			lock(o);
-			if(o->npage && eqqid(o->qid, c->qid))
-			if(o->va==va && o->npte==npte && o->flag==flag)
-			if(o->mchan==c->mchan && o->type==c->type && eqqid(o->mqid, c->mqid)){
-				if(o->chan == 0){
-					o->chan = c;
-					incref(c);
-				}
-				o->nproc++;
-				unlock(o);
-				return o;
-			}
-			unlock(o);
-		}
-	return 0;
-}
+	if(onswap(p)) {
+		putswap(p);
+		return;
+	}
 
-Orig*
-neworig(ulong va, ulong npte, int flag, Chan *c)
-{
-	Orig *o;
-	int i, freed;
-
-lockloop:
-	lock(&origalloc);
-loop:
-	if(o = origalloc.free){		/* assign = */
-		origalloc.free = o->next;
-		o->va = va;
-		o->pte = 0;
-		o->flag = flag;
-		o->nproc = 1;
-		o->npage = 0;
-		o->chan = c;
-		o->freepg = unusepage;
-		if(c){
-			o->type = c->type;
-			o->qid = c->qid;
-			o->mchan = c->mchan;
-			o->mqid = c->mqid;
-			incref(c);
-		}else{
-			o->type = 0xFFFF;
-			o->qid = (Qid){~0, ~0};
-			o->mqid = (Qid){~0, ~0};
-			o->mchan = 0;
-		}
-		if(u && u->p && waserror()){
-			unlock(&origalloc);
-			nexterror();
+	lockpage(p);
+	if(--p->ref == 0) {
+		lock(&palloc);
+		if(p->image) {
+			if(palloc.tail) {
+				p->prev = palloc.tail;
+				palloc.tail->next = p;
+				p->next = 0;
+				palloc.tail = p;
+			}
+			else {
+				palloc.head = palloc.tail = p;
+				p->prev = p->next = 0;
+			}
 		}
-		growpte(o, npte);
-		if(u && u->p)
-			poperror();
-		unlock(&origalloc);
-		return o;
-	}
-	/*
-	 * This is feeble.  Orig's should perhaps be held in
-	 * an LRU list.  This algorithm is too aggressive.
-	 */
-	freed = 0;
-	for(o=origalloc.arena,i=0; i<conf.norig; i++,o++){
-		if(o->nproc==0 && canlock(o)){
-			if(o->nproc){
-				unlock(o);
-				continue;
+		else {
+			if(palloc.head) {
+				p->next = palloc.head;
+				palloc.head->prev = p;
+				p->prev = 0;
+				palloc.head = p;
+			}
+			else {
+				palloc.head = palloc.tail = p;
+				p->prev = p->next = 0;
 			}
-			freepage(o, 1);
-			freepte(o);
-			unlock(o);
-			o->next = origalloc.free;
-			origalloc.free = o;
-			freed++;
 		}
-	}
-	if(freed)
-		goto loop;
-	unlock(&origalloc);
-	if(freebroken())
-		goto lockloop;
-	print("no origs freed\n");
-	if(u == 0)
-		panic("neworig");
-	u->p->state = Wakeme;
-	alarm(1000, wakeme, u->p);
-	sched();
-	lock(&origalloc);
-	goto loop;
-}
 
-PTE*
-newmod(Orig *o)
-{
-	PTEA *pte;
-
-loop:
-	lock(&modalloc);
-	if(pte = modalloc.free){		/* assign = */
-		modalloc.free = pte->next;
-		unlock(&modalloc);
-		memset(pte, 0, sizeof(PTE));
-		return pte;
+		palloc.freecount++;		/* Release people waiting for memory */
+		unlock(&palloc);
 	}
-	unlock(&modalloc);
-	print("no mods\n");
-	if(u == 0)
-		panic("newmod");
-	u->p->state = Wakeme;
-	alarm(1000, wakeme, u->p);
-	sched();
-	goto loop;
+	unlockpage(p);
+
+	if(palloc.wanted)
+		wakeup(&palloc.r);
 }
 
-/*
- * Duplicate mod structure for this segment (old) in new process p.
- * old->o must be locked.
- */
 void
-forkmod(Seg *old, Seg *new, Proc *p)
+duppage(Page *p)				/* Always call with p locked */
 {
-	Orig *o;
-	PTE *pte, *ppte, *opte, *npte;
-	ulong va;
-
-	o = old->o;
-	ppte = 0;
-	pte = old->mod;
-	while(pte){
-		npte = newmod(o);
-		npte->proc = p;
-		npte->page = pte->page;
-		pte->page->ref++;
-		o->npage++;
-		/*
-		 * Link into mod list for this va
-		 */
-		npte->nextmod = pte->nextmod;
-		pte->nextmod = npte;
-		/*
-		 * Link into mod list for new segment
-		 */
-		if(ppte == 0)
-			new->mod = npte;
-		else
-			ppte->nextva = npte;
-		npte->nextva = 0;
-		ppte = npte;
-		pte = pte->nextva;
+	Page *np;
+
+	lock(&palloc);
+
+	if(palloc.freecount < HIGHWATER || /* No freelist cache when memory is very low */
+	   p->image == &swapimage) {	   /* No dup for swap pages */
+		unlock(&palloc);
+		uncachepage(p);	
+		return;
 	}
-}
 
-void
-freesegs(int save)
-{
-	int i, j;
-	Seg *s;
-	Orig *o;
-	PTE *pte, *opte;
-	PTEA *old;
-	Page *pg;
-	Chan *c;
+	np = palloc.head;			/* Allocate a new page from freelist */
+	if(palloc.head = np->next)		/* = Assign */
+		palloc.head->prev = 0;
+	else
+		palloc.tail = 0;
 
-	/*
-	 * flushvirt() is a no-op on machines without virtual write-back caches.
-	 * On such machines it is necessary to make sure the caches are flushed
-	 * before the pages are remapped.
-	 */
-	flushvirt();
-	s = u->p->seg;
-	for(i=0; i<NSEG; i++,s++){
-		if(i == save)
-			continue;
-		o = s->o;
-		s->o = 0;	/* seg() won't match it (e.g. in procread()) */
-		if(o == 0)
-			continue;
-		lock(o);
-		if(pte = s->mod){	/* assign = */
-			while(pte){
-				opte = &o->pte[(pte->page->va-o->va)>>PGSHIFT];
-				while(opte->nextmod != pte){
-					if(opte->page && opte->page->va != pte->page->va)
-						panic("pte %lux %lux\n", opte->page->va, pte->page->va);
-					opte = opte->nextmod;
-					if(opte == 0)
-						panic("freeseg opte==0");
-				}
-				opte->nextmod = pte->nextmod;
-				pg = pte->page;
-				if(pg->ref == 1){
-					pte->page = 0;
-					pg->o = 0;
-				}
-				pg->ref--;
-				o->npage--;
-				old = (PTEA*)pte;
-				pte = pte->nextva;
-				lock(&modalloc);
-				old->next = modalloc.free;
-				modalloc.free = old;
-				unlock(&modalloc);
-			}
-		}
-		o->nproc--;
-		if(o->nproc == 0){
-			if(c = o->chan){	/* assign = */
-				o->chan = 0;
-				close(c);
-			}
-			if(!(o->flag&OCACHED) || o->npage==0){
-				freepage(o, 1);
-				freepte(o);
-				unlock(o);
-				lock(&origalloc);
-				o->next = origalloc.free;
-				origalloc.free = o;
-				unlock(&origalloc);
-			}else
-				unlock(o);
-		}else{
-			/*
-			 * BUG: there is a leak here. if the origin pte is being used only
-			 * by the exiting process, the associated page will linger.  the fix
-			 * is to remember either the length of the mod list at each va or
-			 * the number of processes sharing the origin pte, and to promote one
-			 * of the mods to the origin pte when no process is left using the
-			 *  origin pte.
-			 */
-			unlock(o);
-		}
+	if(palloc.tail) {			/* Link back onto tail to give us lru */
+		np->prev = palloc.tail;
+		palloc.tail->next = np;
+		np->next = 0;
+		palloc.tail = np;
+	}
+	else {
+		palloc.head = palloc.tail = np;
+		np->prev = np->next = 0;
 	}
-}
 
-/*
- * Adjust segment to desired size.  This implementation is rudimentary.
- */
-int
-segaddr(Seg *s, ulong min, ulong max)
-{
-	Orig *o;
-
-	if(max < min)
-		return 0;
-	if(min != s->minva)	/* can't grow down yet (stacks: fault.c) */
-		return 0;
-	max = PGROUND(max);
-	o = s->o;
-	if(max == s->maxva)
-		return 1;
-	if(max > s->maxva){
-		/*
-		 * Grow
-		 */
-		/* BUG: check spill onto other segments */
-		if(o->va+BY2PG*o->npte < max)
-			growpte(o, (max-o->va)>>PGSHIFT);
-		s->maxva = max;
-		return 1;
+	unlock(&palloc);
+
+	lockpage(np);				/* Cache the new version */
+	if(np->ref != 0) {			/* Stolen by new page */
+		uncachepage(p);
+		unlockpage(np);
+		return;
 	}
-	/*
-	 * Shrink
-	 */
-	print("segaddr shrink");
-	pexit("Suicide", 0);
+	
+	uncachepage(np);
+	np->va = p->va;
+	np->daddr = p->daddr;
+	copypage(p, np);
+	cachepage(np, p->image);
+	unlockpage(np);
+	uncachepage(p);
 }
 
-/*
- * o is locked
- */
 void
-freepage(Orig *o, int dolock)
+copypage(Page *f, Page *t)
 {
-	PTE *pte;
-	Page *pg;
-	int i;
+	KMap *ks, *kd;
+
+	ks = kmap(f);
+	kd = kmap(t);
+	memmove((void*)VA(kd), (void*)VA(ks), BY2PG);
+	kunmap(ks);
+	kunmap(kd);
+}
 
-	pte = o->pte;
-	for(i=0; i<o->npte; i++,pte++) {
-		if(pg = pte->page){	/* assign = */
-			if(pg->ref == 1){
-				(*o->freepg)(pg, dolock);
-				pte->page = 0;
-				pg->o = 0;
+void
+uncachepage(Page *p)				/* Alway called with a locked page */
+{
+	Page **l, *f;
+
+	if(p->image) {
+		lock(&palloc.hashlock);
+		l = &pghash(p);
+		for(f = *l; f; f = f->hash) {
+			if(f == p) {
+				*l = p->hash;
+				break;
 			}
-			pg->ref--;
+			l = &f->hash;
 		}
+		unlock(&palloc.hashlock);
+		putimage(p->image);
+		p->image = 0;
 	}
-	o->npage = 0;
 }
 
-/*
- * Compacting allocator
- */
-
 void
-freepte(Orig *o)	/* o is locked */
+cachepage(Page *p, Image *i)
 {
-	PTEA *p;
-	p = (PTEA*)(o->pte - 1);
-	p->o = 0;
+	Page **l;
+
+	incref(i);
+	lock(&palloc.hashlock);
+	p->image = i;
+	l = &pghash(p);
+	p->hash = *l;
+	*l = p;
+	unlock(&palloc.hashlock);
 }
 
-/*
- * o is locked.  this will always do a grow; if n<=o->npte someone
- * else got here first and we can just return.
- */
-void
-growpte(Orig *o, ulong n)
+Page *
+lookpage(Image *i, ulong daddr)
 {
-	PTEA *p;
-	ulong nfree;
-
-	lock(&ptealloc);
-	lock(o);
-	if(o->pte){
-		if(o->npte >= n)
-			goto Return;
-		p = (PTEA*)(o->pte - 1);
-		n++;
-		if(p+p->n == ptealloc.free){
-			if(!compactpte(o, n - p->n))
-				goto Trouble;
-			p = (PTEA*)(o->pte - 1);
-			ptealloc.free += n - p->n;
-		}else{
-			if(!compactpte(o, n))
-				goto Trouble;
-			p = ptealloc.free;
-			ptealloc.free += n;
-			memmove(p+1, o->pte, o->npte*sizeof(PTE));
-			p->o = o;
-			((PTEA*)(o->pte-1))->o = 0;
-			o->pte = p+1;
+	Page *f;
+
+	lock(&palloc.hashlock);
+	for(f = palloc.hash[PGHFUN(i, daddr)]; f; f = f->hash) {
+		if(f->image == i && f->daddr == daddr) {
+			unlock(&palloc.hashlock);
+
+			lockpage(f);
+			if(f->image != i || f->daddr != daddr) {
+				unlockpage(f);
+				return 0;
+			}
+
+			lock(&palloc);
+			if(++f->ref == 1) {
+				if(f->prev) 
+					f->prev->next = f->next;
+				else
+					palloc.head = f->next;
+
+				if(f->next)
+					f->next->prev = f->prev;
+				else
+					palloc.tail = f->prev;
+				palloc.freecount--;
+			}
+			unlock(&palloc);
+
+			unlockpage(f);
+			return f;	
 		}
-		memset(p+1+o->npte, 0, (n-(1+o->npte))*sizeof(PTE));
-		p->n = n;
-		o->npte = n-1;
-		goto Return;
 	}
-	n++;
-	if(!compactpte(o, n))
-		goto Trouble;
-	p = ptealloc.free;
-	ptealloc.free += n;
-	memset(p, 0, n*sizeof(PTE));
-	p->n = n;
-	p->o = o;
-	o->pte = p+1;
-	o->npte = n-1;
-    Return:
-	unlock(&ptealloc);
-	unlock(o);
-	return;
-
-    Trouble:
-	unlock(&ptealloc);
-	unlock(o);
-	if(u && u->p)
-		error(Enovmem);
-	panic("growpte fails %d %lux %d\n", n, o->va, o->npte);
+	unlock(&palloc.hashlock);
+	return 0;
 }
 
-int
-compactpte(Orig *o, ulong n)
+Pte*
+ptecpy(Pte *old)
 {
-	PTEA *p1, *p2;
-	Orig *p2o;
-
-	if(ptealloc.end-ptealloc.free >= n)
-		return 1;
-	p1 = ptealloc.arena;	/* dest */
-	p2 = ptealloc.arena;	/* source */
-	while(p2 < ptealloc.free){
-		p2o = p2->o;
-		if(p2o == 0){
-    Free:
-			p2 += p2->n;
-			continue;
-		}
-		if(p1 != p2){
-			if(p2o != o)
-				lock(p2o);
-			if(p2->o != p2o){	/* freepte()d very recently */
-				if(p2->o)
-					panic("compactpte p2->o %lux\n", p2->o);
-				unlock(p2o);
-				goto Free;
+	Page **src, **dst, **end;
+	Pte *new;
+
+	new = ptealloc();
+
+	end = &old->pages[PTEPERTAB];
+	for(src = old->pages, dst = new->pages; src < end; src++, dst++)
+		if(*src) {
+			if(onswap(*src))
+				dupswap(*src);
+			else {
+				lockpage(*src);
+				(*src)->ref++;
+				unlockpage(*src);
 			}
-			memmove(p1, p2, p2->n*sizeof(PTE));
-			p2o->pte = p1+1;
-			if(p2o != o)
-				unlock(p2o);
+			*dst = *src;
 		}
-		p2 += p1->n;
-		p1 += p1->n;
-	}
-	ptealloc.free = p1;
-	if(ptealloc.end-ptealloc.free >= n)
-		return 1;
-	unlock(o);
-	unlock(&ptealloc);
-	if(u && u->p)
-		print("%s: %s: ", u->p->text, u->p->pgrp->user);
-	print("compactpte fails addr %lux %lux %d\n", o->va+n*BY2PG, o->va, n);
-	return 0;
+
+	return new;		
 }
 
-long
-ibrk(ulong addr, int seg)
+Pte*
+ptealloc(void)
 {
-	Seg *s;
+	Pte *new;
+	int i, n;
+	KMap *k;
 
-	s = &u->p->seg[seg];
-	if(seg == LSEG && s->o == 0)
-		mklockseg(s);
+	lock(&ptealloclk);
+	while(ptealloclk.free == 0) {
+		unlock(&ptealloclk);
 
-	/* Allows us to determine the base of the segment */
-	if(addr == 0)
-		return s->minva;
+		k = kmap(newpage(1, 0, 0));
+		new = (Pte*)VA(k);
+		n = (BY2PG/sizeof(Pte))-1;
+		for(i = 0; i < n; i++)
+			new[i].next = &new[i+1];
 
-	if(addr < s->endseg){
-		pprint("addr below segment\n");
-		pexit("Suicide", 0);
-		error(Esegaddr);
+		lock(&ptealloclk);
+		ptealloclk.pages++;
+		new[i].next = ptealloclk.free;
+		ptealloclk.free = new;
 	}
 
-	if(addr > PGROUND(s->endseg))
-		if(segaddr(s, s->minva, addr) == 0){
-			pprint("bad segaddr in brk\n");
-			pexit("Suicide", 0);
-			error(Esegaddr);
-		}
+	new = ptealloclk.free;
+	ptealloclk.free = new->next;
+	unlock(&ptealloclk);
+	memset(new->pages, 0, sizeof(new->pages));
+	return new;
+}
 
-	s->endseg = addr;
-	return 0;
+void
+freepte(Segment *s, Pte *p)
+{
+	Page **pg, **ptop;
+
+	ptop = &p->pages[PTEPERTAB];
+
+	switch(s->type&SG_TYPE) {
+	case SG_PHYSICAL:
+		for(pg = p->pages; pg < ptop; pg++)
+			if(*pg)
+				(*s->pgfree)(*pg);
+		break;
+	default:
+		for(pg = p->pages; pg < ptop; pg++)
+			if(*pg)
+				putpage(*pg);
+	}
+
+	lock(&ptealloclk);
+	p->next = ptealloclk.free;
+	ptealloclk.free = p;
+	unlock(&ptealloclk);
 }

@@ 5,13 5,26 @@
 #include	"fns.h"
 #include	"errno.h"
 
-struct{
+struct
+{
 	Lock;
 	Pgrp	*arena;
 	Pgrp	*free;
 	ulong	pgrpid;
 }pgrpalloc;
 
+struct
+{
+	Lock;
+	Egrp	*free;
+}egrpalloc;
+
+struct
+{
+	Lock;
+	Fgrp	*free;
+}fgrpalloc;
+
 struct{
 	Lock;
 	Mount	*free;


@@ 19,11 32,13 @@ struct{
 }mountalloc;
 
 void
-pgrpinit(void)
+grpinit(void)
 {
 	int i;
 	Pgrp *p;
-	Mount *m;
+	Egrp *e, *ee;
+	Fgrp *f, *fe;
+	Mount *m, *em;
 
 	pgrpalloc.arena = ialloc(conf.npgrp*sizeof(Pgrp), 0);
 	pgrpalloc.free = pgrpalloc.arena;


@@ 33,14 48,26 @@ pgrpinit(void)
 		p->index = i;
 		p->next = p+1;
 		p->mtab = ialloc(conf.nmtab*sizeof(Mtab), 0);
-		p->etab = ialloc(conf.npgenv*sizeof(Envp*), 0);
 	}
 	p[-1].next = 0;
 
-	mountalloc.free = ialloc(conf.nmount*sizeof(Mount), 0);
+	egrpalloc.free = ialloc(conf.npgrp*sizeof(Egrp), 0);
+	ee = &egrpalloc.free[conf.npgrp];
+	for(e = egrpalloc.free; e < ee; e++) {
+		e->next = e+1;
+		e->etab = ialloc(conf.npgenv*sizeof(Envp*), 0);
+	}
+	e[-1].next = 0;
+
+	fgrpalloc.free = ialloc(conf.nproc*sizeof(Fgrp), 0);
+	fe = &fgrpalloc.free[conf.nproc-1];
+	for(f = fgrpalloc.free; f < fe; f++)
+		f->next = f+1;
+	f->next = 0;
 
-	m = mountalloc.free;
-	for(i=0; i<conf.nmount-1; i++,m++)
+	mountalloc.free = ialloc(conf.nmount*sizeof(Mount), 0);
+	em = &mountalloc.free[conf.nmount-1];
+	for(m = mountalloc.free; m < em; m++)
 		m->next = m+1;
 	m->next = 0;
 }


@@ 86,25 113,88 @@ newpgrp(void)
 {
 	Pgrp *p;
 
-loop:
-	lock(&pgrpalloc);
-	if(p = pgrpalloc.free){		/* assign = */
-		pgrpalloc.free = p->next;
-		p->ref = 1;
-		p->pgrpid = ++pgrpalloc.pgrpid;
-		p->nmtab = 0;
-		p->nenv = 0;
+	for(;;) {
+		lock(&pgrpalloc);
+		if(p = pgrpalloc.free){
+			pgrpalloc.free = p->next;
+			p->ref = 1;
+			p->pgrpid = ++pgrpalloc.pgrpid;
+			p->nmtab = 0;
+			unlock(&pgrpalloc);
+			return p;
+		}
 		unlock(&pgrpalloc);
-		return p;
+		resrcwait("no pgrps");
 	}
-	unlock(&pgrpalloc);
-	print("no pgrps\n");
+}
+
+Egrp*
+newegrp(void)
+{
+	Egrp *e;
+
+	for(;;) {
+		lock(&egrpalloc);
+		if(e = egrpalloc.free) {
+			egrpalloc.free = e->next;
+			e->ref = 1;
+			e->nenv = 0;
+			unlock(&egrpalloc);
+			return e;
+		}
+		unlock(&egrpalloc);
+		resrcwait("no envgrps");
+	}
+}
+
+Fgrp*
+newfgrp(void)
+{
+	Fgrp *f;
+
+	for(;;) {
+		lock(&fgrpalloc);
+		if(f = fgrpalloc.free) {
+			fgrpalloc.free = f->next;
+			f->ref = 1;
+			f->maxfd = 0;
+			memset(f->fd, 0, sizeof(f->fd));
+			unlock(&fgrpalloc);
+			return f;
+		}
+		unlock(&fgrpalloc);
+		resrcwait("no filegrps");
+	}
+}
+
+Fgrp*
+dupfgrp(Fgrp *f)
+{
+	Fgrp *new;
+	Chan *c;
+	int i;
+
+	new = newfgrp();
+
+	new->maxfd = f->maxfd;
+	for(i = 0; i <= f->maxfd; i++)
+		if(c = f->fd[i]){
+			incref(c);
+			new->fd[i] = c;
+		}
+
+	return new;
+}
+
+void
+resrcwait(char *reason)
+{
+	print("%s\n", reason);
 	if(u == 0)
-		panic("newpgrp");
+		panic("resched");
 	u->p->state = Wakeme;
 	alarm(1000, wakeme, u->p);
 	sched();
-	goto loop;
 }
 
 void


@@ 112,7 202,6 @@ closepgrp(Pgrp *p)
 {
 	int i;
 	Mtab *m;
-	Envp *ep;
 
 	if(decref(p) == 0){
 		qlock(&p->debug);


@@ 123,10 212,6 @@ closepgrp(Pgrp *p)
 				close(m->c);
 				closemount(m->mnt);
 			}
-		ep = p->etab;
-		for(i=0; i<p->nenv; i++,ep++)
-			if(ep->env)
-				envpgclose(ep->env);
 		lock(&pgrpalloc);
 		p->next = pgrpalloc.free;
 		pgrpalloc.free = p;


@@ 135,6 220,43 @@ closepgrp(Pgrp *p)
 	}
 }
 
+void
+closeegrp(Egrp *e)
+{
+	Envp *ep;
+	int i;
+
+	if(decref(e) == 0) {
+		ep = e->etab;
+		for(i=0; i<e->nenv; i++,ep++)
+			if(ep->env)
+				envpgclose(ep->env);
+		lock(&egrpalloc);
+		e->next = egrpalloc.free;
+		egrpalloc.free = e;
+		unlock(&egrpalloc);
+	}
+}
+
+void
+closefgrp(Fgrp *f)
+{
+	int i;
+	Chan *c;
+
+	if(decref(f) == 0) {
+		for(i = 0; i <= f->maxfd; i++)
+			if(c = f->fd[i])
+				close(c);
+
+		lock(&fgrpalloc);
+		f->next = fgrpalloc.free;
+		fgrpalloc.free = f;
+		unlock(&fgrpalloc);
+	}
+}
+
+
 Mount*
 newmount(void)
 {


@@ 182,7 304,7 @@ closemount(Mount *m)
 }
 
 void
-envcpy(Pgrp *to, Pgrp *from)
+envcpy(Egrp *to, Egrp *from)
 {
 	Envp *ep;
 	Env *e;

@@ 5,27 5,30 @@ typedef struct Blist	Blist;
 typedef struct Chan	Chan;
 typedef struct Dev	Dev;
 typedef struct Dirtab	Dirtab;
+typedef struct Egrp	Egrp;
 typedef struct Env	Env;
 typedef struct Envp	Envp;
 typedef struct Envval	Envval;
 typedef struct Etherpkt	Etherpkt;
+typedef struct Fgrp	Fgrp;
+typedef struct Image	Image;
 typedef struct IOQ	IOQ;
 typedef struct KIOQ	KIOQ;
 typedef struct List	List;
 typedef struct Mount	Mount;
 typedef struct Mtab	Mtab;
 typedef struct Note	Note;
-typedef struct Orig	Orig;
-typedef struct PTE	PTE;
 typedef struct Page	Page;
+typedef struct Palloc	Palloc;
 typedef struct Pgrp	Pgrp;
 typedef struct Proc	Proc;
+typedef struct Pte	Pte;
 typedef struct Qinfo	Qinfo;
 typedef struct QLock	QLock;
 typedef struct Queue	Queue;
 typedef struct Ref	Ref;
 typedef struct Rendez	Rendez;
-typedef struct Seg	Seg;
+typedef struct Segment	Segment;
 typedef struct Stream	Stream;
 
 typedef int Devgen(Chan*, Dirtab*, int, int, Dir*);


@@ 177,7 180,7 @@ struct Env
 	Lock;
 	Envval	*val;
 	char	name[NAMELEN];
-	Env	*next;			/* in chain of Envs for a pgrp */
+	Env	*next;			/* in chain of Envs for a egrp */
 	int	pgref;			/* # pgrps pointing here */
 };
 


@@ 259,57 262,146 @@ struct Note
 	int	flag;			/* whether system posted it */
 };
 
-#define	OWRPERM	0x01	/* write permission */
-#define	OPURE	0x02	/* original data mustn't be written */
-#define	OCACHED	0x04	/* cached; don't discard on exit */
-#define OISMEM	0x08	/* origin contains real memory */
-#define OSHARED	0x10	/* origin does not copy on ref/wr */
+/* Fields for cache control of pages */
+#define	PG_NOFLUSH	0
+#define PG_TXTFLUSH	1
+#define PG_DATFLUSH	2
+/* Simulated modified and referenced bits */
+#define PG_MOD		0x01
+#define PG_REF		0x02
 
-struct Orig
+struct Page
 {
-	Lock;
-	Orig	*next;			/* for allocation */
-	ushort	nproc;			/* processes using it */
-	ushort	npage;			/* sum of refs of pages in it */
-	ushort	flag;
-	ulong	va;			/* va of 0th pte */
-	ulong	npte;			/* #pte's in list */
-	PTE	*pte;
-	Chan	*chan;			/* channel deriving segment (if open) */
-	ushort	type;			/* of channel (which could be non-open) */
-	Qid	qid;
-	Chan	*mchan;
+	ulong	pa;			/* Physical address in memory */
+	ulong	va;			/* Virtual address for user */
+	ulong	daddr;			/* Disc address on swap */
+	ushort	ref;			/* Reference count */
+	char	lock;			/* Software lock */
+	char	modref;			/* Simulated modify/reference bits */
+	char	cachectl[MAXMACH];	/* Cache flushing control for putmmu */
+	Image	*image;			/* Associated text or swap image */
+	Page	*next;			/* Lru free list */
+	Page	*prev;
+	Page	*hash;			/* Image hash chains */
+};
+
+struct Swapalloc
+{
+	Lock;			/* Free map lock */
+	int	free;		/* Number of currently free swap pages */
+	char	*swmap;		/* Base of swap map in memory */
+	char	*alloc;		/* Round robin allocator */
+	char	*top;		/* Top of swap map */
+	Rendez	r;		/* Pager kproc idle sleep */
+}swapalloc;
+
+struct Image
+{
+	Ref;
+	Chan	*c;			/* Channel associated with running image */
+	Qid 	qid;			/* Qid for page cache coherence checks */
 	Qid	mqid;
-	ulong	minca;			/* base of region in chan */
-	ulong	maxca;			/* end of region in chan */
-	void	(*freepg)(Page*, int);	/* how to free pages for this origin */
-	Page	(*allocpg)(int, Orig*, ulong);
+	Chan	*mchan;
+	ushort	type;			/* Device type of owning channel */
+	Segment *s;			/* TEXT segment for image if running, may be null */
+	Image	*hash;			/* Qid hash chains */
+	Image	*next;			/* Free list */
 };
 
-struct Page
+struct Pte
 {
-	Orig	*o;			/* origin of segment owning page */
-	ulong	va;			/* virtual address */
-	ulong	pa;			/* physical address */
-	ushort	ref;
-	Page	*next;
-	Page	*prev;
+	union {
+		Pte	*next;			/* Free list */
+		Page	*pages[PTEPERTAB];	/* Page map for this chunk of pte */
+	};
+};
+
+/* Segment types */
+#define SG_TYPE		007		/* Mask type of segment */
+#define SG_TEXT		000
+#define SG_DATA		001
+#define SG_BSS		002
+#define SG_STACK	003
+#define SG_SHARED	004
+#define SG_PHYSICAL	005
+/* Segment flags */
+#define SG_RONLY	040		/* Segment is read only */
+
+#define HIGHWATER	((conf.npage*5)/100)
+#define MAXHEADROOM	HIGHWATER*2	/* Silly but OK for debug */
+#define PG_ONSWAP	1
+#define pagedout(s)	(((ulong)s)==0 || (((ulong)s)&PG_ONSWAP))
+#define swapaddr(s)	(((ulong)s)&~PG_ONSWAP)
+#define onswap(s)	(((ulong)s)&PG_ONSWAP)
+
+#define SEGMAXSIZE	(SEGMAPSIZE*PTEMAPMEM)
+
+struct Segment
+{
+	Ref;
+	QLock	lk;
+	ushort	steal;			/* Page stealer lock */
+	Segment	*next;			/* free list pointers */
+	ushort	type;			/* segment type */
+	ulong	base;			/* virtual base */
+	ulong	top;			/* virtual top */
+	ulong	size;			/* size in pages */
+	ulong	fstart;			/* start address in file for demand load */
+	ulong	flen;			/* length of segment in file */
+	Image	*image;			/* image in file system attached to this segment */
+	Page	*(*pgalloc)(ulong addr);/* SG_PHYSICAL page allocator */
+	void	(*pgfree)(Page *);	/* SG_PHYSICAL page free */
+	Pte	*map[SEGMAPSIZE];	/* segment pte map */
 };
 
 struct Pgrp
 {
 	Ref;				/* also used as a lock when mounting */
-	Pgrp	*next;
+	Pgrp	*next;			/* free list */
 	int	index;			/* index in pgrp table */
 	ulong	pgrpid;
 	char	user[NAMELEN];
 	int	nmtab;			/* highest active mount table entry, +1 */
-	int	nenv;			/* highest active env table entry, +1 */
 	QLock	debug;			/* single access via devproc.c */
 	Mtab	*mtab;
+};
+
+struct Egrp
+{
+	Ref;
+	Egrp	*next;
+	int	nenv;			/* highest active env table entry, +1 */
 	Envp	*etab;
 };
 
+#define	NFD	100
+struct Fgrp
+{
+	Ref;
+	Fgrp	*next;
+	Chan	*fd[NFD];
+	int	maxfd;			/* highest fd in use */
+};
+
+#define PGHSIZE	512
+struct Palloc
+{
+	Lock;
+	ulong	addr;
+	int	active;
+	Page	*page;		/* base of Page structures, indexed by phys page number */
+	ulong	minppn;		/* index of first usable page */
+	Page	*head;		/* most recently used */
+	Page	*tail;		/* least recently used */
+	ulong	freecount;	/* how many pages on free list now */
+	ulong	user;		/* how many user pages */
+	Page	*hash[PGHSIZE];
+	Lock	hashlock;
+	Rendez	r;		/* Sleep for free mem */
+	QLock	pwait;		/* Queue of procs waiting for memory */
+	int	wanted;		/* Do the wakeup at free */
+};
+
 enum					/* Argument to forkpgrp call */
 {
 	FPall 	  = 0,			/* Concession to back portablility */


@@ 324,17 416,7 @@ enum					/* Argument to forkpgrp call */
  */
 enum
 {
-	SSEG, TSEG, DSEG, BSEG, ESEG, LSEG, NSEG
-};
-
-struct Seg
-{
-	Proc	*proc;			/* process owning this segment */
-	Orig	*o;			/* root list of pte's */
-	ulong	minva;			/* va of 0th pte (not necessarily Seg->o->va) */
-	ulong	maxva;			/* va of last pte */
-	PTE	*mod;			/* list of modified pte's */
-	ulong	endseg;			/* segments end */
+	SSEG, TSEG, DSEG, BSEG, ESEG, LSEG, SEG1, SEG2, NSEG
 };
 
 /*


@@ 354,6 436,16 @@ enum
 	Inwait,
 	Wakeme,
 	Broken,
+	Stopped,
+};
+
+/*
+ * devproc requests
+ */
+enum
+{
+	Proc_stopme = 1,
+	Proc_exitme = 2,
 };
 
 /*


@@ 379,14 471,18 @@ struct Proc
 	QLock	*qlock;			/* address of qlock being queued for DEBUG */
 	int	state;
 	Page	*upage;			/* BUG: should be unlinked from page list */
-	Seg	seg[NSEG];
+	Segment	*seg[NSEG];
 	ulong	pid;
 	int	nchild;
 	QLock	wait;			/* exiting children to be waited for */
 	Waitmsg	waitmsg;		/* this is large but must be addressable */
 	Proc	*child;
 	Proc	*parent;
-	Pgrp	*pgrp;
+
+	Pgrp	*pgrp;			/* Process group for notes and namespace */
+	Egrp 	*egrp;			/* Environment group */
+	Fgrp	*fgrp;			/* File descriptor group */
+
 	ulong	parentpid;
 	ulong	time[6];		/* User, Sys, Real; child U, S, R */
 	short	exiting;


@@ 400,22 496,15 @@ struct Proc
 	int	kp;			/* true if a kernel process */
 	Proc	*palarm;		/* Next alarm time */
 	ulong	alarm;			/* Time of call */
-	int	hasspin;
-
+	int 	hasspin;		/* I hold a spin lock */
+	int	newtlb;			/* Pager has touched my tables so I must flush */
+	int	procctl;		/* Control for /proc debugging */
 	/*
 	 *  machine specific MMU goo
 	 */
 	PMMU;
 };
 
-struct PTE
-{
-	Proc	*proc;			/* process owning this PTE (0 in Orig) */
-	PTE	*nextmod;		/* next at this va */
-	PTE	*nextva;		/* next in this proc at higher va */
-	Page	*page;
-};
-
 /*
  *  operations available to a queue
  */


@@ 504,10 593,12 @@ extern	char	devchar[];
 extern	char	user[NAMELEN];
 extern	char	*errstrtab[];
 extern	char	*statename[];
+extern	Palloc 	palloc;
+extern  Image	swapimage;
 
-#define	CHDIR	0x80000000L
-#define	CHAPPEND 0x40000000L
-#define	CHEXCL	0x20000000L
+#define	CHDIR		0x80000000L
+#define	CHAPPEND 	0x40000000L
+#define	CHEXCL		0x20000000L
 
 
 

@@ 1,19 1,23 @@
+
 #define	SET(x)	x = 0
 #define	USED(x)	if(x)
 
-Alarm*	alarm(int, void (*)(Alarm*), void*);
 void	alarminit(void);
+Alarm*	alarm(int, void (*)(Alarm*), void*);
 Block*	allocb(ulong);
+Image*	attachimage(int, Chan*, ulong, ulong);
 int	anyready(void);
 void	append(List**, List*);
 int	blen(Block *);
 int	bround(Block *, int);
 void	buzz(int, int);
+void	cachepage(Page*, Image*);
 void	cancel(Alarm*);
 int	cangetc(void*);
 int	canlock(Lock*);
-int	canputc(void*);
 int	canqlock(QLock*);
+int	canpage(Proc*);
+int	canputc(void*);
 void	chandevinit(void);
 void	chandevreset(void);
 void	chaninit(void);


@@ 23,15 27,17 @@ Chan*	clone(Chan*, Chan*);
 void	close(Chan*);
 void	closemount(Mount*);
 void	closepgrp(Pgrp*);
+void	closeegrp(Egrp*);
+void	closefgrp(Fgrp*);
 long	clrfpintr(void);
-int	compactpte(Orig*, ulong);
 void	confinit(void);
 int	consactive(void);
 Env*	copyenv(Env*, int);
+void	copypage(Page*, Page*);
 int	decref(Ref*);
 void	delay(int);
-void	delete(List**, List*, List*);
 void	delete0(List**, List*);
+void	delete(List**, List*, List*);
 Chan*	devattach(int, char*);
 Chan*	devclone(Chan*, Chan*);
 void	devdir(Chan*, Qid, char*, long, long, Dir*);


@@ 45,8 51,12 @@ void*	dmaalloc(ulong);
 void	dumpqueues(void);
 void	dumpregs(Ureg*);
 void	dumpstack(void);
-void	envcpy(Pgrp*, Pgrp*);
+Fgrp*	dupfgrp(Fgrp*);
+void	dupswap(Page*);
 void	envpgclose(Env *);
+void	duppage(Page*);
+Segment* dupseg(Segment*);
+void	envcpy(Egrp*, Egrp*);
 int	eqchan(Chan*, Chan*, long);
 int	eqqid(Qid, Qid);
 void	error(int);


@@ 54,61 64,61 @@ void	errors(char*);
 void	execpc(ulong);
 void	exit(void);
 int	fault(ulong, int);
-void	fdclose(int);
+void	fdclose(int, int);
 Chan*	fdtochan(int, int);
 void	firmware(void);
 void	flowctl(Queue*);
 void	flushmmu(void);
-void	forkmod(Seg*, Seg*, Proc*);
 void	freealarm(Alarm*);
 void	freeb(Block*);
 int	freebroken(void);
 void	freechan(Chan*);
-void	freepage(Orig*, int);
-void	freepte(Orig*);
+void	freepte(Segment*, Pte*);
 void	freesegs(int);
 Block*	getb(Blist*);
 int	getc(IOQ*);
+int	gets(IOQ*, void*, int);
 int	getfields(char*, char**, int, char);
 Block*	getq(Queue*);
-int	gets(IOQ*, void*, int);
 void	gotolabel(Label*);
-void	growpte(Orig*, ulong);
 void*	ialloc(ulong, int);
 long	ibrk(ulong, int);
 int	incref(Ref*);
 void	initq(IOQ*);
+void	initseg(void);
 void	insert(List**, List*, List*);
 void	invalidateu(void);
 void	isdir(Chan*);
+int	ispages(void*);
 void	kbdclock(void);
-int	kbdputc(IOQ*, int);
 void	kbdrepeat(int);
+int	kbdputc(IOQ*, int);
 int	kprint(char*, ...);
 void	kproc(char*, void(*)(void*), void*);
+void	kickpager(void);
 void	lights(int);
-Page*	lkpage(Orig*, ulong);
-void	lkpgfree(Page*, int);
 void	lock(Lock*);
+void	lockpage(Page*);
 void	lockinit(void);
-Orig*	lookorig(ulong, ulong, int, Chan*);
+Page*	lookpage(Image*, ulong);
 void	machinit(void);
 void	mapstack(Proc*);
-void	mklockseg(Seg*);
-void	mmurelease(Proc*);
+void	mfreeseg(Segment*, ulong, int);
 void	mntdump(void);
-int	mount(Chan*, Chan*, int);
+void	mmurelease(Proc*);
 int	mouseputc(IOQ*, int);
+int	mount(Chan*, Chan*, int);
 Chan*	namec(char*, int, int, ulong);
 Alarm*	newalarm(void);
 Chan*	newchan(void);
-PTE*	newmod(Orig*);
+Egrp*	newegrp(void);
+Fgrp*	newfgrp(void);
 Mount*	newmount(void);
-Orig*	neworig(ulong, ulong, int, Chan*);
-Page*	newpage(int, Orig*, ulong);
+Page*	newpage(int, Segment **, ulong);
 Pgrp*	newpgrp(void);
 Proc*	newproc(void);
 void	newqinfo(Qinfo*);
+Segment* newseg(int, ulong, ulong);
 char*	nextelem(char*, char*);
 void	nexterror(void);
 void	notify(Ureg*);


@@ 116,61 126,74 @@ void	nullput(Queue*, Block*);
 int	openmode(ulong);
 Block*	padb(Block*, int);
 void	pageinit(void);
+int	pagemeis0(void*);
 void	panic(char*, ...);
 void	pexit(char*, int);
 void	pgrpcpy(Pgrp*, Pgrp*);
-void	pgrpinit(void);
+void	pio(Segment *, ulong, ulong, Page **);
+Pte*	ptecpy(Pte*);
+void	putseg(Segment*);
+void	putswap(Page*);
+void	grpinit(void);
 void	pgrpnote(Pgrp*, char*, long, int);
 Pgrp*	pgrptab(int);
 #define	poperror()	u->nerrlab--
 int	postnote(Proc*, int, char*, int);
 int	pprint(char*, ...);
 void	printinit(void);
+void	procctl(Proc *p);
+void	putimage(Image*);
+void	putpage(Page*);
+void	putstr(char*);
+int	putc(IOQ*, int);
+void	putstr(char*);
+void	putstrn(char*, long);
+void	puts(IOQ*, void*, int);
 ulong 	procalarm(ulong);
 void	procdump(void);
 void	procinit0(void);
 Proc*	proctab(int);
+Pte*	ptealloc(void);
 Block*	pullup(Block *, int);
 Queue*	pushq(Stream*, Qinfo*);
 int	putb(Blist*, Block*);
 void	putbq(Blist*, Block*);
-int	putc(IOQ*, int);
-void	putmmu(ulong, ulong);
+void	putmmu(ulong, ulong, Page*);
 int	putq(Queue*, Block*);
-void	puts(IOQ*, void*, int);
-void	putstr(char*);
-void	putstrn(char*, long);
 ulong	pwait(Waitmsg*);
 void	qlock(QLock*);
 void	qunlock(QLock*);
 int	readnum(ulong, char*, ulong, ulong, int);
 void	ready(Proc*);
+void	relocateseg(Segment*, ulong);
 void	resched(char*);
+void	resrcwait(char*);
 int	return0(void*);
 Proc*	runproc(void);
 void	savefpregs(FPsave*);
 void	sccintr(void);
-void	sccputs(IOQ*, char*, int);
 void	sccsetup(void*);
 void	sccspecial(int, IOQ*, IOQ*, int);
-void	sched(void);
 void	schedinit(void);
+void	sched(void);
 long	seconds(void);
-Seg*	seg(Proc*, ulong);
-int	segaddr(Seg*, ulong, ulong);
+Segment* seg(Proc*, ulong, int);
+void	segpage(Segment*, Page*);
+ulong	segattach(Proc*, ulong, char *, ulong, ulong);
 int	setlabel(Label*);
+void	setswapchan(Chan*);
 char*	skipslash(char*);
 void	sleep(Rendez*, int(*)(void*), void*);
 int	splhi(void);
 int	spllo(void);
 void	splx(int);
-int	streamclose(Chan*);
 int	streamclose1(Stream*);
+int	streamclose(Chan*);
 int	streamenter(Stream*);
 int	streamexit(Stream*, int);
 Devgen	streamgen;
-void	streaminit(void);
 void	streaminit0(void);
+void	streaminit(void);
 Stream*	streamnew(ushort, ushort, ushort, Qinfo*, int);
 void	streamopen(Chan*, Qinfo*);
 int	streamparse(char*, Block*);


@@ 178,15 201,17 @@ long	streamread(Chan*, void*, long);
 void	streamstat(Chan*, char*, char*);
 long	streamwrite(Chan*, void*, long, int);
 long	stringread(Chan*, void*, long, char*, ulong);
+void	swapinit(void);
 long	syscall(Ureg*);
+void	tcpinit(void);
 void	tsleep(Rendez*, int (*)(void*), void*, int);
 void	twakeme(Alarm*);
+void	uncachepage(Page*);
 long	unionread(Chan*, void*, long);
 void	unlock(Lock*);
-void	unusepage(Page*, int);
-void	usepage(Page*, int);
+void	unlockpage(Page*);
 void	userinit(void);
 void	validaddr(ulong, ulong, int);
-void*	vmemchr(void*, int, ulong);
+void*	vmemchr(void*, int, int);
 void	wakeme(Alarm*);
 void	wakeup(Rendez*);

@@ 40,6 40,7 @@ char *statename[]={	/* BUG: generate automatically */
 	"Inwait",
 	"Wakeme",
 	"Broken",
+	"Stopped",
 };
 
 /*


@@ 49,6 50,7 @@ void
 schedinit(void)		/* never returns */
 {
 	Proc *p;
+	Page *pg;
 
 	setlabel(&m->sched);
 	if(u){


@@ 58,16 60,38 @@ schedinit(void)		/* never returns */
 		u = 0;
 		if(p->state == Running)
 			ready(p);
-		else if(p->state == Moribund){
+		else if(p->state == Moribund) {
+			/*
+			 * The Grim Reaper lays waste the bodies of the dead
+			 */
 			p->pid = 0;
 			mmurelease(p);
-			/* procalloc already locked */
+			/* 
+			 * Holding locks:
+			 * 	procalloc, debug, palloc
+			 */
+			pg = p->upage;
+			pg->ref = 0;
+			p->upage = 0;
+			palloc.freecount++;
+			if(palloc.head) {
+				pg->next = palloc.head;
+				palloc.head->prev = pg;
+				pg->prev = 0;
+				palloc.head = pg;
+			}
+			else {
+				palloc.head = palloc.tail = pg;
+				pg->prev = pg->next = 0;
+			}
+
 			p->qnext = procalloc.free;
 			procalloc.free = p;
-			p->upage->ref--;
-			p->upage = 0;
+		
+			unlock(&palloc);
 			unlock(&p->debug);
 			unlock(&procalloc);
+
 			p->state = Dead;
 		}
 		p->mach = 0;


@@ 78,7 102,7 @@ schedinit(void)		/* never returns */
 void
 sched(void)
 {
-	uchar procstate[64];		/* sleaze for portability */
+	uchar procstate[64];
 	Proc *p;
 	ulong tlbvirt, tlbphys;
 	void (*f)(ulong, ulong);


@@ 175,6 199,23 @@ loop:
 	return p;
 }
 
+int
+canpage(Proc *p)
+{
+	int ok = 0;
+
+	splhi();
+	lock(&runhiq);
+	if(p->state != Running) {
+		p->newtlb = 1;
+		ok = 1;
+	}
+	unlock(&runhiq);
+	spllo();
+
+	return ok;
+}
+
 Proc*
 newproc(void)
 {


@@ 192,8 233,11 @@ loop:
 		p->child = 0;
 		p->exiting = 0;
 		p->pgrp = 0;
+		p->egrp = 0;
+		p->fgrp = 0;
 		p->fpstate = FPinit;
 		p->kp = 0;
+		p->procctl = 0;
 		memset(p->seg, 0, sizeof p->seg);
 		lock(&pidalloc);
 		p->pid = ++pidalloc.pid;


@@ 300,8 344,8 @@ wakeup(Rendez *r)
 	p = r->p;
 	if(p){
 		r->p = 0;
-		if(p->state != Wakeme)
-			panic("wakeup: not Wakeme");
+		if(p->state != Wakeme) 
+			panic("wakeup: state");
 		p->r = 0;
 		ready(p);
 	}


@@ 359,7 403,8 @@ postnote(Proc *p, int dolock, char *n, int flag)
 		kunmap(k);
 	if(dolock)
 		unlock(&p->debug);
-	if(r = p->r){	/* assign = */
+
+	if(r = p->r) {		/* assign = */
 		/* wake up */
 		s = splhi();
 		lock(r);


@@ 432,27 477,29 @@ pexit(char *s, int freemem)
 {
 	ulong mypid;
 	Proc *p, *c, *k, *l;
-	int n;
+	int n, i;
 	Chan *ch;
 	char msg[ERRLEN];
 	ulong *up, *ucp, *wp;
 
-	if(s)	/* squirrel away; we'll lose our address space */
+	if(s) 	/* squirrel away; we'll lose our address space */
 		strcpy(msg, s);
 	else
 		msg[0] = 0;
+	
 	c = u->p;
 	c->alarm = 0;
 	mypid = c->pid;
 
-	for(n=0; n<=u->maxfd; n++)
-		if(ch = u->fd[n])	/* assign = */
-			close(ch);
-
+	closefgrp(c->fgrp);
 
 	if(freemem){
-		freesegs(-1);
+		flushvirt();
+		for(i = 0; i < NSEG; i++)
+			if(c->seg[i])
+				putseg(c->seg[i]);
 		closepgrp(c->pgrp);
+		closeegrp(c->egrp);
 		close(u->dot);
 	}
 	/*


@@ 502,18 549,27 @@ pexit(char *s, int freemem)
    out:
 	if(!freemem){
 		addbroken(c);
-		freesegs(-1);
+		flushvirt();
+		for(i = 0; i < NSEG; i++)
+			if(c->seg[i])
+				putseg(c->seg[i]);
 		closepgrp(c->pgrp);
+		closeegrp(c->egrp);
 		close(u->dot);
 	}
 
     done:
 
-	lock(&procalloc);	/* sched() can't do this */
-	lock(&c->debug);	/* sched() can't do this */
-	unusepage(c->upage, 1);	/* sched() can't do this (it locks) */
+	/*
+	 * sched() cannot wait on these locks
+	 */
+	lock(&procalloc);
+	lock(&c->debug);
+	lock(&palloc);
+
 	c->state = Moribund;
-	sched();	/* never returns */
+	sched();
+	panic("pexit");
 }
 
 ulong


@@ 568,15 624,14 @@ procdump(void)
 {
 	int i;
 	Proc *p;
-	Orig *o;
 
-	print("DEBUG\n");
+	print("process table:\n");
 	for(i=0; i<conf.nproc; i++){
 		p = procalloc.arena+i;
 		if(p->state != Dead){
 			print("%d:%s %s upc %lux %s ut %ld st %ld r %lux\n",
-				p->pid, p->text, p->pgrp->user, p->pc, statename[p->state],
-				p->time[0], p->time[1], p->r);
+				p->pid, p->text, p->pgrp->user, p->pc, 
+				statename[p->state], p->time[0], p->time[1], p->r);
 		}
 	}
 }


@@ 591,6 646,7 @@ kproc(char *name, void (*func)(void *), void *arg)
 	User *up;
 	KMap *k;
 	static Pgrp *kpgrp;
+	char *user;
 
 	/*
 	 * Kernel stack


@@ 616,9 672,7 @@ kproc(char *name, void (*func)(void *), void *arg)
 	 * Refs
 	 */
 	incref(up->dot);
-	for(n=0; n<=up->maxfd; n++)
-		up->fd[n] = 0;
-	up->maxfd = 0;
+	p->fgrp = newfgrp();
 	kunmap(k);
 
 	/*


@@ 633,13 687,19 @@ kproc(char *name, void (*func)(void *), void *arg)
 		(*func)(arg);
 		pexit(0, 1);
 	}
+
+	user = "bootes";
 	if(kpgrp == 0){
 		kpgrp = newpgrp();
-		strcpy(kpgrp->user, "bootes");
+		strcpy(kpgrp->user, user);
 	}
 	p->pgrp = kpgrp;
 	incref(kpgrp);
-	sprint(p->text, "%s.%.6s", name, u->p->pgrp->user);
+
+	if(u->p->pgrp->user[0] != '\0')
+		user = u->p->pgrp->user;
+	sprint(p->text, "%s.%.6s", name, user);
+
 	p->nchild = 0;
 	p->parent = 0;
 	memset(p->time, 0, sizeof(p->time));


@@ 652,3 712,17 @@ kproc(char *name, void (*func)(void *), void *arg)
 	 */
 	flushmmu();
 }
+
+void
+procctl(Proc *p)
+{
+	switch(p->procctl) {
+	case Proc_exitme:
+		pexit("Killed", 1);
+	case Proc_stopme:
+		p->procctl = 0;
+		p->state = Stopped;
+		sched();
+		return;
+	}
+}