## diffname port/alloc.c 1992/0618
## diff -e /dev/null /n/bootesdump/1992/0618/sys/src/9/port/alloc.c
0a
#include	"u.h"
#include	"../port/lib.h"
#include	"mem.h"
#include	"dat.h"
#include	"fns.h"
#define	nil	((void*)0)
#define datoff	((int)&((Xhdr*)0)->data)

enum
{
	Nhole	= 128,
	Magic	= 0xDeadBabe,
};

typedef struct Hole Hole;
typedef struct Xalloc Xalloc;
typedef struct Xhdr Xhdr;
struct Hole
{
	ulong	addr;
	ulong	size;
	ulong	top;
	Hole	*link;
};

struct Xhdr
{
	ulong	size;
	ulong	magix;
	char	data[1];
};

struct Xalloc
{
	Lock;
	Hole	hole[Nhole];
	Hole	*flist;
	Hole	*table;
};

Xalloc	xlists;

void
xinit(void)
{
	Hole *h, *eh;

	eh = &xlists.hole[Nhole-1];
	for(h = xlists.hole; h < eh; h++)
		h->link = h+1;

	xlists.flist = h;
}

void
xhole(ulong addr, ulong size)
{
	Hole *h, **l;

	lock(&xlists);
	l = &xlists.table;
	for(h = *l; h; h = h->link) {
		if(h->top == addr) {
			h->size += size;
			h->top = h->addr+h->size;
			unlock(&xlists);
			return;
		}
		if(h->addr > addr)
			break;
		l = &h->link;
	}

	if(xlists.flist == nil) {
		print("xfree: no free holes, leaked %d bytes\n", size);
		unlock(&xlists);
		return;
	}

	h = xlists.flist;
	xlists.flist = h->link;
	h->addr = addr;
	h->top = addr+size;
	h->size = size;
	h->link = *l;
	*l = h;
	unlock(&xlists);
}

void*
xalloc(ulong size)
{
	Hole *h, **l;
	Xhdr *p;

	size += sizeof(Xhdr);

	lock(&xlists);
	l = &xlists.table;
	for(h = *l; h; h = h->link) {
		if(h->size >= size) {
			p = (Xhdr*)h->addr;
			h->addr += size;
			h->size -= size;
			if(h->size == 0) {
				*l = h->link;
				h->link = xlists.flist;
				xlists.flist = h;
			}
			p->magix = Magic;
			p->size = size;
			unlock(&xlists);
			return p->data;
		}
		l = &h->link;
	}
	unlock(&xlists);
	return nil;
}

void
xfree(void *p)
{
	Xhdr *x;

	x = (Xhdr*)((ulong)p - datoff);
	if(x->magix != Magic)
		panic("xfree");

	xhole((ulong)x, x->size);
}

void
xsummary(void)
{
	int i;
	Hole *h;

	i = 0;
	for(h = xlists.flist; h; h = h->link)
		i++;

	print("%d holes free\n", i);
	i = 0;
	for(h = xlists.table; h; h = h->link) {
		print("%lux %lux %d\n", h->addr, h->top, h->size);
		i += h->size;
	}
	print("%d bytes free\n", i);
}
.
## diffname port/alloc.c 1992/0619
## diff -e /n/bootesdump/1992/0618/sys/src/9/port/alloc.c /n/bootesdump/1992/0619/sys/src/9/port/alloc.c
149a
}

void*
malloc(ulong size)
{
	int pow;
	Bucket *bp;

	for(pow = 1; pow < Maxpow; pow++)
		if(size <= (1<<pow))
			goto good;

	return nil;
good:
	/* Allocate off this list */
	lock(&arena);
	bp = arena.btab[pow];
	if(bp) {
		arena.btab[pow] = bp->next;
		unlock(&arena);

		if(bp->magic != 0)
			panic("malloc");

		bp->magic = Magic2n;

		memset(bp->data, 0,  size);
		return  bp->data;
	}
	unlock(&arena);
	size = sizeof(Bucket)+(1<<pow);
	bp = xalloc(size);
	if(bp == nil)
		return nil;

	bp->size = pow;
	bp->magic = Magic2n;
	return bp->data;
}

void*
smalloc(ulong size)
{
	void *p;

	p = malloc(size);
	if(p == nil)
		panic("smalloc should sleep");
	return p;
}

void
free(void *ptr)
{
	Bucket *bp, **l;

	bp = (Bucket*)((ulong)ptr - bdatoff);
	if(bp->magic != Magic2n)
		panic("free");

	bp->magic = 0;
	lock(&arena);
	l = &arena.btab[bp->size];
	bp->next = *l;
	*l = bp;
	unlock(&arena);
.
146c
		print("%.8lux %.8lux %d\n", h->addr, h->top, h->size);
.
133a
xhole(ulong addr, ulong size)
{
	ulong top;
	Hole *h, *c, **l;

	if(size == 0)
		return;

	top = addr + size;
	lock(&xlists);
	l = &xlists.table;
	for(h = *l; h; h = h->link) {
		if(h->top == addr) {
			h->size += size;
			h->top = h->addr+h->size;
			c = h->link;
			if(c && h->top == c->addr) {
				h->top += c->size;
				h->size += c->size;
				h->link = c->link;
				c->link = xlists.flist;
				xlists.flist = c;
			}
			unlock(&xlists);
			return;
		}
		if(h->addr > addr)
			break;
		l = &h->link;
	}
	if(h && top == h->addr) {
		h->addr -= size;
		h->size += size;
		unlock(&xlists);
		return;
	}

	if(xlists.flist == nil) {
		unlock(&xlists);
		print("xfree: no free holes, leaked %d bytes\n", size);
		return;
	}

	h = xlists.flist;
	xlists.flist = h->link;
	h->addr = addr;
	h->top = top;
	h->size = size;
	h->link = *l;
	*l = h;
	unlock(&xlists);
}

void
.
130c
	xhole(PADDR(x), x->size);
.
127c
	if(x->magix != Magichole)
.
110c
			p = KADDR(p);
			memset(p, 0, size);
			p->magix = Magichole;
.
96c
	size += BY2WD + sizeof(Xhdr);
	size &= ~(BY2WD-1);
.
94a
	Hole *h, **l;
.
93d
80,87c
	np0 = up;
	if(np0 > conf.npage0)
		np0 = conf.npage0;

	palloc.p0 = conf.base0;
	conf.base0 += np0*BY2PG;
	conf.npage0 -= np0;
	xhole(conf.base0, conf.npage0*BY2PG);

	palloc.np0 = np0;
	palloc.np1 = np1;
.
74,78c
	palloc.p1 = conf.base1;
	conf.base1 += np1*BY2PG;
	conf.npage1 -= np1;
	xhole(conf.base1, conf.npage1*BY2PG);
	up -= np1;
.
60,72c
	up = conf.upages;
	np1 = up;
	if(np1 > conf.npage1)
		np1 = conf.npage1;
.
55,58c
	ktop = PGROUND((ulong)end);
	ktop = PADDR(ktop);
	conf.npage0 -= ktop/BY2PG;
	conf.base0 += ktop;
.
52,53c
	xlists.flist = xlists.hole;
.
46a
	int up, np0, np1;
.
45a
	ulong ktop;
.
42a
struct Arena
{
	Lock;
	Bucket	*btab[Maxpow];	
};

static Arena	arena;
static Xalloc	xlists;

void*
ialloc(ulong size, int align)
{
	ulong p;

	if(align) {
		size += BY2PG;
		p = (ulong)xalloc(size);
		p += BY2PG;
		p &= ~(BY2PG-1);
		return (void*)p;
	}

	return xalloc(size);
}

void*
iallocspan(ulong size, int quanta, ulong span)
{
	return ialloc(size, quanta);
}

.
41c
struct Bucket
{
	int	size;
	int	magic;
	Bucket	*next;
	char	data[1];
};
.
17a
typedef struct Bucket Bucket;
typedef struct Arena Arena;

.
11,12c
	Maxpow		= 16,
	Nhole		= 128,
	Magichole	= 0xDeadBabe,
	Magic2n		= 0xBadC0c0a,
.
8a
#define	nil		((void*)0)
#define datoff		((ulong)&((Xhdr*)0)->data)
#define bdatoff		((ulong)&((Bucket*)0)->data)

.
6,7d
## diffname port/alloc.c 1992/0620
## diff -e /n/bootesdump/1992/0619/sys/src/9/port/alloc.c /n/bootesdump/1992/0620/sys/src/9/port/alloc.c
311a
}

void
xsummary(void)
{
	Hole *h;
	Bucket *k;
	int i, nfree;

	i = 0;
	for(h = xlists.flist; h; h = h->link)
		i++;

	print("%d holes free\n", i);
	i = 0;
	for(h = xlists.table; h; h = h->link) {
		print("%.8lux %.8lux %d\n", h->addr, h->top, h->size);
		i += h->size;
	}
	print("%d bytes free\n", i);
	for(i = 3; i < Maxpow; i++) {
		if(arena.btab[i] == 0 && arena.nbuck[i] == 0)
			continue;
		nfree = 0;
		for(k = arena.btab[i]; k; k = k->next)
			nfree++;
		print("%8d %4d %4d\n", 1<<i, arena.nbuck[i], nfree);
	}
.
274a
	arena.nbuck[pow]++;
.
254c
	for(pow = 3; pow < Maxpow; pow++)
.
229,247d
59c
	Bucket	*btab[Maxpow];
	int	nbuck[Maxpow];
.
16c
	Magic2n		= 0xFeedBeef,
.
## diffname port/alloc.c 1992/0621
## diff -e /n/bootesdump/1992/0620/sys/src/9/port/alloc.c /n/bootesdump/1992/0621/sys/src/9/port/alloc.c
127a
}

/*
 * NB. spanalloc memory will cause a panic if free'd
 */
