9os

alloc.c (4321B)

---

 #include <os9/os9.h>
 
 #include <libk.h>
 
 #include <errno.h>
 #include <string.h>
 
 union bucket {
 	long long ll;
 	uintptr_t up;
 	union bucket *next;
 };
 
 struct pool {
 	void *list;
 	mutex_t m;
 };
 
 static union bucket *heap;
 static struct pool bufpool;
 static struct pool pagepool;
 static struct pool nspool;
 static struct pool mappool;
 static struct pool fdspool;
 static struct pool chanpool;
 static struct pool mpointpool;
 
 void
 freeb(void *bp)
 {
 	union bucket *p = bp;
 
 	if (!p)
 		return;
 
 	lock(&bufpool.m);
 	p->next = bufpool.list;
 	bufpool.list = p;
 	unlock(&bufpool.m);
 }
 
 void *
 allocb(void)
 {
 	union bucket *bp = NULL;
 
 	lock(&bufpool.m);
 	if (!bufpool.list) {
 		seterror(ENOMEM);
 	} else {
 		bp = bufpool.list;
 		bufpool.list = bp->next;
 	}
 	unlock(&bufpool.m);
 
 	return bp;
 }
 
 void *
 alloc(size_t size)
 {
 	size_t n;
 	static size_t used;
 	static mutex_t m;
 	void  *bp;
 
 	if (size == 0) {
 		seterror(EINVAL);
 		return NULL;
 	}
 
 	lock(&m);
 	n = (size-1) / sizeof(union bucket) + 1;
 	size = n * sizeof(union bucket);
 
 	if (used > PAGESIZE*HEAPSIZ - size) {
 		bp = NULL;
 		seterror(ENOMEM);
 	} else {
 		bp = (char *) heap + used;
 		used += size;
 	}
 	unlock(&m);
 
 	return bp;
 }
 
 Nspace *
 allocspace(void)
 {
 	Nspace *ns;
 
 	lock(&nspool.m);
 	if (nspool.list) {
 		ns = nspool.list;
 		nspool.list = ns->next;
 	} else {
 		if ((ns = alloc(sizeof(*ns))) == NULL)
 			return NULL;
 	}
 	unlock(&nspool.m);
 
 	return ns;
 }
 
 void
 freespace(Nspace *ns)
 {
 	lock(&nspool.m);
 	ns->next = nspool.list;
 	nspool.list = ns;
 	unlock(&nspool.m);
 }
 
 Map *
 allocmap(void)
 {
 	Map *mp;
 
 	lock(&mappool.m);
 	if (mappool.list) {
 		mp = mappool.list;
 		mappool.list = mp->next;
 	} else {
 		if ((mp = alloc(sizeof(*mp))) == NULL)
 			return NULL;
 	}
 	unlock(&mappool.m);
 
 	return mp;
 }
 
 void
 freemap(Map *mp)
 {
         lock(&mappool.m);
         mp->next = mappool.list;
         mappool.list = mp;
         unlock(&mappool.m);
 }
 
 Fdset *
 allocfds(void)
 {
 	Fdset *fds;
 
 	lock(&fdspool.m);
 	if (fdspool.list) {
 		fds = fdspool.list;
 		fdspool.list = fds->next;
 	} else {
 		if ((fds = alloc(sizeof(*fds))) == NULL)
 			return NULL;
 	}
 	unlock(&fdspool.m);
 
 	return fds;
 }
 
 void
 freefds(Fdset *fds)
 {
 	if (!fds)
 		return;
 
 	lock(&fdspool.m);
 	fds->next = fdspool.list;
 	fdspool.list = fds;
 	unlock(&fdspool.m);
 }
 
 /*
  * This functions is always called with the page pool locked
  */
 static int
 morepages(void)
 {
 	Page *p, *bp;
 
 	if (pagepool.list)
 		return 1;
 
 	if ((bp = allocb()) == NULL)
 		return 0;
 
 	for (p = bp; p < &bp[PAGESIZE/sizeof(Page)]; ++p)
 		p->next = p+1;
 	p->next = NULL;
 
 	pagepool.list = bp;
 
 	return 1;
 }
 
 Page *
 allocp(phyaddr_t pa)
 {
 	int alloc = 0;
 	void *bp = NULL;
 	Page *p;
 
 	if (pa == -1) {
 		if ((bp = allocb()) == NULL)
 			return NULL;
 		pa = (phyaddr_t) PMEM(bp);
 		alloc = 1;
 	}
 
 	lock(&pagepool.m);
 
 	if (!morepages()) {
 		freeb(bp);
 		unlock(&pagepool.m);
 		return NULL;
 	}
 
 	p = pagepool.list;
 	pagepool.list = p->next;
 
 	unlock(&pagepool.m);
 
 	p->pa = pa;
 	p->va = -1;
 	p->allocated = alloc;
 	p->next = NULL;
 
 	return p;
 }
 
 void
 freep(Page *p)
 {
 	if (!p)
 		return;
 
 	if (p->allocated)
 		freeb(VMEM(p->pa));
 
 	lock(&pagepool.m);
 	p->next = pagepool.list;
 	pagepool.list = p;
 	unlock(&pagepool.m);
 }
 
 Chan *
 allocchan(void)
 {
 	Chan *c;
 
 	lock(&chanpool.m);
 	if (chanpool.list) {
 		c = chanpool.list;
 		chanpool.list = c->next;
 	} else {
 		if ((c = alloc(sizeof(*c))) == NULL)
 			return NULL;
 	}
 	unlock(&chanpool.m);
 
 	return c;
 }
 
 void
 freechan(Chan *c)
 {
 	if (!c)
 		return;
 
 	lock(&chanpool.m);
 	c->next = chanpool.list;
 	chanpool.list = c;
 	unlock(&chanpool.m);
 }
 
 Mpoint *
 allocmpoint(void)
 {
 	Mpoint *mp;
 
 	lock(&mpointpool.m);
 	if (mpointpool.list) {
 		mp = mpointpool.list;
 		mpointpool.list = mp->next;
 	} else {
 		if ((mp = alloc(sizeof(*mp))) == NULL)
 			return NULL;
 	}
 	unlock(&mpointpool.m);
 
 	return mp;
 }
 
 void
 freempoint(Mpoint *mp)
 {
 	if (!mp)
 		return;
 
 	lock(&mpointpool.m);
 	mp->next = mpointpool.list;
 	mpointpool.list = mp;
 	unlock(&mpointpool.m);
 }
 
 void
 ialloc(void)
 {
 	int i;
 	union bucket *bp, *prev;
 
 	heap = (union bucket *) buffertab;
 
 	prev = NULL;
 	for (i = HEAPSIZ; i < NR_BUFFERS; i++) {
 		bp = (union bucket *) buffertab[i];
 		bp->next = prev;
 		prev = bp;
 	}
 	bufpool.list = bp;
 
 	kprint("%d available buffers: %d heap, %d buffer pool\n",
 	       NR_BUFFERS, HEAPSIZ, NR_BUFFERS - HEAPSIZ);
 }