9os

commit 5b24ca7903d9387f6c01276fbc14eb8f61b97c97
parent 60a5454e05ad7a1e079858d8e3f1ff0a83fd4490
Author: Roberto E. Vargas Caballero <roberto.vargas@midokura.com>
Date:   Sat, 19 Nov 2022 09:38:55 +0100

os9: Separate allocation from management

There were several functions called new* that were allocating
data structures and they were also doing some additional work.
This separation makes the code clearer and hides the allocation
mechanism in parts of the code that should be independent.

Diffstat:
M
include/os9/os9.h
 | 
6
++++++
M
src/os9/alloc.c
 | 
97
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M
src/os9/proc.c
 | 
99
+++++++++++++++++++++++--------------------------------------------------------

3 files changed, 131 insertions(+), 71 deletions(-)
diff --git a/include/os9/os9.h b/include/os9/os9.h
@@ -267,8 +267,14 @@ extern void unlocktask(Task *);
 extern void *alloc(size_t);
 extern void *allocb(void);
 extern Page *allocp(phyaddr_t);
+extern Nspace *allocspace(void);
+extern Map *allocmap(void);
+extern Fdset *allocfds(void);
 extern void freeb(void *);
 extern void freep(Page *);
+extern void freespace(Nspace *);
+extern void freemap(Map *);
+extern void freefds(Fdset *);
 extern void ialloc(void);
 
 /* sys.c */
diff --git a/src/os9/alloc.c b/src/os9/alloc.c
@@ -21,9 +21,27 @@ struct pagepool {
 	mutex_t m;
 };
 
+struct nspool {
+        Nspace *list;
+        mutex_t m;
+};
+
+struct fdspool {
+        Fdset *list;
+        mutex_t m;
+};
+
+struct mappool {
+        Map *list;
+        mutex_t m;
+};
+
 static union bucket *heap;
 static struct bufpool bufpool;
 static struct pagepool pagepool;
+static struct nspool nspool;
+static struct mappool mappool;
+static struct fdspool fdspool;
 
 void
 freeb(void *bp)
@@ -85,6 +103,85 @@ alloc(size_t size)
 	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);
+}
+
+void
+freefds(Fdset *fds)
+{
+	lock(&fdspool.m);
+	fds->next = fdspool.list;
+	fdspool.list = fds;
+	unlock(&fdspool.m);
+}
+
 /*
  * This functions is always called with the page pool locked
  */
diff --git a/src/os9/proc.c b/src/os9/proc.c
@@ -7,21 +7,6 @@
 
 static Task tasktab[NR_TASKS];
 
-static struct {
-	Nspace *list;
-	mutex_t m;
-} nspool;
-
-static struct {
-	Fdset *list;
-	mutex_t m;
-} fdspool;
-
-static struct {
-	Map *list;
-	mutex_t m;
-} mappool;
-
 /* per cpu globals */
 Task *proc;
 long long now;
@@ -283,15 +268,8 @@ newspace(Nspace *from)
 {
 	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);
+	if ((ns = allocspace()) == NULL)
+		return NULL;
 
 	*ns = (from) ? *from : (Nspace) {0};
 	initref(&ns->ref);
@@ -304,15 +282,8 @@ newfds(Fdset *from)
 {
 	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);
+	if ((fds = allocfds()) == NULL)
+		return NULL;
 
 	*fds = (from) ? *from : (Fdset) {0};
 	initref(&fds->ref);
@@ -325,15 +296,8 @@ newmap(Map *from)
 {
 	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);
+	if ((mp = allocmap()) == NULL)
+		return NULL;
 
 	*mp = *from;
 	initref(&mp->ref);
@@ -343,32 +307,28 @@ newmap(Map *from)
 }
 
 static void
-freespace(Nspace *ns)
+delspace(Nspace *ns)
 {
-	lock(&nspool.m);
-	ns->next = nspool.list;
-	nspool.list = ns;
-	unlock(&nspool.m);
+	if (!decref(&ns->ref))
+		return;
+	freespace(ns);
 }
 
 static void
-freefds(Fdset *fds)
+delfds(Fdset *fds)
 {
-	lock(&fdspool.m);
-	fds->next = fdspool.list;
-	fdspool.list = fds;
-	unlock(&fdspool.m);
+	if (!decref(&fds->ref))
+		return;
+	freefds(fds);
 }
 
 static void
-freemap(Map *mp)
+delmap(Map *mp)
 {
+	if (!decref(&mp->ref))
+		return;
 	unmapseg(mp);
-
-	lock(&mappool.m);
-	mp->next = mappool.list;
-	mappool.list = mp;
-	unlock(&mappool.m);
+	freemap(mp);
 }
 
 /*
@@ -377,10 +337,10 @@ freemap(Map *mp)
 static void
 deltask(Task *tp)
 {
-	freemap(tp->text);
-	freemap(tp->data);
-	freespace(tp->ns);
-	freefds(tp->fds);
+	delmap(tp->text);
+	delmap(tp->data);
+	delspace(tp->ns);
+	delfds(tp->fds);
 	unlocktask(tp);
 }
 
@@ -493,18 +453,15 @@ rfork(int flags)
 	}
 
 	if (tp->ns != ns) {
-		if (decref(&tp->ns->ref))
-			freespace(tp->ns);
+		delspace(tp->ns);
 		tp->ns = ns;
 	}
 	if (tp->fds != fds) {
-		if (decref(&tp->fds->ref))
-			freefds(tp->fds);
+		delfds(tp->fds);
 		tp->fds = fds;
 	}
 	if (tp->data != data) {
-		if (decref(&tp->data->ref))
-			freemap(tp->data);
+		delmap(tp->data);
 		tp->data = data;
 	}
 
@@ -516,11 +473,11 @@ rfork(int flags)
 
 err:
 	if (data)
-		freemap(data);
+		delmap(data);
 	if (fds)
-		freefds(fds);
+		delfds(fds);
 	if (ns)
-		freespace(ns);
+		delspace(ns);
 
 	if (flags & RFPROC)
 		deltask(tp);