void*
xspanalloc(ulong size, int align, ulong span)
{
	int i, j;
	ulong a, p;
	ulong ptr[Spanlist];

	span = ~(span-1);
	for(i = 0; i < Spanlist; i++) {
		p = (ulong)xalloc(size+align);
		if(p == 0)
			panic("xspanalloc: size %d align %d span %d", size, align, span);

		a = p+align;
		a &= ~(align-1);
		if((a&span) == ((a+size)&span)) {
			for(j = 0; j < i; j++)
				xfree((void*)ptr[j]);

			return (void*)a;
		}
		ptr[i] = p;
	}
	panic("xspanalloc: spanlist");		
	return 0;
.
82,87d
78,79c
	return xalloc(size);;
.
16a
	Spanlist	= 64,
.
8,9c
#define datoff		((ulong)((Xhdr*)0)->data)
#define bdatoff		((ulong)((Bucket*)0)->data)
.
6a
/*
 * Plan 9 has two kernel allocators, the x... routines provide a first
 * fit hole allocator which should be used for permanent or large structures.
 * Routines are provided to allocate aligned memory which does not cross
 * arbitrary 2^n boundaries. A second allocator malloc, smalloc, free is
 * a 2n bucket allocator which steals from the x routines. This should
 * be used for small frequently used structures.
 */

.
## diffname port/alloc.c 1992/0622
## diff -e /n/bootesdump/1992/0621/sys/src/9/port/alloc.c /n/bootesdump/1992/0622/sys/src/9/port/alloc.c
309a
	}
.
308c
	if(p == nil) {
		print("asking for %d\n", size);
		xsummary();
.
76,90d
## diffname port/alloc.c 1992/0623
## diff -e /n/bootesdump/1992/0622/sys/src/9/port/alloc.c /n/bootesdump/1992/0623/sys/src/9/port/alloc.c
298a
}

