vx32

segment.c (14276B)

---

 #include	"u.h"
 #include	"lib.h"
 #include	"mem.h"
 #include	"dat.h"
 #include	"fns.h"
 #include	"error.h"
 
 static void	imagereclaim(void);
 static void	imagechanreclaim(void);
 
 #include "io.h"
 
 /*
  * Attachable segment types
  */
 static Physseg physseg[10] = {
 	{ SG_SHARED,	"shared",	0,	SEGMAXSIZE,	0, 	0 },
 	{ SG_BSS,	"memory",	0,	SEGMAXSIZE,	0,	0 },
 	{ 0,		0,		0,	0,		0,	0 },
 };
 
 static Lock physseglock;
 
 #define NFREECHAN	64
 #define IHASHSIZE	64
 #define ihash(s)	imagealloc.hash[s%IHASHSIZE]
 static struct Imagealloc
 {
 	Lock lk;
 	Image	*free;
 	Image	*hash[IHASHSIZE];
 	QLock	ireclaim;	/* mutex on reclaiming free images */
 
 	Chan	**freechan;	/* free image channels */
 	int	nfreechan;	/* number of free channels */
 	int	szfreechan;	/* size of freechan array */
 	QLock	fcreclaim;	/* mutex on reclaiming free channels */
 }imagealloc;
 
 Segment* (*_globalsegattach)(Proc*, char*);
 
 void
 initseg(void)
 {
 	Image *i, *ie;
 
 	imagealloc.free = xalloc(conf.nimage*sizeof(Image));
 	if (imagealloc.free == nil)
 		panic("initseg: no memory");
 	ie = &imagealloc.free[conf.nimage-1];
 	for(i = imagealloc.free; i < ie; i++)
 		i->next = i+1;
 	i->next = 0;
 	imagealloc.freechan = malloc(NFREECHAN * sizeof(Chan*));
 	imagealloc.szfreechan = NFREECHAN;
 }
 
 Segment *
 newseg(int type, ulong base, ulong size)
 {
 	Segment *s;
 	int mapsize;
 
 	if(size > (SEGMAPSIZE*PTEPERTAB))
 		error(Enovmem);
 
 	if(swapfull())
 		error(Enoswap);
 	s = smalloc(sizeof(Segment));
 	s->ref.ref = 1;
 	s->type = type;
 	s->base = base;
 	s->top = base+(size*BY2PG);
 	s->size = size;
 	s->sema.prev = &s->sema;
 	s->sema.next = &s->sema;
 
 	mapsize = ROUND(size, PTEPERTAB)/PTEPERTAB;
 	if(mapsize > nelem(s->ssegmap)){
 		mapsize *= 2;
 		if(mapsize > (SEGMAPSIZE*PTEPERTAB))
 			mapsize = (SEGMAPSIZE*PTEPERTAB);
 		s->map = smalloc(mapsize*sizeof(Pte*));
 		s->mapsize = mapsize;
 	}
 	else{
 		s->map = s->ssegmap;
 		s->mapsize = nelem(s->ssegmap);
 	}
 
 	return s;
 }
 
 void
 putseg(Segment *s)
 {
 	Pte **pp, **emap;
 	Image *i;
 
 	if(s == 0)
 		return;
 
 	i = s->image;
 	if(i != 0) {
 		lock(&i->ref.lk);
 		lock(&s->ref.lk);
 		if(i->s == s && s->ref.ref == 1)
 			i->s = 0;
 		unlock(&i->ref.lk);
 	}
 	else
 		lock(&s->ref.lk);
 
 	s->ref.ref--;
 	if(s->ref.ref != 0) {
 		unlock(&s->ref.lk);
 		return;
 	}
 	unlock(&s->ref.lk);
 
 	qlock(&s->lk);
 	if(i)
 		putimage(i);
 
 	emap = &s->map[s->mapsize];
 	for(pp = s->map; pp < emap; pp++)
 		if(*pp)
 			freepte(s, *pp);
 
 	qunlock(&s->lk);
 	if(s->map != s->ssegmap)
 		free(s->map);
 	if(s->profile != 0)
 		free(s->profile);
 	free(s);
 }
 
 void
 relocateseg(Segment *s, ulong offset)
 {
 	Page **pg, *x;
 	Pte *pte, **p, **endpte;
 
 	endpte = &s->map[s->mapsize];
 	for(p = s->map; p < endpte; p++) {
 		if(*p == 0)
 			continue;
 		pte = *p;
 		for(pg = pte->first; pg <= pte->last; pg++) {
 			if((x = *pg))
 				x->va += offset;
 		}
 	}
 }
 
 Segment*
 dupseg(Segment **seg, int segno, int share)
 {
 	int i, size;
 	Pte *pte;
 	Segment *n, *s;
 
 	n = 0;
 	s = seg[segno];
 
 	qlock(&s->lk);
 	if(waserror()){
 		qunlock(&s->lk);
 		nexterror();
 	}
 	switch(s->type&SG_TYPE) {
 	case SG_TEXT:		/* New segment shares pte set */
 	case SG_SHARED:
 	case SG_PHYSICAL:
 		goto sameseg;
 
 	case SG_STACK:
 		n = newseg(s->type, s->base, s->size);
 		break;
 
 	case SG_BSS:		/* Just copy on write */
 		if(share)
 			goto sameseg;
 		n = newseg(s->type, s->base, s->size);
 		break;
 
 	case SG_DATA:		/* Copy on write plus demand load info */
 		if(segno == TSEG){
 			poperror();
 			qunlock(&s->lk);
 			return data2txt(s);
 		}
 
 		if(share)
 			goto sameseg;
 		n = newseg(s->type, s->base, s->size);
 
 		incref(&s->image->ref);
 		n->image = s->image;
 		n->fstart = s->fstart;
 		n->flen = s->flen;
 		break;
 	}
 	size = s->mapsize;
 	for(i = 0; i < size; i++)
 		if((pte = s->map[i]))
 			n->map[i] = ptecpy(pte);
 
 	n->flushme = s->flushme;
 	if(s->ref.ref > 1)
 		procflushseg(s);
 	poperror();
 	qunlock(&s->lk);
 	return n;
 
 sameseg:
 	incref(&s->ref);
 	poperror();
 	qunlock(&s->lk);
 	return s;
 }
 
 void
 segpage(Segment *s, Page *p)
 {
 	Pte **pte;
 	ulong off;
 	Page **pg;
 
 	if(p->va < s->base || p->va >= s->top)
 		panic("segpage");
 
 	off = p->va - s->base;
 	pte = &s->map[off/PTEMAPMEM];
 	if(*pte == 0)
 		*pte = ptealloc();
 
 	pg = &(*pte)->pages[(off&(PTEMAPMEM-1))/BY2PG];
 	*pg = p;
 	if(pg < (*pte)->first)
 		(*pte)->first = pg;
 	if(pg > (*pte)->last)
 		(*pte)->last = pg;
 }
 
 Image*
 attachimage(int type, Chan *c, ulong base, ulong len)
 {
 	Image *i, **l;
 
 	/* reclaim any free channels from reclaimed segments */
 	if(imagealloc.nfreechan)
 		imagechanreclaim();
 
 	lock(&imagealloc.lk);
 
 	/*
 	 * Search the image cache for remains of the text from a previous
 	 * or currently running incarnation
 	 */
 	for(i = ihash(c->qid.path); i; i = i->hash) {
 		if(c->qid.path == i->qid.path) {
 			lock(&i->ref.lk);
 			if(eqqid(c->qid, i->qid) &&
 			   eqqid(c->mqid, i->mqid) &&
 			   c->mchan == i->mchan &&
 			   c->type == i->type) {
 				goto found;
 			}
 			unlock(&i->ref.lk);
 		}
 	}
 
 	/*
 	 * imagereclaim dumps pages from the free list which are cached by image
 	 * structures. This should free some image structures.
 	 */
 	while(!(i = imagealloc.free)) {
 		unlock(&imagealloc.lk);
 		imagereclaim();
 		sched();
 		lock(&imagealloc.lk);
 	}
 
 	imagealloc.free = i->next;
 
 	lock(&i->ref.lk);
 	incref(&c->ref);
 	i->c = c;
 	i->type = c->type;
 	i->qid = c->qid;
 	i->mqid = c->mqid;
 	i->mchan = c->mchan;
 	l = &ihash(c->qid.path);
 	i->hash = *l;
 	*l = i;
 found:
 	unlock(&imagealloc.lk);
 
 	if(i->s == 0) {
 		/* Disaster after commit in exec */
 		if(waserror()) {
 			unlock(&i->ref.lk);
 			pexit(Enovmem, 1);
 		}
 		i->s = newseg(type, base, len);
 		i->s->image = i;
 		i->ref.ref++;
 		poperror();
 	}
 	else
 		incref(&i->s->ref);
 
 	return i;
 }
 
 static struct {
 	int	calls;			/* times imagereclaim was called */
 	int	loops;			/* times the main loop was run */
 	uvlong	ticks;			/* total time in the main loop */
 	uvlong	maxt;			/* longest time in main loop */
 } irstats;
 
 static void
 imagereclaim(void)
 {
 	int n;
 	Page *p;
 	uvlong ticks;
 
 	irstats.calls++;
 	/* Somebody is already cleaning the page cache */
 	if(!canqlock(&imagealloc.ireclaim))
 		return;
 
 	lock(&palloc.lk);
 	ticks = fastticks(nil);
 	n = 0;
 	/*
 	 * All the pages with images backing them are at the
 	 * end of the list (see putpage) so start there and work
 	 * backward.
 	 */
 	for(p = palloc.tail; p && p->image && n<1000; p = p->prev) {
 		if(p->ref == 0 && canlock(&p->lk)) {
 			if(p->ref == 0) {
 				n++;
 				uncachepage(p);
 			}
 			unlock(&p->lk);
 		}
 	}
 	ticks = fastticks(nil) - ticks;
 	unlock(&palloc.lk);
 	irstats.loops++;
 	irstats.ticks += ticks;
 	if(ticks > irstats.maxt)
 		irstats.maxt = ticks;
 	//print("T%llud+", ticks);
 	qunlock(&imagealloc.ireclaim);
 }
 
 /*
  *  since close can block, this has to be called outside of
  *  spin locks.
  */
 static void
 imagechanreclaim(void)
 {
 	Chan *c;
 
 	/* Somebody is already cleaning the image chans */
 	if(!canqlock(&imagealloc.fcreclaim))
 		return;
 
 	/*
 	 * We don't have to recheck that nfreechan > 0 after we
 	 * acquire the lock, because we're the only ones who decrement 
 	 * it (the other lock contender increments it), and there's only
 	 * one of us thanks to the qlock above.
 	 */
 	while(imagealloc.nfreechan > 0){
 		lock(&imagealloc.lk);
 		imagealloc.nfreechan--;
 		c = imagealloc.freechan[imagealloc.nfreechan];
 		unlock(&imagealloc.lk);
 		cclose(c);
 	}
 
 	qunlock(&imagealloc.fcreclaim);
 }
 
 void
 putimage(Image *i)
 {
 	Chan *c, **cp;
 	Image *f, **l;
 
 	if(i->notext)
 		return;
 
 	lock(&i->ref.lk);
 	if(--i->ref.ref == 0) {
 		l = &ihash(i->qid.path);
 		mkqid(&i->qid, ~0, ~0, QTFILE);
 		unlock(&i->ref.lk);
 		c = i->c;
 
 		lock(&imagealloc.lk);
 		for(f = *l; f; f = f->hash) {
 			if(f == i) {
 				*l = i->hash;
 				break;
 			}
 			l = &f->hash;
 		}
 
 		i->next = imagealloc.free;
 		imagealloc.free = i;
 
 		/* defer freeing channel till we're out of spin lock's */
 		if(imagealloc.nfreechan == imagealloc.szfreechan){
 			imagealloc.szfreechan += NFREECHAN;
 			cp = malloc(imagealloc.szfreechan*sizeof(Chan*));
 			if(cp == nil)
 				panic("putimage");
 			memmove(cp, imagealloc.freechan, imagealloc.nfreechan*sizeof(Chan*));
 			free(imagealloc.freechan);
 			imagealloc.freechan = cp;
 		}
 		imagealloc.freechan[imagealloc.nfreechan++] = c;
 		unlock(&imagealloc.lk);
 
 		return;
 	}
 	unlock(&i->ref.lk);
 }
 
 long
 ibrk(ulong addr, int seg)
 {
 	Segment *s, *ns;
 	ulong newtop, newsize;
 	int i, mapsize;
 	Pte **map;
 
 	s = up->seg[seg];
 	if(s == 0)
 		error(Ebadarg);
 
 	if(addr == 0)
 		return s->base;
 
 	qlock(&s->lk);
 
 	/* We may start with the bss overlapping the data */
 	if(addr < s->base) {
 		if(seg != BSEG || up->seg[DSEG] == 0 || addr < up->seg[DSEG]->base) {
 			qunlock(&s->lk);
 			error(Enovmem);
 		}
 		addr = s->base;
 	}
 
 	newtop = PGROUND(addr);
 	newsize = (newtop-s->base)/BY2PG;
 	if(newtop < s->top) {
 		mfreeseg(s, newtop, (s->top-newtop)/BY2PG);
 		s->top = newtop;
 		s->size = newsize;
 		qunlock(&s->lk);
 		flushmmu();
 		return 0;
 	}
 
 	if(swapfull()){
 		qunlock(&s->lk);
 		error(Enoswap);
 	}
 
 	for(i = 0; i < NSEG; i++) {
 		ns = up->seg[i];
 		if(ns == 0 || ns == s)
 			continue;
 		if(newtop >= ns->base && newtop < ns->top) {
 			qunlock(&s->lk);
 			error(Esoverlap);
 		}
 	}
 
 	if(newsize > (SEGMAPSIZE*PTEPERTAB)) {
 		qunlock(&s->lk);
 		error(Enovmem);
 	}
 	mapsize = ROUND(newsize, PTEPERTAB)/PTEPERTAB;
 	if(mapsize > s->mapsize){
 		map = smalloc(mapsize*sizeof(Pte*));
 		memmove(map, s->map, s->mapsize*sizeof(Pte*));
 		if(s->map != s->ssegmap)
 			free(s->map);
 		s->map = map;
 		s->mapsize = mapsize;
 	}
 
 	s->top = newtop;
 	s->size = newsize;
 	qunlock(&s->lk);
 	return 0;
 }
 
 /*
  *  called with s->lk locked
  */
 void
 mfreeseg(Segment *s, ulong start, int pages)
 {
 	int i, j, size;
 	ulong soff;
 	Page *pg;
 	Page *list;
 
 	soff = start-s->base;
 	j = (soff&(PTEMAPMEM-1))/BY2PG;
 
 	size = s->mapsize;
 	list = nil;
 	for(i = soff/PTEMAPMEM; i < size; i++) {
 		if(pages <= 0)
 			break;
 		if(s->map[i] == 0) {
 			pages -= PTEPERTAB-j;
 			j = 0;
 			continue;
 		}
 		while(j < PTEPERTAB) {
 			pg = s->map[i]->pages[j];
 			/*
 			 * We want to zero s->map[i]->page[j] and putpage(pg),
 			 * but we have to make sure other processors flush the
 			 * entry from their TLBs before the page is freed.
 			 * We construct a list of the pages to be freed, zero
 			 * the entries, then (below) call procflushseg, and call
 			 * putpage on the whole list.
 			 *
 			 * Swapped-out pages don't appear in TLBs, so it's okay
 			 * to putswap those pages before procflushseg.
 			 */
 			if(pg){
 				if(onswap(pg))
 					putswap(pg);
 				else{
 					pg->next = list;
 					list = pg;
 				}
 				s->map[i]->pages[j] = 0;
 			}
 			if(--pages == 0)
 				goto out;
 			j++;
 		}
 		j = 0;
 	}
 out:
 	/* flush this seg in all other processes */
 	if(s->ref.ref > 1)
 		procflushseg(s);
 
 	/* free the pages */
 	for(pg = list; pg != nil; pg = list){
 		list = list->next;
 		putpage(pg);
 	}
 }
 
 Segment*
 isoverlap(Proc *p, ulong va, int len)
 {
 	int i;
 	Segment *ns;
 	ulong newtop;
 
 	newtop = va+len;
 	for(i = 0; i < NSEG; i++) {
 		ns = p->seg[i];
 		if(ns == 0)
 			continue;
 		if((newtop > ns->base && newtop <= ns->top) ||
 		   (va >= ns->base && va < ns->top))
 			return ns;
 	}
 	return nil;
 }
 
 int
 addphysseg(Physseg* new)
 {
 	Physseg *ps;
 
 	/*
 	 * Check not already entered and there is room
 	 * for a new entry and the terminating null entry.
 	 */
 	lock(&physseglock);
 	for(ps = physseg; ps->name; ps++){
 		if(strcmp(ps->name, new->name) == 0){
 			unlock(&physseglock);
 			return -1;
 		}
 	}
 	if(ps-physseg >= nelem(physseg)-2){
 		unlock(&physseglock);
 		return -1;
 	}
 
 	*ps = *new;
 	unlock(&physseglock);
 
 	return 0;
 }
 
 int
 isphysseg(char *name)
 {
 	Physseg *ps;
 	int rv = 0;
 
 	lock(&physseglock);
 	for(ps = physseg; ps->name; ps++){
 		if(strcmp(ps->name, name) == 0){
 			rv = 1;
 			break;
 		}
 	}
 	unlock(&physseglock);
 	return rv;
 }
 
 ulong
 segattach(Proc *p, ulong attr, char *name, ulong va, ulong len)
 {
 	int sno;
 	Segment *s, *os;
 	Physseg *ps;
 
 	if(va != 0 && va >= USTKTOP)
 		error(Ebadarg);
 
 	vmemchr(name, 0, ~0);
 
 	for(sno = 0; sno < NSEG; sno++)
 		if(p->seg[sno] == nil && sno != ESEG)
 			break;
 
 	if(sno == NSEG)
 		error(Enovmem);
 
 	/*
 	 *  first look for a global segment with the
 	 *  same name
 	 */
 	if(_globalsegattach != nil){
 		s = (*_globalsegattach)(p, name);
 		if(s != nil){
 			p->seg[sno] = s;
 			return s->base;
 		}
 	}
 
 	len = PGROUND(len);
 	if(len == 0)
 		error(Ebadarg);
 
 	/*
 	 * Find a hole in the address space.
 	 * Starting at the lowest possible stack address - len,
 	 * check for an overlapping segment, and repeat at the
 	 * base of that segment - len until either a hole is found
 	 * or the address space is exhausted.
 	 */
 	if(va == 0) {
 		va = p->seg[SSEG]->base - len;
 		for(;;) {
 			os = isoverlap(p, va, len);
 			if(os == nil)
 				break;
 			va = os->base;
 			if(len > va)
 				error(Enovmem);
 			va -= len;
 		}
 	}
 
 	va = va&~(BY2PG-1);
 	if(isoverlap(p, va, len) != nil)
 		error(Esoverlap);
 
 	for(ps = physseg; ps->name; ps++)
 		if(strcmp(name, ps->name) == 0)
 			goto found;
 
 	error(Ebadarg);
 found:
 	if(len > ps->size)
 		error(Enovmem);
 
 	attr &= ~SG_TYPE;		/* Turn off what is not allowed */
 	attr |= ps->attr;		/* Copy in defaults */
 
 	s = newseg(attr, va, len/BY2PG);
 	s->pseg = ps;
 	p->seg[sno] = s;
 
 	return va;
 }
 
 void
 pteflush(Pte *pte, int s, int e)
 {
 #if 0	// Not needed for Plan 9 VX - no swap
 	int i;
 	Page *p;
 
 	for(i = s; i < e; i++) {
 		p = pte->pages[i];
 		if(pagedout(p) == 0)
 			memset(p->cachectl, PG_TXTFLUSH, sizeof(p->cachectl));
 	}
 #endif
 }
 
 long
 syssegflush(uint32 *arg)
 {
 	Segment *s;
 	ulong addr, l;
 	Pte *pte;
 	int chunk, ps, pe, len;
 
 	addr = arg[0];
 	len = arg[1];
 
 	while(len > 0) {
 		s = seg(up, addr, 1);
 		if(s == 0)
 			error(Ebadarg);
 
 		s->flushme = 1;
 	more:
 		l = len;
 		if(addr+l > s->top)
 			l = s->top - addr;
 
 		ps = addr-s->base;
 		pte = s->map[ps/PTEMAPMEM];
 		ps &= PTEMAPMEM-1;
 		pe = PTEMAPMEM;
 		if(pe-ps > l){
 			pe = ps + l;
 			pe = (pe+BY2PG-1)&~(BY2PG-1);
 		}
 		if(pe == ps) {
 			qunlock(&s->lk);
 			error(Ebadarg);
 		}
 
 		if(pte)
 			pteflush(pte, ps/BY2PG, pe/BY2PG);
 
 		chunk = pe-ps;
 		len -= chunk;
 		addr += chunk;
 
 		if(len > 0 && addr < s->top)
 			goto more;
 
 		qunlock(&s->lk);
 	}
 	flushmmu();
 	return 0;
 }
 
 void
 segclock(ulong pc)
 {
 	Segment *s;
 
 	s = up->seg[TSEG];
 	if(s == 0 || s->profile == 0)
 		return;
 
 	s->profile[0] += TK2MS(1);
 	if(pc >= s->base && pc < s->top) {
 		pc -= s->base;
 		s->profile[pc>>LRESPROF] += TK2MS(1);
 	}
 }