int
msize(void *ptr)
{
	Bucket *bp;

	bp = (Bucket*)((ulong)ptr - bdatoff);
	if(bp->magic != Magic2n)
		panic("msize");
	return 1<<bp->size;
.
173d
168a
			unlock(&xlists);
.
## diffname port/alloc.c 1992/0625
## diff -e /n/bootesdump/1992/0623/sys/src/9/port/alloc.c /n/bootesdump/1992/0625/sys/src/9/port/alloc.c
326a
	if(arena.r.p)
		wakeup(&arena.r);
.
292,296c
	for(;;) {
		p = malloc(size);
		if(p != nil)
			return p;
		s = u->p->psstate;
		u->p->psstate = "Malloc";
		qlock(&arena.rq);
		while(waserror())
			;
		sleep(&arena.r, return0, nil);
		poperror();
		qunlock(&arena.rq);
		u->p->psstate = s;
.
289a
	char *s;
.
115a
	/* Save the bounds of kernel alloc memory for kernel mmu mapping (NeXT) */
	conf.base0 = (ulong)KADDR(conf.base0);
	conf.base1 = (ulong)KADDR(conf.base1);
	conf.npage0 = (ulong)KADDR(conf.npage0);
	conf.npage1 = (ulong)KADDR(conf.npage1);
.
112a
	conf.npage0 = conf.base0+(conf.npage0*BY2PG);
.
102a
	conf.npage1 = conf.base1+(conf.npage1*BY2PG);
.
70a
	QLock	rq;
	Rendez	r;
.
## diffname port/alloc.c 1992/0707
## diff -e /n/bootesdump/1992/0625/sys/src/9/port/alloc.c /n/bootesdump/1992/0707/sys/src/9/port/alloc.c
316c
	pexit(Enomem, 1);
	return 0;
.
302c
	for(attempt = 0; attempt < 1000; attempt++) {
.
300a
	int attempt;
.
263c
	for(pow = 3; pow <= Maxpow; pow++)
.
22c
	Maxpow		= 18,
.
5a
#include	"error.h"
.
## diffname port/alloc.c 1992/0708
## diff -e /n/bootesdump/1992/0707/sys/src/9/port/alloc.c /n/bootesdump/1992/0708/sys/src/9/port/alloc.c
153a
	USED(sinc);
.
152c
		xfree((void*)p);
		ptr[i] = (ulong)xalloc(sinc);
.
148c
				if(ptr[j])
					xfree((void*)ptr[j]);
.
142c
			panic("xspanalloc: size %d align %d span %lux", size, align, span);
.
137a
	sinc = span/8;
.
135c
	ulong a, p, sinc;
.
## diffname port/alloc.c 1992/0715
## diff -e /n/bootesdump/1992/0708/sys/src/9/port/alloc.c /n/bootesdump/1992/0715/sys/src/9/port/alloc.c
91,95d
82d
## diffname port/alloc.c 1992/0720
## diff -e /n/bootesdump/1992/0715/sys/src/9/port/alloc.c /n/bootesdump/1992/0720/sys/src/9/port/alloc.c
286,288c
	size += 3;
	size &= ~3;

	if(pow < CUTOFF) {
		n = (CUTOFF-pow)+2;
		bp = xalloc(size*n);
		if(bp == nil)
			return nil;

		next = (ulong)bp+size;
		nbp = (Bucket*)next;
		lock(&arena);
		arena.btab[pow] = nbp;
		arena.nbuck[pow] += n;
		for(n -= 2; n; n--) {
			next = (ulong)nbp+size;
			nbp->next = (Bucket*)next;
			nbp->size = pow;
			nbp = nbp->next;
		}
		nbp->size = pow;
		unlock(&arena);
	}
	else {
		bp = xalloc(size);
		if(bp == nil)
			return nil;
	}
.
284a

.
283d
259,260c
	ulong next;
	int pow, n;
	Bucket *bp, *nbp;
.
137c
			panic("xspanalloc: %d %d %lux", size, align, span);
.
23a
	CUTOFF		= 12,
.
## diffname port/alloc.c 1992/0726
## diff -e /n/bootesdump/1992/0720/sys/src/9/port/alloc.c /n/bootesdump/1992/0726/sys/src/9/port/alloc.c
116c
	/* Save the bounds of kernel alloc memory for kernel mmu mapping */
.
## diffname port/alloc.c 1992/0729
## diff -e /n/bootesdump/1992/0726/sys/src/9/port/alloc.c /n/bootesdump/1992/0729/sys/src/9/port/alloc.c
153c
	xsummary();
	panic("xspanalloc: %d %d %lux\n", size, align, span);	
.
138c
			break;
.
133c
	sinc = size/8;
.
## diffname port/alloc.c 1992/0912
## diff -e /n/bootesdump/1992/0729/sys/src/9/port/alloc.c /n/bootesdump/1992/0912/sys/src/9/port/alloc.c
403a
	print("%d bytes in pool\n", nused);
.
398a
		nused += arena.nbuck[i]*(1<<i);
.
395a
	nused = 0;
.
383c
	int i, nfree, nused;
.
## diffname port/alloc.c 1992/0913
## diff -e /n/bootesdump/1992/0912/sys/src/9/port/alloc.c /n/bootesdump/1992/0913/sys/src/9/port/alloc.c
315a

		arena.nbuck[pow]++;
.
7a

.
## diffname port/alloc.c 1993/0116
## diff -e /n/bootesdump/1992/0913/sys/src/9/port/alloc.c /n/bootesdump/1993/0116/sys/src/9/port/alloc.c
372,373d
370d
367a
	l = &arena.btab[bp->size];

	lock(&arena);
.
280c
			panic("malloc %lux", bp->magic);
.
## diffname port/alloc.c 1993/0120
## diff -e /n/bootesdump/1993/0116/sys/src/9/port/alloc.c /n/bootesdump/1993/0120/sys/src/9/port/alloc.c
318a
		unlock(&arena);
.
317a
		lock(&arena);
.
310d
308c
			nbp->next = arena.btab[pow];
			arena.btab[pow] = nbp;
.
306c
			nbp = (Bucket*)next;
.
304c
		while(--n) {
.
302d
299,300c
		nbp = bp;
.
266c
	for(pow = 3; pow < Maxpow; pow++)
.
## diffname port/alloc.c 1993/0121
## diff -e /n/bootesdump/1993/0120/sys/src/9/port/alloc.c /n/bootesdump/1993/0121/sys/src/9/port/alloc.c
284c
		memset(bp->data, 0, size);
.
279,280c
		if(bp->magic != 0 || bp->size != pow)
			panic("malloc bp %lux magic %lux size %d next %lux pow %d", bp,
				bp->magic, bp->size, bp->next, pow);
.
## diffname port/alloc.c 1993/0205
## diff -e /n/bootesdump/1993/0121/sys/src/9/port/alloc.c /n/bootesdump/1993/0205/sys/src/9/port/alloc.c
319d
317d
283a
		unlock(&arena);
.
282c
		}
.
277,279c
		if(bp->magic != 0 || bp->size != pow){
			unlock(&arena);
.
## diffname port/alloc.c 1993/0501
## diff -e /n/bootesdump/1993/0205/sys/src/9/port/alloc.c /n/fornaxdump/1993/0501/sys/src/brazil/port/alloc.c
372a
	lock(&arena);
	l = &arena.btab[bp->size];
.
371a

.
367,369d
344c
		up->psstate = s;
.
336,337c
		s = up->psstate;
		up->psstate = "Malloc";
.
309a
		nbp->size = pow;
.
307,308c
			nbp = nbp->next;
.
305c
			nbp->next = (Bucket*)next;
.
303c
		for(n -= 2; n; n--) {
.
301a
		arena.btab[pow] = nbp;
.
300c
		next = (ulong)bp+size;
		nbp = (Bucket*)next;
.
285c
		if(bp->magic != 0)
			panic("malloc");

		bp->magic = Magic2n;

		memset(bp->data, 0,  size);
.
277,282d
266c
	for(pow = 3; pow <= Maxpow; pow++)
.
## diffname port/alloc.c 1993/0515
## diff -e /n/fornaxdump/1993/0501/sys/src/brazil/port/alloc.c /n/fornaxdump/1993/0515/sys/src/brazil/port/alloc.c
109,110c
	palloc.p0 = conf.base0 + (conf.npage0 - np0)*BY2PG;
.
98,99c
	palloc.p1 = conf.base1 + (conf.npage1 - np1)*BY2PG;
.
## diffname port/alloc.c 1993/1121
## diff -e /n/fornaxdump/1993/0515/sys/src/brazil/port/alloc.c /n/fornaxdump/1993/1121/sys/src/brazil/port/alloc.c
320a
bp->pc = pc;
.
281c
bp->pc = pc;
.
262a
ulong pc;
pc = getcallerpc(0);
.
65a
	ulong	pc;
.
## diffname port/alloc.c 1993/1125
## diff -e /n/fornaxdump/1993/1121/sys/src/brazil/port/alloc.c /n/fornaxdump/1993/1125/sys/src/brazil/port/alloc.c
338a
		}
.
337c
		if(p != nil) {
			bp = (Bucket*)((ulong)p - bdatoff);
			bp->pc = getcallerpc(((uchar*)&size) - sizeof(size));
.
333a
	Bucket *bp;
.
324c
	bp->pc = getcallerpc(((uchar*)&size) - sizeof(size));
.
284c
		bp->pc = getcallerpc(((uchar*)&size) - sizeof(size));
.
264,265d
## diffname port/alloc.c 1993/1231
## diff -e /n/fornaxdump/1993/1125/sys/src/brazil/port/alloc.c /n/fornaxdump/1993/1231/sys/src/brazil/port/alloc.c
152,155c
	else
		v = a;

	if(align > 1)
		v = (v + align) & ~(align-1);

	return (void*)v;
.
140,150c
	if(span > 2) {
		v = (a + span) & ~(span-1);
		t = v - a;
		if(t > 0)
			xhole(PADDR(a), t);
		t = a + span - v;
		if(t > 0)
			xhole(PADDR(v+size+align), t);
.
133,138c
	a = (ulong)xalloc(size+align+span);
	if(a == 0)
		panic("xspanalloc: %d %d %lux\n", size, align, span);
.
129,131c
	ulong a, v, t;
.
## diffname port/alloc.c 1994/0208
## diff -e /n/fornaxdump/1993/1231/sys/src/brazil/port/alloc.c /n/fornaxdump/1994/0208/sys/src/brazil/port/alloc.c
120a

	/* setup initial memory allocations for interrupt time */
	qinit();
.
## diffname port/alloc.c 1994/0222
## diff -e /n/fornaxdump/1994/0208/sys/src/brazil/port/alloc.c /n/fornaxdump/1994/0222/sys/src/brazil/port/alloc.c
371c
		panic("free %lux %lux", bp->magic, bp->pc);
.
277c
			panic("malloc %lux %lux", bp->magic, bp->pc);
.
## diffname port/alloc.c 1994/0223
## diff -e /n/fornaxdump/1994/0222/sys/src/brazil/port/alloc.c /n/fornaxdump/1994/0223/sys/src/brazil/port/alloc.c
196,197c
	if(x->magix != Magichole) {
		uchar *a;
		int i;
		a = (uchar*)x;
		for(i = 0; i < 32; i++)
			print("#%lux ", *a++);
		panic("xfree(0x%lux) 0x%lux!=0x%lux", p, Magichole, x->magix);
	}
.
189a
void*
xalloc(ulong size)
{
	return xallocz(size, 1);
}

.
179c
			if(zero)
				memset(p, 0, size);
.
157c
xallocz(ulong size, int zero)
.
## diffname port/alloc.c 1994/0224
## diff -e /n/fornaxdump/1994/0223/sys/src/brazil/port/alloc.c /n/fornaxdump/1994/0224/sys/src/brazil/port/alloc.c
211d
204,208c
		xsummary();
.
## diffname port/alloc.c 1994/0306
## diff -e /n/fornaxdump/1994/0224/sys/src/brazil/port/alloc.c /n/fornaxdump/1994/0306/sys/src/brazil/port/alloc.c
295,296c
	size += BY2V;
	size &= ~(BY2V-1);
.
162,163c
	size += BY2V + sizeof(Xhdr);
	size &= ~(BY2V-1);
.
## diffname port/alloc.c 1994/0322
## diff -e /n/fornaxdump/1994/0306/sys/src/brazil/port/alloc.c /n/fornaxdump/1994/0322/sys/src/brazil/port/alloc.c
386c
	iunlock(&arena);
.
382c
	ilock(&arena);
.
346d
342,344c
		if(p != nil)
.
338d
328c

.
316c
		iunlock(&arena);
.
306c
		ilock(&arena);
.
292c
	iunlock(&arena);
.
288,289c

		if(zero)
			memset(bp->data, 0,  size);
.
282c
		iunlock(&arena);
.
278c
	ilock(&arena);
.
265c
mallocz(ulong size, int zero)
.
261c
	iunlock(&xlists);
.
249c
		iunlock(&xlists);
.
244c
		iunlock(&xlists);
.
234c
			iunlock(&xlists);
.
220c
	ilock(&xlists);
.
191,196d
187c
	iunlock(&xlists);
.
177c
			iunlock(&xlists);
.
165c
	ilock(&xlists);
.
121,123d
## diffname port/alloc.c 1994/0812
## diff -e /n/fornaxdump/1994/0322/sys/src/brazil/port/alloc.c /n/fornaxdump/1994/0812/sys/src/brazil/port/alloc.c
324a
malloc(ulong size)
{
	return mallocz(size, 1);
}

void*
.
## diffname port/alloc.c 1995/0616
## diff -e /n/fornaxdump/1994/0812/sys/src/brazil/port/alloc.c /n/fornaxdump/1995/0616/sys/src/brazil/port/alloc.c
105c
	np0 = upages;
.
103c
	upages -= np1;
.
94,95c
	upages = conf.upages;
	np1 = upages;
.
86c
	int upages, np0, np1;
.
## diffname port/alloc.c 1996/0217
## diff -e /n/fornaxdump/1995/0616/sys/src/brazil/port/alloc.c /n/fornaxdump/1996/0217/sys/src/brazil/port/alloc.c
18d
## diffname port/alloc.c 1996/0305
## diff -e /n/fornaxdump/1996/0217/sys/src/brazil/port/alloc.c /n/fornaxdump/1996/0305/sys/src/brazil/port/alloc.c
266a

.
## diffname port/alloc.c 1996/0324
## diff -e /n/fornaxdump/1996/0305/sys/src/brazil/port/alloc.c /n/fornaxdump/1996/0324/sys/src/brazil/port/alloc.c
23c
	Maxpow		= 19,
.
## diffname port/alloc.c 1996/1120
## diff -e /n/fornaxdump/1996/0324/sys/src/brazil/port/alloc.c /n/fornaxdump/1996/1120/sys/src/brazil/port/alloc.c
373c
		panic("free %lux %lux %lux", bp->magic, bp->pc, getcallerpc(ptr));
.
307d
301,305c
		l = &arena.btab[pow];
		/* add all but the last to the free list */
		while(--n){
			bp->size = pow;
			bp->next = *l;
			*l = bp;
			bp = (Bucket*)((ulong)bp+size);
.
299d
296,297d
259c
	Bucket *bp, **l;
.
257d
## diffname port/alloc.c 1997/1101
## diff -e /n/fornaxdump/1996/1120/sys/src/brazil/port/alloc.c /n/emeliedump/1997/1101/sys/src/brazil/port/alloc.c
410c

	return compacted;
.
399,408c
}

int
poolcompact(Pool *pool)
{
	Bhdr *base, *limit, *ptr, *end, *next;
	int compacted, recov, nb;

	if(pool->move == nil || pool->lastfree == pool->nfree)
		return 0;

	pool->lastfree = pool->nfree;

	base = pool->chain;
	ptr = B2NB(base);	/* First Block in arena has clink */
	limit = B2LIMIT(base);
	compacted = 0;

	pool->root = nil;
	end = ptr;
	recov = 0;
	while(base != nil) {
		next = B2NB(ptr);
		if(ptr->magic == MAGIC_A) {
			if(ptr != end) {
				memmove(end, ptr, ptr->size);
				pool->move(B2D(ptr), B2D(end));
				recov = (uchar*)ptr - (uchar*)end;
				compacted = 1;
			}
			end = B2NB(end);
		}
		if(next >= limit) {
			nb = (uchar*)limit - (uchar*)end;
			//print("recovered %d bytes\n", recov);
			//print("%d bytes at end\n", nb);
			USED(recov);
			if(nb > 0){
				if(nb < pool->quanta+1)
					panic("poolcompact: leftover too small\n");
				end->size = nb;
				pooladd(pool, end);
			}
			base = base->clink;
			if(base == nil)
				break;
			ptr = B2NB(base);
			end = ptr;	/* could do better by copying between chains */
			limit = B2LIMIT(base);
			recov = 0;
		} else
			ptr = next;
.
393,397c
	for(i=0; i<table.n; i++){
		p = &table.pool[i];
		if(strcmp(name, p->name) == 0){
			if(maxsize)
				p->maxsize = maxsize;
			if(quanta)
				p->quanta = quanta;
			if(chunk)
				p->chunk = chunk;
			return;
		}
.
389,391c
void
poolsetparam(char *name, ulong maxsize, int quanta, int chunk)
{
	Pool *p;
	int i;
.
385,387c
	p->move = move;
}
.
383c
poolsetcompact(Pool *p, void (*move)(void*, void*))
.
380a
*/
.
372,379c
	while(base != nil) {
		print("\tbase #%.8lux ptr #%.8lux", base, ptr);
		if(ptr->magic == MAGIC_A)
			print("\tA%.5d\n", ptr->size);
		else if(ptr->magic == MAGIC_E)
			print("\tE\tL#%.8lux\tS#%.8lux\n", ptr->clink, ptr->csize);
		else
			print("\tF%.5d\tL#%.8lux\tR#%.8lux\tF#%.8lux\tP#%.8lux\tT#%.8lux\n",
				ptr->size, ptr->left, ptr->right, ptr->fwd, ptr->prev, ptr->parent);
		ptr = B2NB(ptr);
		if(ptr >= limit) {
			print("link to #%.8lux\n", base->clink);
			base = base->clink;
			if(base == nil)
				break;
			ptr = base;
			limit = B2LIMIT(base);
		}
	}
	return;
.
368,370c
	b = p->chain;
	if(b == nil)
		return;
	base = b;
	ptr = b;
	limit = B2LIMIT(b);
.
366c
	Bhdr *b, *base, *limit, *ptr;
.
364c
pooldump(Pool *p)
.
362a
/*
.
357,360c
	for(i = 0; i < table.n; i++)
		print("Arena: %s cursize=%d; maxsize=%d\n", table.pool[i].name, table.pool[i].cursize, table.pool[i].maxsize);
.
355c
	int i;
.
352,353c
void
poolsummary(void)
.
350a
*/
.
348,349d
334,346c
	if(b == nil)
		return;

	print("%.8lux %.8lux %.8lux %c %4d %d (f %.8lux p %.8lux)\n",
		b, b->left, b->right, c, d, b->size, b->fwd, b->prev);
	d++;
	for(t = b->fwd; t != b; t = t->fwd)
		print("\t%.8lux %.8lux %.8lux\n", t, t->prev, t->fwd);
	pooldump(b->left, d, 'l');
	pooldump(b->right, d, 'r');
}


void
poolshow(void)
{
	int i;

	for(i = 0; i < table.n; i++) {
		print("Arena: %s root=%.8lux\n", table.pool[i].name, table.pool[i].root);
		pooldump(table.pool[i].root, 0, 'R');
.
330,332c
	Bhdr *t;
.
327,328c
/*
void
pooldump(Bhdr *b, int d, int c)
.
324c
	return malloc(n*szelem);
.
322c
calloc(ulong n, ulong szelem)
.
318c
	D2B(b, v);
	return b->size - BHDRSIZE;
.
315,316c
int
msize(void *v)
{
	Bhdr *b;
.
313a
	return nv;
}
.
312c
	osize = b->size - BHDRSIZE;
	if(osize >= size)
		return v;

	nv = poolalloc(mainmem, size);
	if(nv != nil) {
		memmove(nv, v, osize);
		free(v);
.
295,310c
	D2B(b, v);
.
289,293c
	if(v == nil)
		return malloc(size);
.
285,287c
void*
realloc(void *v, ulong size)
{
	Bhdr *b;
	void *nv;
	int osize;
.
283c
}
.
279,281c
void
free(void *v)
{
	Bhdr *b;

	if(v != nil) {
		D2B(b, v);
		poolfree(mainmem, v);
.
277c
	v = poolalloc(mainmem, size);
	if(clr && v != nil)
		memset(v, 0, size);
	return v;
}
.
274,275c
void*
mallocz(ulong size, int clr)
{
	void *v;
.
267,272c
	for(;;) {
		v = poolalloc(mainmem, size);
		if(v != nil)
			break;
		tsleep(&up->sleep, return0, 0, 100);
	}
	memset(v, 0, size);
	return v;
}
.
264,265c
void*
smalloc(ulong size)
{
	void *v;
.
260,262c
	v = poolalloc(mainmem, size);
	if(v != nil)
		memset(v, 0, size);
	return v;
}
.
257,258c
	void *v;
.
255c
malloc(ulong size)
.
243,251c
	return n;
.
238,241d
227,236d
224,225c
			else
				n = 0;
.
209,222c
		if(signed_off > 0) {
			signed_off -= n;
			if(signed_off < 0) {
				memmove(va, va+n+signed_off, -signed_off);
				n = -signed_off;
.
206,207c
	n = 0;
	signed_off = offset;
	for(i = 0; i < table.n; i++) {
		p = &table.pool[i];
		n += snprint(va+n, count-n, "%11d %11d %11d %11d %11d %11d %s\n",
			p->cursize,
			p->maxsize,
			p->hw,
			p->nalloc,
			p->nfree,
			p->nbrk,
			p->name);
.
203,204c
	Pool *p;
	int n, i, signed_off;
.
200,201c
int
poolread(char *va, int count, ulong offset)
.
197c

	c = B2PT(b)->hdr;
	if(c->magic == MAGIC_F) {	/* Join backward */
		pooldel(p, c);
		b->magic = 0;
		c->size += b->size;
		b = c;
		B2T(b)->hdr = b;
	}

	pooladd(p, b);
	iunlock(&p->l);
.
192,195c
	D2B(b, v);

	ilock(&p->l);
	p->nfree++;
	p->cursize -= b->size;

	c = B2NB(b);
	if(c->magic == MAGIC_F) {	/* Join forward */
		pooldel(p, c);
		c->magic = 0;
		b->size += c->size;
		B2T(b)->hdr = b;
.
190c
	Bhdr *b, *c;
.
188c
poolfree(Pool *p, void *v)
.
183,184c

	t->magic = MAGIC_E;		/* Make a leader */
	t->size = ldr;
	t->csize = ns+ldr;
	t->clink = p->chain;
	p->chain = t;
	B2T(t)->hdr = t;
	t = B2NB(t);

	t->magic = MAGIC_A;		/* Make the block we are going to return */
	t->size = size;
	B2T(t)->hdr = t;
	q = t;

	ns -= size;			/* Free the rest */
	if(ns > 0) {
		q = B2NB(t);
		q->size = ns;
		B2T(q)->hdr = q;
		pooladd(p, q);
	}
	B2NB(q)->magic = MAGIC_E;	/* Mark the end of the chunk */

	p->cursize += t->size;
	if(p->cursize > p->hw)
		p->hw = p->cursize;
	iunlock(&p->l);
	return B2D(t);
.
161,181c
	p->nbrk++;
	t = xalloc(alloc);
	if(t == nil) {
		iunlock(&p->l);
		return nil;
.
158,159c
		iunlock(&p->l);
		print("arena too large: size %d cursize %d arenasize %d maxsize %d\n",
			 size, p->cursize, p->arenasize, p->maxsize);
		return nil;
	}
.
152,156c
		if(poolcompact(p)) {
			iunlock(&p->l);
			return poolalloc(p, size);
		}
.
149,150c
	alloc = ns+ldr+sizeof(t->magic);
	p->arenasize += alloc;
	if(p->arenasize > p->maxsize) {
		p->arenasize -= alloc;
.
146,147c
	ns = p->chunk;
	if(size > ns)
		ns = size;
	ldr = p->quanta+1;
.
143,144c
	if(q != nil) {
		pooldel(p, q);
		q->magic = MAGIC_A;
		frag = q->size - size;
		if(frag < (size>>2)) {
			p->cursize += q->size;
			if(p->cursize > p->hw)
				p->hw = p->cursize;
			iunlock(&p->l);
			return B2D(q);
		}
		/* Split */
		ns = q->size - size;
		q->size = size;
		B2T(q)->hdr = q;
		t = B2NB(q);
		t->size = ns;
		B2T(t)->hdr = t;
		pooladd(p, t);				
		p->cursize += q->size;
		if(p->cursize > p->hw)
			p->hw = p->cursize;
		iunlock(&p->l);
		return B2D(q);
	}
.
134,141c
	ilock(&p->l);
	p->nalloc++;

	t = p->root;
	q = nil;
	while(t) {
		if(t->size == size) {
			pooldel(p, t);
			t->magic = MAGIC_A;
			p->cursize += t->size;
			if(p->cursize > p->hw)
				p->hw = p->cursize;
			iunlock(&p->l);
			return B2D(t);
		}
		if(size < t->size) {
			q = t;
			t = t->left;
		}
		else
			t = t->right;
.
130,132c
	size = (size + BHDRSIZE + p->quanta) & ~(p->quanta);
.
128c
	Bhdr *q, *t;
	int alloc, ldr, ns, frag;
.
126c
poolalloc(Pool *p, int size)
.
122,124d
108,119c
	q->parent = tp;
	if(size < tp->size)
		tp->left = q;
	else
		tp->right = q;
.
104,106c
	tp = nil;
	while(t != nil) {
		if(size == t->size) {
			q->fwd = t->fwd;
			q->fwd->prev = q;
			q->prev = t;
			t->fwd = q;
			return;
		}
		tp = t;
		if(size < t->size)
			t = t->left;
		else
			t = t->right;
	}
.
98,102c
	size = q->size;
.
93,96c
	t = p->root;
	if(t == nil) {
		p->root = q;
		return;
	}
.
91c
	q->left = nil;
	q->right = nil;
	q->parent = nil;
	q->fwd = q;
	q->prev = q;
.
87,89c
	q->magic = MAGIC_F;
.
84,85c
	int size;
	Bhdr *tp, *t;
.
82c
pooladd(Pool *p, Bhdr *q)
.
80a
	if(t->left == nil)
		rp = t->right;
	else {
		if(t->right == nil) 
			rp = t->left;
		else {
			f = t;
			rp = t->right;
			s = rp->left;
			while(s != nil) {
				f = rp;
				rp = s;
				s = rp->left;
			}
			if(f != t) {
				s = rp->right;
				f->left = s;
				if(s != nil)
					s->parent = f;
				s = t->right;
				rp->right = s;
				if(s != nil)
					s->parent = rp;
			}
			s = t->left;
			rp->left = s;
			s->parent = rp;
		}
	}
	q = t->parent;
	if(q == nil)
		p->root = rp;
	else {
		if(t == q->left)
			q->left = rp;
		else
			q->right = rp;
	}
	if(rp != nil)
		rp->parent = q;
}

.
78,79c
	if(t->parent == nil && p->root != t) {
		t->prev->fwd = t->fwd;
		t->fwd->prev = t->prev;
		return;
	}
 
	if(t->fwd != t) {
		f = t->fwd;
		s = t->parent;
		f->parent = s;
		if(s == nil)
			p->root = f;
		else {
			if(s->left == t)
				s->left = f;
			else
				s->right = f;
		}
 
		rp = t->left;
		f->left = rp;
		if(rp != nil)
			rp->parent = f;
		rp = t->right;
		f->right = rp;
		if(rp != nil)
			rp->parent = f;
 
		t->prev->fwd = t->fwd;
		t->fwd->prev = t->prev;
		return;
	}
.
71,76c
	Bhdr *s, *f, *rp, *q;
.
69c
void
pooldel(Pool *p, Bhdr *t)
.
62,67c
	return p->chain;
}
.
60c
Bhdr*
poolchain(Pool *p)
.
52,58c
int	poolcompact(Pool*);
.
45,50c
Pool*	mainmem = &table.pool[0];
Pool*	imagmem = &table.pool[1];
.
39,42c
	int	n;
	Pool	pool[MAXPOOL];
	Lock	l;
} table = {
	2,
	{
		{ "Main",	 4*1024*1024, 31,  128*1024 },
		{ "Image",	 8*1024*1024, 31, 2*1024*1024 },
	}
.
31,37c
struct
.
23,28c
	char*	name;
	ulong	maxsize;
	int	quanta;
	int	chunk;
	ulong	cursize;
	ulong	arenasize;
	ulong	hw;
	Lock	l;
	Bhdr*	root;
	Bhdr*	chain;
	int	nalloc;
	int	nfree;
	int	nbrk;
	int	lastfree;
	void	(*move)(void*, void*);
.
9,21c
struct Pool
.
7a
#define left	u.s.bhl
#define right	u.s.bhr
#define fwd	u.s.bhf
#define prev	u.s.bhv
#define parent	u.s.bhp
.
3a
#include	"pool.h"
.
## diffname port/alloc.c 1997/1105
## diff -e /n/emeliedump/1997/1101/sys/src/brazil/port/alloc.c /n/emeliedump/1997/1105/sys/src/brazil/port/alloc.c
603a

int
recur(Bhdr *t)
{
	if(t == 0)
		return 1;
	if(((ulong)t) < 0x80000000)
		return 0;
	if(((ulong)t) > 0x90000000)
		return 0;
	return recur(t->right) && recur(t->left);
}

int
poolok(void)
{
	return recur(mainmem->root);
}
.
## diffname port/alloc.c 1997/1108
## diff -e /n/emeliedump/1997/1105/sys/src/brazil/port/alloc.c /n/emeliedump/1997/1108/sys/src/brazil/port/alloc.c
43c
		{ "Image",	 16*1024*1024, 31, 2*1024*1024 },
.
## diffname port/alloc.c 1997/1202
## diff -e /n/emeliedump/1997/1108/sys/src/brazil/port/alloc.c /n/emeliedump/1997/1202/sys/src/brazil/port/alloc.c
188a
	if(size < 0 || size >= 1024*1024*1024)	/* for sanity and to avoid overflow */
		return nil;
.
## diffname port/alloc.c 1997/1208
## diff -e /n/emeliedump/1997/1202/sys/src/brazil/port/alloc.c /n/emeliedump/1997/1208/sys/src/brazil/port/alloc.c
622c
	if(x & 1)
		return recur(mainmem->root);
	return recur(imagmem->root);
.
620c
poolok(int x)
.
## diffname port/alloc.c 1998/0128
## diff -e /n/emeliedump/1997/1208/sys/src/brazil/port/alloc.c /n/emeliedump/1998/0128/sys/src/brazil/port/alloc.c
257,258c
		print("%s arena too large: size %d cursize %d arenasize %d maxsize %d\n",
			 p->name, size, p->cursize, p->arenasize, p->maxsize);
.
## diffname port/alloc.c 1998/0221
## diff -e /n/emeliedump/1998/0128/sys/src/brazil/port/alloc.c /n/emeliedump/1998/0221/sys/src/brazil/port/alloc.c
618,625d
## diffname port/alloc.c 1998/0512
## diff -e /n/emeliedump/1998/0221/sys/src/brazil/port/alloc.c /n/emeliedump/1998/0512/sys/src/brazil/port/alloc.c
233c
		pooladd(p, t);
.
99c
		if(t->right == nil)
.
90c

.
81c

.
68c

.
## diffname port/alloc.c 1998/0825
## diff -e /n/emeliedump/1998/0512/sys/src/brazil/port/alloc.c /n/emeliedump/1998/0825/sys/src/brazil/port/alloc.c
487c
		print("Arena: %s cursize=%lud; maxsize=%lud\n",
			table.pool[i].name,
			table.pool[i].cursize,
			table.pool[i].maxsize);
.
340c
		n += snprint(va+n, count-n, "%11lud %11lud %11lud %11d %11d %11d %s\n",
.
257c
		print("%s arena too large: size %d cursize %lud arenasize %lud maxsize %lud\n",
.
## diffname port/alloc.c 1998/0916
## diff -e /n/emeliedump/1998/0825/sys/src/brazil/port/alloc.c /n/emeliedump/1998/0916/sys/src/brazil/port/alloc.c
489a
			table.pool[i].arenasize,
.
487c
		print("Arena: %s cursize=%lud; arenasize=%lud; maxsize=%lud\n",
.
## diffname port/alloc.c 1999/0125
## diff -e /n/emeliedump/1998/0916/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0125/sys/src/brazil/port/alloc.c
550a
			if(move != nil)
				p->move = move;
.
549c
			if(chunk != 0)
.
547c
			if(quanta != 0)
.
545c
			if(maxsize != 0)
.
533,538d
531c
poolsetparam(char *name, ulong maxsize, int quanta, int chunk, void (*move)(void*, void*))
.
## diffname port/alloc.c 1999/0209
## diff -e /n/emeliedump/1999/0125/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0209/sys/src/brazil/port/alloc.c
184c
poolalloc(Pool *p, long size)
.
## diffname port/alloc.c 1999/0211
## diff -e /n/emeliedump/1999/0209/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0211/sys/src/brazil/port/alloc.c
257c
		print("%s arena too large: size %ld cursize %lud arenasize %lud maxsize %lud\n",
.
## diffname port/alloc.c 1999/0501
## diff -e /n/emeliedump/1999/0211/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0501/sys/src/brazil/port/alloc.c
431a
{
Bhdr *h;
D2B(h, nv);
B2T(h)->pad = getcallerpc(&size);
}
.
396a
{
Bhdr *h;
D2B(h, v);
B2T(h)->pad = getcallerpc(&size);
}
.
385a
{
Bhdr *h;
D2B(h, v);
B2T(h)->pad = getcallerpc(&size);
}
.
370a
{
Bhdr *h;
D2B(h, v);
B2T(h)->pad = getcallerpc(&size);
}
.
## diffname port/alloc.c 1999/0511
## diff -e /n/emeliedump/1999/0501/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0511/sys/src/brazil/port/alloc.c
410a
		memset(v, 0, size);
.
406d
## diffname port/alloc.c 1999/0526
## diff -e /n/emeliedump/1999/0511/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0526/sys/src/brazil/port/alloc.c
410d
406c
		memset(v, 0, size);
if(v != nil){
.
371c
if(v != nil){
.
## diffname port/alloc.c 1999/0527
## diff -e /n/emeliedump/1999/0526/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0527/sys/src/brazil/port/alloc.c
636a
}

enum
{
	Hdrspc		= 64,		/* leave room for high-level headers */
	Bdead		= 0x51494F42,	/* "QIOB" */
};

struct
{
	Lock;
	ulong	bytes;
} ialloc;

/*
 *  allocate blocks, round the data base upt to a multiple of BLOCKALIGN.
 */
Block*
allocb(int size)
{
	Block *b;
	ulong addr;
	int n;

	n = sizeof(Block) + size;
	b = poolalloc(mainmem, n+Hdrspc);
	if(b == 0)
		exhausted("Blocks");
	memset(b, 0, sizeof(Block));

	/* align start of data portion by rounding up */
	addr = (ulong)b;
	addr = ROUND(addr + sizeof(Block), BLOCKALIGN);
	b->base = (uchar*)addr;

	/* align end of data portion by rounding down */
	b->lim = ((uchar*)b) + msize(b);
	addr = (ulong)(b->lim);
	addr = addr & ~(BLOCKALIGN-1);
	b->lim = (uchar*)addr;

	/* leave sluff at beginning for added headers */
	b->rp = b->lim - ROUND(size, BLOCKALIGN);
	if(b->rp < b->base)
		panic("allocb");
	b->wp = b->rp;
	tagwithpc(b, getcallerpc(&size));

	return b;
}

/*
 *  interrupt time allocation
 */
Block*
iallocb(int size)
{
	Block *b;
	ulong addr;
	int n;

	if(ialloc.bytes > conf.ialloc){
		print("iallocb: limited %lud/%lud\n",
			ialloc.bytes, conf.ialloc);
		return 0;
	}

	n = sizeof(Block) + size;
	b = poolalloc(mainmem, n+Hdrspc);
	if(b == 0){
		print("iallocb: no memory %lud/%lud\n",
			ialloc.bytes, conf.ialloc);
		return nil;
	}
	memset(b, 0, sizeof(Block));

	/* align start of data portion by rounding up */
	addr = (ulong)b;
	addr = ROUND(addr + sizeof(Block), BLOCKALIGN);
	b->base = (uchar*)addr;

	/* align end of data portion by rounding down */
	b->lim = ((uchar*)b) + msize(b);
	addr = (ulong)(b->lim);
	addr = addr & ~(BLOCKALIGN-1);
	b->lim = (uchar*)addr;

	/* leave sluff at beginning for added headers */
	b->rp = b->lim - ROUND(size, BLOCKALIGN);
	if(b->rp < b->base)
		panic("allocb");
	b->wp = b->rp;

	b->flag = BINTR;

	ilock(&ialloc);
	ialloc.bytes += b->lim - b->base;
	iunlock(&ialloc);
	tagwithpc(b, getcallerpc(&size));

	return b;
}

void
freeb(Block *b)
{
	void *dead = (void*)Bdead;

	if(b == nil)
		return;

	/*
	 * drivers which perform non cache coherent DMA manage their own buffer
	 * pool of uncached buffers and provide their own free routine.
	 */
	if(b->free) {
		b->free(b);
		return;
	}
	if(b->flag & BINTR) {
		ilock(&ialloc);
		ialloc.bytes -= b->lim - b->base;
		iunlock(&ialloc);
	}

	/* poison the block in case someone is still holding onto it */
	b->next = dead;
	b->rp = dead;
	b->wp = dead;
	b->lim = dead;
	b->base = dead;

	poolfree(mainmem, b);
}

void
checkb(Block *b, char *msg)
{
	void *dead = (void*)Bdead;

	if(b == dead)
		panic("checkb b %s %lux", msg, b);
	if(b->base == dead || b->lim == dead || b->next == dead
	  || b->rp == dead || b->wp == dead){
		print("checkb: base 0x%8.8luX lim 0x%8.8luX next 0x%8.8luX\n",
			b->base, b->lim, b->next);
		print("checkb: rp 0x%8.8luX wp 0x%8.8luX\n", b->rp, b->wp);
		panic("checkb dead: %s\n", msg);
	}

	if(b->base > b->lim)
		panic("checkb 0 %s %lux %lux", msg, b->base, b->lim);
	if(b->rp < b->base)
		panic("checkb 1 %s %lux %lux", msg, b->base, b->rp);
	if(b->wp < b->base)
		panic("checkb 2 %s %lux %lux", msg, b->base, b->wp);
	if(b->rp > b->lim)
		panic("checkb 3 %s %lux %lux", msg, b->rp, b->lim);
	if(b->wp > b->lim)
		panic("checkb 4 %s %lux %lux", msg, b->wp, b->lim);

}

void
iallocsummary(void)
{
	print("ialloc %lud/%lud\n", ialloc.bytes, conf.ialloc);
.
447,451c
	if(nv != nil)
		tagwithpc(nv, getcallerpc(&v));
.
423d
418,421c
	if(v != nil)
.
407,411c
	if(v != nil)
		tagwithpc(v, getcallerpc(&size));
.
391,395c
	tagwithpc(v, getcallerpc(&size));
.
371,375c
	if(v != nil)
		tagwithpc(v, getcallerpc(&size));
.
362a
static void
tagwithpc(void *v, ulong pc)
{
	Bhdr *h;

	D2B(h, v);
	B2T(h)->pad = pc;
}

.
## diffname port/alloc.c 1999/0603
## diff -e /n/emeliedump/1999/0527/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0603/sys/src/brazil/port/alloc.c
363c
void
.
## diffname port/alloc.c 1999/0710
## diff -e /n/emeliedump/1999/0603/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0710/sys/src/brazil/port/alloc.c
542,796d
540d
515,538c
	u = v;
	u[-2] = pc;
.
496,513c
	ulong *u;
	if(v == nil)
.
494c
tagwithpc(void *v, ulong pc)
.
491d
484,489c
	poolsummary(mainmem);
	poolsummary(imagmem);
.
482c
mallocsummary(void)
.
480d
466,477c
	print("%s max %lud cur %lud free %lud alloc %lud\n", p->name,
		p->maxsize, p->cursize, p->curfree, p->curalloc);
.
464c
poolsummary(Pool *p)
.
462d
459c
	return mallocz(n*szelem, 1);
.
450,453c
	return poolmsize(mainmem, (uchar*)v-8)-8;
.
447c
ulong
.
431,444c
	nv = (uchar*)v-8;
	nsize = size+8;
	if(l = poolrealloc(mainmem, nv, nsize))
		return l+2;
	return nil;
.
427a
	if(size == 0) {
		free(v);
		return nil;
	}
.
426c
	long nsize;
.
424c
	ulong *l;
.
417,418c
	if(v != nil) {
		poolfree(mainmem, (uchar*)v-8);
	}
.
409,410d
406c
	if(size == 0)
		return nil;

	v = poolalloc(mainmem, size+8);
	if(v != nil) {
		l = v;
		l[0] = getcallerpc(&size);
		v = l+2;
	}
.
404a
	ulong *l;
.
396,397d
385,394c
	v = poolalloc(mainmem, size+8);
	if(v != nil) {
		l = v;
		l[0] = getcallerpc(&size);
		v = l+2;
		memset(v, 0, size);
.
377,383c
	if(size == 0)
		return nil;
.
374a
	ulong *l;
.
298,371d
215,295c
	l = v;
	l[0] = getcallerpc(&size);
	v = l+2;
	memset(v, 0, size);
	return v;
.
189,213c
	for(;;) {
		v = poolalloc(mainmem, size+8);
		if(v != nil)
			break;
		tsleep(&up->sleep, return0, 0, 100);
.
186,187c
	void *v;
	ulong *l;
.
184c
smalloc(ulong size)
.
50,182d
47,48c
Pool*	mainmem = &pmainmem;
Pool*	imagmem = &pimagmem;
.
34,44c
static Pool pimagmem = {
	.name=	"Image",
	.maxsize=	16*1024*1024,
	.minarena=	2*1024*1024,
	.quantum=	32,
	.alloc=	xalloc,
	.merge=	xmerge,
	.flags=	0,
.
9,31c
static Pool pmainmem = {
	.name=	"Main",
	.maxsize=	4*1024*1024,
	.minarena=	128*1024,
	.quantum=	32,
	.alloc=	xalloc,
	.merge=	xmerge,
	.flags=	0,
.
7a
#include	"pool.h"
.
4d
## diffname port/alloc.c 1999/0711
## diff -e /n/emeliedump/1999/0710/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0711/sys/src/brazil/port/alloc.c
75,77d
57,59d
## diffname port/alloc.c 1999/0712
## diff -e /n/emeliedump/1999/0711/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0712/sys/src/brazil/port/alloc.c
145,146c
	base = b;
	ptr = b;
	limit = B2LIMIT(b);

	while(base != nil) {
		print("\tbase #%.8lux ptr #%.8lux", base, ptr);
		if(ptr->magic == MAGIC_A)
			print("\tA%.5d\n", ptr->size);
		else if(ptr->magic == MAGIC_E)
			print("\tE\tL#%.8lux\tS#%.8lux\n", ptr->clink, ptr->csize);
		else
			print("\tF%.5d\tL#%.8lux\tR#%.8lux\tF#%.8lux\tP#%.8lux\tT#%.8lux\n",
				ptr->size, ptr->left, ptr->right, ptr->fwd, ptr->prev, ptr->parent);
		ptr = B2NB(ptr);
		if(ptr >= limit) {
			print("link to #%.8lux\n", base->clink);
			base = base->clink;
			if(base == nil)
				break;
			ptr = base;
			limit = B2LIMIT(base);
		}
	}
	return;
}
*/

void
poolsetparam(char *name, ulong maxsize, int quanta, int chunk, void (*move)(void*, void*))
{
	Pool *p;
	int i;

	for(i=0; i<table.n; i++){
		p = &table.pool[i];
		if(strcmp(name, p->name) == 0){
			if(maxsize != 0)
				p->maxsize = maxsize;
			if(quanta != 0)
				p->quanta = quanta;
			if(chunk != 0)
				p->chunk = chunk;
			if(move != nil)
				p->move = move;
			return;
		}
	}
}

int
poolcompact(Pool *pool)
{
	Bhdr *base, *limit, *ptr, *end, *next;
	int compacted, recov, nb;

	if(pool->move == nil || pool->lastfree == pool->nfree)
		return 0;

	pool->lastfree = pool->nfree;

	base = pool->chain;
	ptr = B2NB(base);	/* First Block in arena has clink */
	limit = B2LIMIT(base);
	compacted = 0;

	pool->root = nil;
	end = ptr;
	recov = 0;
	while(base != nil) {
		next = B2NB(ptr);
		if(ptr->magic == MAGIC_A) {
			if(ptr != end) {
				memmove(end, ptr, ptr->size);
				pool->move(B2D(ptr), B2D(end));
				recov = (uchar*)ptr - (uchar*)end;
				compacted = 1;
			}
			end = B2NB(end);
		}
		if(next >= limit) {
			nb = (uchar*)limit - (uchar*)end;
			//print("recovered %d bytes\n", recov);
			//print("%d bytes at end\n", nb);
			USED(recov);
			if(nb > 0){
				if(nb < pool->quanta+1)
					panic("poolcompact: leftover too small\n");
				end->size = nb;
				pooladd(pool, end);
			}
			base = base->clink;
			if(base == nil)
				break;
			ptr = B2NB(base);
			end = ptr;	/* could do better by copying between chains */
			limit = B2LIMIT(base);
			recov = 0;
		} else
			ptr = next;
	}

	return compacted;
.
142,143c
	Bhdr *b, *base, *limit, *ptr;

	b = p->chain;
	if(b == nil)
.
140c
pooldump(Pool *p)
.
138a
/*
.
135,136c
	int i;

	for(i = 0; i < table.n; i++)
		print("Arena: %s cursize=%lud; arenasize=%lud; maxsize=%lud\n",
			table.pool[i].name,
			table.pool[i].cursize,
			table.pool[i].arenasize,
			table.pool[i].maxsize);
.
132a
poolshow(void)
{
	int i;

	for(i = 0; i < table.n; i++) {
		print("Arena: %s root=%.8lux\n", table.pool[i].name, table.pool[i].root);
		pooldump(table.pool[i].root, 0, 'R');
	}
}
*/

void
.
131a

.
128,129c
	Bhdr *t;

	if(b == nil)
		return;

	print("%.8lux %.8lux %.8lux %c %4d %d (f %.8lux p %.8lux)\n",
		b, b->left, b->right, c, d, b->size, b->fwd, b->prev);
	d++;
	for(t = b->fwd; t != b; t = t->fwd)
		print("\t%.8lux %.8lux %.8lux\n", t, t->prev, t->fwd);
	pooldump(b->left, d, 'l');
	pooldump(b->right, d, 'r');
.
126c
pooldump(Bhdr *b, int d, int c)
.
124a
/*
.
122c
	return malloc(n*szelem);
.
116c
	Bhdr *b;

	D2B(b, v);
	return b->size - BHDRSIZE;
.
106,110c
	D2B(b, v);

	osize = b->size - BHDRSIZE;
	if(osize >= size)
		return v;

	nv = poolalloc(mainmem, size);
	if(nv != nil) {
		memmove(nv, v, osize);
		free(v);
	}
	if(nv != nil)
		tagwithpc(nv, getcallerpc(&v));
	return nv;
.
99,102d
97c
	int osize;
.
95c
	Bhdr *b;
.
87,89c
	if(v != nil)
		poolfree(mainmem, v);
.
80a
	if(v != nil)
		tagwithpc(v, getcallerpc(&size));
.
73,78c
	v = poolalloc(mainmem, size);
.
71d
63a
	memset(v, 0, size);
	tagwithpc(v, getcallerpc(&size));
.
62a
	if(v != nil)
		tagwithpc(v, getcallerpc(&size));
	return v;
}

void*
smalloc(ulong size)
{
	void *v;

	for(;;) {
		v = poolalloc(mainmem, size);
		if(v != nil)
			break;
		tsleep(&up->sleep, return0, 0, 100);
.
57,61c
	v = poolalloc(mainmem, size);
	if(v != nil)
.
54d
50a
void
poolfree(Pool *p, void *v)
{
	Bhdr *b, *c;

	D2B(b, v);

	ilock(&p->l);
	p->nfree++;
	p->cursize -= b->size;

	c = B2NB(b);
	if(c->magic == MAGIC_F) {	/* Join forward */
		pooldel(p, c);
		c->magic = 0;
		b->size += c->size;
		B2T(b)->hdr = b;
	}

	c = B2PT(b)->hdr;
	if(c->magic == MAGIC_F) {	/* Join backward */
		pooldel(p, c);
		b->magic = 0;
		c->size += b->size;
		b = c;
		B2T(b)->hdr = b;
	}

	pooladd(p, b);
	iunlock(&p->l);
}

int
poolread(char *va, int count, ulong offset)
{
	Pool *p;
	int n, i, signed_off;

	n = 0;
	signed_off = offset;
	for(i = 0; i < table.n; i++) {
		p = &table.pool[i];
		n += snprint(va+n, count-n, "%11lud %11lud %11lud %11d %11d %11d %s\n",
			p->cursize,
			p->maxsize,
			p->hw,
			p->nalloc,
			p->nfree,
			p->nbrk,
			p->name);

		if(signed_off > 0) {
			signed_off -= n;
			if(signed_off < 0) {
				memmove(va, va+n+signed_off, -signed_off);
				n = -signed_off;
			}
			else
				n = 0;
		}

	}
	return n;
}

void
tagwithpc(void *v, ulong pc)
{
	Bhdr *h;

	D2B(h, v);
	B2T(h)->pad = pc;
}

.
44,48c
	if(q != nil) {
		pooldel(p, q);
		q->magic = MAGIC_A;
		frag = q->size - size;
		if(frag < (size>>2)) {
			p->cursize += q->size;
			if(p->cursize > p->hw)
				p->hw = p->cursize;
			iunlock(&p->l);
			return B2D(q);
		}
		/* Split */
		ns = q->size - size;
		q->size = size;
		B2T(q)->hdr = q;
		t = B2NB(q);
		t->size = ns;
		B2T(t)->hdr = t;
		pooladd(p, t);
		p->cursize += q->size;
		if(p->cursize > p->hw)
			p->hw = p->cursize;
		iunlock(&p->l);
		return B2D(q);
	}

	ns = p->chunk;
	if(size > ns)
		ns = size;
	ldr = p->quanta+1;

	alloc = ns+ldr+sizeof(t->magic);
	p->arenasize += alloc;
	if(p->arenasize > p->maxsize) {
		p->arenasize -= alloc;

		if(poolcompact(p)) {
			iunlock(&p->l);
			return poolalloc(p, size);
		}

		iunlock(&p->l);
		print("%s arena too large: size %ld cursize %lud arenasize %lud maxsize %lud\n",
			 p->name, size, p->cursize, p->arenasize, p->maxsize);
		return nil;
	}

	p->nbrk++;
	t = xalloc(alloc);
	if(t == nil) {
		iunlock(&p->l);
		return nil;
	}

	t->magic = MAGIC_E;		/* Make a leader */
	t->size = ldr;
	t->csize = ns+ldr;
	t->clink = p->chain;
	p->chain = t;
	B2T(t)->hdr = t;
	t = B2NB(t);

	t->magic = MAGIC_A;		/* Make the block we are going to return */
	t->size = size;
	B2T(t)->hdr = t;
	q = t;

	ns -= size;			/* Free the rest */
	if(ns > 0) {
		q = B2NB(t);
		q->size = ns;
		B2T(q)->hdr = q;
		pooladd(p, q);
	}
	B2NB(q)->magic = MAGIC_E;	/* Mark the end of the chunk */

	p->cursize += t->size;
	if(p->cursize > p->hw)
		p->hw = p->cursize;
	iunlock(&p->l);
	return B2D(t);
.
38,42c
	if(size < 0 || size >= 1024*1024*1024)	/* for sanity and to avoid overflow */
		return nil;
	size = (size + BHDRSIZE + p->quanta) & ~(p->quanta);

	ilock(&p->l);
	p->nalloc++;

	t = p->root;
	q = nil;
	while(t) {
		if(t->size == size) {
			pooldel(p, t);
			t->magic = MAGIC_A;
			p->cursize += t->size;
			if(p->cursize > p->hw)
				p->hw = p->cursize;
			iunlock(&p->l);
			return B2D(t);
		}
		if(size < t->size) {
			q = t;
			t = t->left;
		}
		else
			t = t->right;
.
35,36c
	Bhdr *q, *t;
	int alloc, ldr, ns, frag;
.
33c
poolalloc(Pool *p, long size)
.
31a
int	poolcompact(Pool*);

Bhdr*
poolchain(Pool *p)
{
	return p->chain;
}

void
pooldel(Pool *p, Bhdr *t)
{
	Bhdr *s, *f, *rp, *q;

	if(t->parent == nil && p->root != t) {
		t->prev->fwd = t->fwd;
		t->fwd->prev = t->prev;
		return;
	}

	if(t->fwd != t) {
		f = t->fwd;
		s = t->parent;
		f->parent = s;
		if(s == nil)
			p->root = f;
		else {
			if(s->left == t)
				s->left = f;
			else
				s->right = f;
		}

		rp = t->left;
		f->left = rp;
		if(rp != nil)
			rp->parent = f;
		rp = t->right;
		f->right = rp;
		if(rp != nil)
			rp->parent = f;

		t->prev->fwd = t->fwd;
		t->fwd->prev = t->prev;
		return;
	}

	if(t->left == nil)
		rp = t->right;
	else {
		if(t->right == nil)
			rp = t->left;
		else {
			f = t;
			rp = t->right;
			s = rp->left;
			while(s != nil) {
				f = rp;
				rp = s;
				s = rp->left;
			}
			if(f != t) {
				s = rp->right;
				f->left = s;
				if(s != nil)
					s->parent = f;
				s = t->right;
				rp->right = s;
				if(s != nil)
					s->parent = rp;
			}
			s = t->left;
			rp->left = s;
			s->parent = rp;
		}
	}
	q = t->parent;
	if(q == nil)
		p->root = rp;
	else {
		if(t == q->left)
			q->left = rp;
		else
			q->right = rp;
	}
	if(rp != nil)
		rp->parent = q;
}

void
pooladd(Pool *p, Bhdr *q)
{
	int size;
	Bhdr *tp, *t;

	q->magic = MAGIC_F;

	q->left = nil;
	q->right = nil;
	q->parent = nil;
	q->fwd = q;
	q->prev = q;

	t = p->root;
	if(t == nil) {
		p->root = q;
		return;
	}

	size = q->size;

	tp = nil;
	while(t != nil) {
		if(size == t->size) {
			q->fwd = t->fwd;
			q->fwd->prev = q;
			q->prev = t;
			t->fwd = q;
			return;
		}
		tp = t;
		if(size < t->size)
			t = t->left;
		else
			t = t->right;
	}

	q->parent = tp;
	if(size < tp->size)
		tp->left = q;
	else
		tp->right = q;
}

.
29,30c
Pool*	mainmem = &table.pool[0];
Pool*	imagmem = &table.pool[1];
.
19,26c
struct
{
	int	n;
	Pool	pool[MAXPOOL];
	Lock	l;
} table = {
	2,
	{
		{ "Main",	 4*1024*1024, 31,  128*1024 },
		{ "Image",	 16*1024*1024, 31, 2*1024*1024 },
	}
.
9,16c
#define left	u.s.bhl
#define right	u.s.bhr
#define fwd	u.s.bhf
#define prev	u.s.bhv
#define parent	u.s.bhp

struct Pool
{
	char*	name;
	ulong	maxsize;
	int	quanta;
	int	chunk;
	ulong	cursize;
	ulong	arenasize;
	ulong	hw;
	Lock	l;
	Bhdr*	root;
	Bhdr*	chain;
	int	nalloc;
	int	nfree;
	int	nbrk;
	int	lastfree;
	void	(*move)(void*, void*);
.
7d
3a
#include	"pool.h"
.
## diffname port/alloc.c 1999/0713
## diff -e /n/emeliedump/1999/0712/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0713/sys/src/brazil/port/alloc.c
515,616c
	u = v;
	u[-2] = pc;
.
510,513c
	ulong *u;
	if(v == nil)
.
508c
tagwithpc(void *v, ulong pc)
.
506d
496,503c
	poolsummary(mainmem);
	poolsummary(imagmem);
.
482,493d
480d
466,477c
	print("%s max %lud cur %lud free %lud alloc %lud\n", p->name,
		p->maxsize, p->cursize, p->curfree, p->curalloc);
.
464c
poolsummary(Pool *p)
.
462d
459c
	return mallocz(n*szelem, 1);
.
450,453c
	return poolmsize(mainmem, (uchar*)v-8)-8;
.
431,444c
	nv = (uchar*)v-8;
	nsize = size+8;
	if(l = poolrealloc(mainmem, nv, nsize))
		return l+2;
	return nil;
.
427a
	if(size == 0) {
		free(v);
		return nil;
	}
.
426c
	long nsize;
.
424c
	ulong *l;
.
417,418c
	if(v != nil) {
if(0)		if(mainmem->flags & POOL_STUPID) {
			print("A");
			delay(50);
		}
		poolfree(mainmem, (uchar*)v-8);
if(0)		if(mainmem->flags & POOL_STUPID) {
			print("a");
			delay(50);
		}
	}
.
409,410d
406c
	v = poolalloc(mainmem, size+8);
	if(v != nil) {
		l = v;
		l[0] = getcallerpc(&size);
		v = l+2;
	}
.
404a
	ulong *l;
.
396,397d
380,394d
377,378c
	v = poolalloc(mainmem, size+8);
	if(v != nil) {
		l = v;
		l[0] = getcallerpc(&size);
		v = l+2;
.
374a
	ulong *l;
.
298,371d
215,295c
	l = v;
	l[0] = getcallerpc(&size);
	v = l+2;
	memset(v, 0, size);
	return v;
.
189,213c
	for(;;) {
		v = poolalloc(mainmem, size+8);
		if(v != nil)
			break;
		tsleep(&up->sleep, return0, 0, 100);
.
186,187c
	void *v;
	ulong *l;
.
184c
smalloc(ulong size)
.
50,182d
47,48c
Pool*	mainmem = &pmainmem;
Pool*	imagmem = &pimagmem;
.
34,44c
static Pool pimagmem = {
	.name=	"Image",
	.maxsize=	16*1024*1024,
	.minarena=	2*1024*1024,
	.quantum=	32,
	.alloc=	xalloc,
	.merge=	xmerge,
	.flags=	0,
.
15,31c
static Pool pmainmem = {
	.name=	"Main",
	.maxsize=	4*1024*1024,
	.minarena=	128*1024,
	.quantum=	32,
	.alloc=	xalloc,
	.merge=	xmerge,
	.flags=	0,
.
9,13c
enum {
	POOL_STUPID = 0x80000000,
};
.
7a
#include	"pool.h"
.
4d
## diffname port/alloc.c 1999/0714
## diff -e /n/emeliedump/1999/0713/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0714/sys/src/brazil/port/alloc.c
160a
ulong
getmalloctag(void *v)
{
	USED(v);
	if(Npadlong <= MallocOffset)
		return ~0;
	return ((ulong*)v)[-Npadlong+MallocOffset];
}

ulong
getrealloctag(void *v)
{
	USED(v);
	if(Npadlong <= ReallocOffset)
		return ((ulong*)v)[-Npadlong+ReallocOffset];
	return ~0;
}
.
158c
	u[-Npadlong+ReallocOffset] = pc;
.
155c
	USED(v, pc);
	if(Npadlong <= ReallocOffset || v == nil)
.
147,153d
145c
setrealloctag(void *v, ulong pc)
.
140,141c
	ulong *u;
	USED(v, pc);
	if(Npadlong <= MallocOffset || v == nil)
		return;
	u = v;
	u[-Npadlong+MallocOffset] = pc;
.
138c
setmalloctag(void *v, ulong pc)
.
134c
	void *v;
	if(v = mallocz(n*szelem, 1))
		setmalloctag(v, getcallerpc(&n));
	return v;
.
128c
	return poolmsize(mainmem, (ulong*)v-Npadlong)-Npadlong*sizeof(ulong);
.
118,122c
	if(nv = poolrealloc(mainmem, v, size)){
		nv = (ulong*)nv+Npadlong;
		setrealloctag(nv, getcallerpc(&v));
		if(v == nil)
			setmalloctag(nv, getcallerpc(&v));
	}		
	return nv;
.
111,116c
	if(v != nil)
		v = (ulong*)v-Npadlong;
	if(Npadlong !=0 && size != 0)
		size += Npadlong*sizeof(ulong);
.
109d
107d
91,101c
	if(v != nil)
		poolfree(mainmem, (ulong*)v-Npadlong);
.
77,81c
	v = poolalloc(mainmem, size+Npadlong*sizeof(ulong));
	if(Npadlong && v != nil){
		v = (ulong*)v+Npadlong;
		setmalloctag(v, getcallerpc(&size));
		setrealloctag(v, 0);
.
75d
61,65c
	v = poolalloc(mainmem, size+Npadlong*sizeof(ulong));
	if(Npadlong && v != nil) {
		v = (ulong*)v+Npadlong;
		setmalloctag(v, getcallerpc(&size));
		setrealloctag(v, 0);
.
58d
48,50c
	if(Npadlong){
		v = (ulong*)v+Npadlong;
		setmalloctag(v, getcallerpc(&size));
	}
.
43c
		v = poolalloc(mainmem, size+Npadlong*sizeof(ulong));
.
40d
35a
/*
 * because we can't print while we're holding the locks, 
 * we have the save the message and print it once we let go.
 */
static void
poolprint(Pool *p, char *fmt, ...)
{
	va_list v;
	int n;

	va_start(v, fmt);
	n = doprint(p->msg, p->msg+sizeof p->msg, fmt, v)-p->msg;
	va_end(v);
	if(n >= sizeof p->msg);
		n = sizeof(p->msg)-1;
	if(n < 0)
		n = 0;
	p->msg[n] = 0;
}

static void
ppanic(Pool *p, char *fmt, ...)
{
	va_list v;
	int n;

	va_start(v, fmt);
	n = doprint(p->msg, p->msg+sizeof p->msg, fmt, v)-p->msg;
	va_end(v);
	if(n >= sizeof p->msg);
		n = sizeof(p->msg)-1;
	if(n < 0)
		n = 0;
	p->msg[n] = 0;
	iunlock(&p->lk);
	panic("%s", p->msg);
}

static void
plock(Pool *p)
{
	ilock(&p->lk);
	p->msg[0] = 0;
}

static void
punlock(Pool *p)
{
	char msg[sizeof p->msg];

	if(p->msg[0] == 0){
		iunlock(&p->lk);
		return;
	}

	memmove(msg, p->msg, sizeof msg);
	iunlock(&p->lk);
	print("%.*s", sizeof p->msg, msg);
}

void
poolsummary(Pool *p)
{
	print("%s max %lud cur %lud free %lud alloc %lud\n", p->name,
		p->maxsize, p->cursize, p->curfree, p->curalloc);
}

void
mallocsummary(void)
{
	poolsummary(mainmem);
	poolsummary(imagmem);
}

/* everything from here down should be the same in libc, libdebugmalloc, and the kernel */
/* - except the code for malloc(), which alternately doesn't clear or does. */
/* - except the code for smalloc(), which lives only in the kernel. */

/*
 * Npadlong is the number of 32-bit longs to leave at the beginning of 
 * each allocated buffer for our own bookkeeping.  We return to the callers
 * a pointer that points immediately after our bookkeeping area.  Incoming pointers
 * must be decremented by that much, and outgoing pointers incremented.
 * The malloc tag is stored at MallocOffset from the beginning of the block,
 * and the realloc tag at ReallocOffset.  The offsets are from the true beginning
 * of the block, not the beginning the caller sees.
 *
 * The extra if(Npadlong != 0) in various places is a hint for the compiler to
 * compile out function calls that would otherwise be no-ops.
 */

/*	non tracing
 *
enum {
	Npadlong	= 0,
	MallocOffset = 0,
	ReallocOffset = 0,
};
 *
 */

/* tracing */
enum {
	Npadlong	= 2,
	MallocOffset = 0,
	ReallocOffset = 1
};


.
30a

	.lock=	plock,
	.unlock=	punlock,
	.print=	poolprint,
	.panic=	ppanic,
.
20c
	.flags=	POOL_TOLERANCE,

	.lock=	plock,
	.unlock=	punlock,
	.print=	poolprint,
	.panic=	ppanic,
.
9,11c
static void poolprint(Pool*, char*, ...);
static void ppanic(Pool*, char*, ...);
static void plock(Pool*);
static void punlock(Pool*);
.
## diffname port/alloc.c 1999/0825
## diff -e /n/emeliedump/1999/0714/sys/src/brazil/port/alloc.c /n/emeliedump/1999/0825/sys/src/brazil/port/alloc.c
102,104c
	memmove(msg, pv->msg, sizeof msg);
	iunlock(&pv->lk);
	print("%.*s", sizeof pv->msg, msg);
.
97,98c
	pv = p->private;
	if(pv->msg[0] == 0){
		iunlock(&pv->lk);
.
95c
	Private *pv;
	char msg[sizeof pv->msg];
.
88,89c
	Private *pv;

	pv = p->private;
	ilock(&pv->lk);
	pv->msg[0] = 0;
.
80,82c
	pv->msg[n] = 0;
	iunlock(&pv->lk);
	panic("%s", pv->msg);
.
76,77c
	if(n >= sizeof pv->msg);
		n = sizeof(pv->msg)-1;
.
74c
	n = doprint(pv->msg, pv->msg+sizeof pv->msg, fmt, v)-pv->msg;
.
72a
	pv = p->private;
.
71a
	Private *pv;
.
64c
	pv->msg[n] = 0;
.
60,61c
	if(n >= sizeof pv->msg);
		n = sizeof(pv->msg)-1;
.
58c
	n = doprint(pv->msg, pv->msg+sizeof pv->msg, fmt, v)-pv->msg;
.
56a
	pv = p->private;
.
55a
	Private *pv;
.
41a

	.private=	&pimagpriv,
.
28a
static Private pimagpriv;
.
26a

	.private=	&pmainpriv,
.
13a
typedef struct Private	Private;
struct Private {
	Lock		lk;
	char		msg[128];	/* a rock for messages to be printed at unlock */
};

static Private pmainpriv;
.
7c
#include	<pool.h>
.
## diffname port/alloc.c 2000/0120
## diff -e /n/emeliedump/1999/0825/sys/src/brazil/port/alloc.c /n/emeliedump/2000/0120/sys/src/9/port/alloc.c
98c
	panic("%s", msg);
.
92,96c
	memmove(msg, pv->msg, sizeof msg);
.
90c
	doprint(pv->msg+strlen(pv->msg), pv->msg+sizeof pv->msg, fmt, v);
.
86a
	char msg[sizeof pv->msg];
.
74,78d
72c
	doprint(pv->msg+strlen(pv->msg), pv->msg+sizeof pv->msg, fmt, v);
.
17c
	char		msg[256];	/* a rock for messages to be printed at unlock */
.
## diffname port/alloc.c 2000/0229
## diff -e /n/emeliedump/2000/0120/sys/src/9/port/alloc.c /n/emeliedump/2000/0229/sys/src/9/port/alloc.c
67d
## diffname port/alloc.c 2000/0407
## diff -e /n/emeliedump/2000/0229/sys/src/9/port/alloc.c /n/emeliedump/2000/0407/sys/src/9/port/alloc.c
79d
## diffname port/alloc.c 2002/0217
## diff -e /n/emeliedump/2000/0407/sys/src/9/port/alloc.c /n/emeliedump/2002/0217/sys/src/9/port/alloc.c
84c
	vseprint(pv->msg+strlen(pv->msg), pv->msg+sizeof pv->msg, fmt, v);
.
71c
	vseprint(pv->msg+strlen(pv->msg), pv->msg+sizeof pv->msg, fmt, v);
.
## diffname port/alloc.c 2002/0425
## diff -e /n/emeliedump/2002/0217/sys/src/9/port/alloc.c /n/emeliedump/2002/0425/sys/src/9/port/alloc.c
197a
	memset(v, 0, size);
.
196d
192c
	if(v == nil)
		return nil;
	if(Npadlong){
.