Steps towards better status/debugging control

6 files changed, 43 insertions, 32 deletions

diff --git a/common/dmem.c b/common/dmem.c
index 0cc96e1..1c49a83 100644
--- a/common/dmem.c
+++ b/common/dmem.c
@@ -26,27 +26,27 @@ stat_t init_devmem(pm_t ram_base, pm_t ram_top)
 	return OK;
 }
 
-stat_t dev_alloc_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, uint8_t flags, enum mm_order order)
+stat_t dev_alloc_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order)
 {
-	map_vmem(b, *offset, vaddr, flags, order);
+	map_vpage(b, *offset, vaddr, flags, order);
 	*offset += __o_size(order);
 	return 0;
 }
 
-stat_t dev_free_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, uint8_t flags, enum mm_order order)
+stat_t dev_free_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order)
 {
 	UNUSED(offset); UNUSED(flags);
 	pm_t paddr = 0;
 	enum mm_order v_order = 0;
-	stat_vmem(b, vaddr, &paddr, &v_order, 0);
+	stat_vpage(b, vaddr, &paddr, &v_order, 0);
 	if(order != v_order)
 		return -1;
 
-	unmap_vmem(b, vaddr);
+	unmap_vpage(b, vaddr);
 	return 0;
 }
 
-vm_t alloc_devmem(struct tcb *t, pm_t dev_start, size_t bytes, uint8_t flags)
+vm_t alloc_devmem(struct tcb *t, pm_t dev_start, size_t bytes, vmflags_t flags)
 {
 	vm_t region = 0;
 	if(dev_start < __pre_top)
@@ -64,7 +64,7 @@ vm_t alloc_devmem(struct tcb *t, pm_t dev_start, size_t bytes, uint8_t flags)
 stat_t free_devmem(struct tcb *t, vm_t dev_start)
 {
 	pm_t dev_paddr = 0;
-	stat_vmem(t->b_r, dev_start, &dev_paddr, 0, 0);
+	stat_vpage(t->b_r, dev_start, &dev_paddr, 0, 0);
 
 	if(dev_paddr >= __pre_top && dev_paddr <= __post_base)
 		return ERR_ADDR;
diff --git a/common/elf.c b/common/elf.c
index 4378d52..6b7b6dd 100644
--- a/common/elf.c
+++ b/common/elf.c
@@ -54,8 +54,8 @@ static void __map_exec(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart, size
 		 * function?
 		 *
 		pm_t paddr = 0;
-		stat_vmem(t->b_r, va, &paddr, 0, 0);
-		mod_vmem(t->b_r, va, paddr, uvflags);
+		stat_vpage(t->b_r, va, &paddr, 0, 0);
+		mod_vpage(t->b_r, va, paddr, uvflags);
 		*/
 	}
 }
diff --git a/common/mem_regions.c b/common/mem_regions.c
index ebcff50..c7abb19 100644
--- a/common/mem_regions.c
+++ b/common/mem_regions.c
@@ -420,9 +420,8 @@ size_t uvmem_size()
  * NOTE: not actually optimal, this doesn't bother to go through possible
  * permutations etc. which would be slow and I don't want to implement it.
  */
-vm_t map_fill_region(struct vm_branch *b,
-		stat_t (*vmem_handler)(struct vm_branch *, pm_t *, vm_t, uint8_t, enum mm_order),
-		pm_t offset, vm_t start, size_t bytes, uint8_t flags)
+vm_t map_fill_region(struct vm_branch *b, mem_region_callback_t *mem_handler,
+		pm_t offset, vm_t start, size_t bytes, vmflags_t flags)
 {
 	pm_t runner = __page(start);
 	size_t pages = __pages(bytes);
@@ -442,7 +441,7 @@ vm_t map_fill_region(struct vm_branch *b,
 			continue;
 
 		while(pages >= o_pages){
-			int res = vmem_handler(b, &offset, __addr(runner), flags, top);
+			stat_t res = mem_handler(b, &offset, __addr(runner), flags, top);
 			if(res > 0)
 				break;
 
diff --git a/common/proc.c b/common/proc.c
index c272727..13d3750 100644
--- a/common/proc.c
+++ b/common/proc.c
@@ -1,8 +1,8 @@
-#include <apos/conf.h>
 #include <apos/elf.h>
+#include <apos/proc.h>
+#include <apos/conf.h>
 #include <apos/string.h>
 #include <apos/initrd.h>
-#include <apos/proc.h>
 #include <arch/arch.h>
 
 /* TODO: add error checking */
@@ -10,11 +10,11 @@ static vm_t setup_call_stack(struct tcb *t, size_t bytes)
 {
 	pm_t offset = 0;
 	size_t pages = __pages(bytes);
-	uint8_t flags = VM_V | VM_R | VM_W | VM_U;
+	vmflags_t flags = VM_V | VM_R | VM_W | VM_U;
 	for(size_t i = 1; i <= pages; ++i)
 	{
 		offset = alloc_page(BASE_PAGE, offset);
-		map_vmem(t->b_r, offset, PROC_STACK_TOP - BASE_PAGE_SIZE * i, flags, BASE_PAGE);
+		map_vpage(t->b_r, offset, PROC_STACK_TOP - BASE_PAGE_SIZE * i, flags, BASE_PAGE);
 	}
 
 	return PROC_STACK_TOP - BASE_PAGE_SIZE * pages;
@@ -25,9 +25,13 @@ static vm_t setup_proc_stack(struct tcb *t, size_t bytes)
 	return alloc_uvmem(t, bytes, VM_V | VM_R | VM_W | VM_U);
 }
 
-void init_proc(void *fdt, struct vm_branch *b)
+stat_t init_proc(void *fdt, struct vm_branch *b)
 {
+	/* todo: cleanup or something */
 	struct tcb *t = (struct tcb *)alloc_page(BASE_PAGE, 0);
+	if(!t)
+		return ERR_OOMEM;
+
 	memset(t, 0, sizeof(struct tcb));
 	t->b_r = b;
 	t->pid = 0;
@@ -39,13 +43,20 @@ void init_proc(void *fdt, struct vm_branch *b)
 
 	/* the binary gets to choose first what memory regions it requires */
 	t->entry = load_elf(t, get_init_base(fdt));
+	if(!t->entry)
+		return ERR_ADDR;
 
 	t->proc_stack = setup_proc_stack(t, __proc_stack_size);
+	if(!t->proc_stack)
+		return ERR_ADDR;
+
 	t->call_stack = setup_call_stack(t, __call_stack_size);
+	if(!t->call_stack)
+		return ERR_ADDR;
 
 
 	flush_tlb();
 
 	/* TODO: move fdt into process space */
-	jump_to_userspace(t, 1, 0);
+	return jump_to_userspace(t, 1, 0);
 }
diff --git a/common/tcb.c b/common/tcb.c
index 7f3cf81..8fea188 100644
--- a/common/tcb.c
+++ b/common/tcb.c
@@ -9,11 +9,11 @@ static struct tcb *__tcb_cache[MAX_CPUS] = {0};
 #define tcb_container(x) \
 	container_of(x, struct tcb, sp_n)
 
-void threads_insert(struct tcb *t)
+stat_t threads_insert(struct tcb *t)
 {
 	if(!sp_root(t_root)){
 		sp_root(t_root) = &t->sp_n;
-		return;
+		return OK;
 	}
 
 	struct sp_node *n = sp_root(t_root), *p = NULL;
@@ -35,6 +35,7 @@ void threads_insert(struct tcb *t)
 	}
 
 	sp_insert(&sp_root(t_root), p, &t->sp_n, d);
+	return OK;
 }
 
 struct tcb *threads_find(id_t tid)
diff --git a/common/vmem.c b/common/vmem.c
index bd0cc29..33c5dd3 100644
--- a/common/vmem.c
+++ b/common/vmem.c
@@ -1,19 +1,19 @@
 #include <apos/mem_regions.h>
 #include <apos/vmem.h>
-
+#include <arch/vmem.h>
 
 stat_t init_uvmem(struct tcb *t, vm_t base, vm_t top)
 {
 	return sp_mem_init(&t->sp_r, base, top);
 }
 
-vm_t alloc_uvmem(struct tcb *t, size_t size, uint8_t flags)
+vm_t alloc_uvmem(struct tcb *t, size_t size, vmflags_t flags)
 {
 	vm_t v = alloc_region(&t->sp_r, size, &size);
 	return map_allocd_region(t->b_r, v, size, flags);
 }
 
-vm_t alloc_fixed_uvmem(struct tcb *t, vm_t start, size_t size, uint8_t flags)
+vm_t alloc_fixed_uvmem(struct tcb *t, vm_t start, size_t size, vmflags_t flags)
 {
 	vm_t v = alloc_fixed_region(&t->sp_r, start, size, &size);
 	return map_allocd_region(t->b_r, v, size, flags);
@@ -32,27 +32,27 @@ stat_t free_uvmem(struct tcb *t, vm_t va)
 	return 0;
 }
 
-stat_t alloc_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, uint8_t flags, enum mm_order order)
+stat_t alloc_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order)
 {
 	*offset = alloc_page(order, *offset);
 	if(!*offset)
-		return 1; /* try again */
+		return MEM_REGION_TRY_AGAIN; /* try again */
 
-	map_vmem(b, *offset, vaddr, flags, order);
-	return 0;
+	map_vpage(b, *offset, vaddr, flags, order);
+	return OK;
 }
 
-stat_t free_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, uint8_t flags, enum mm_order order)
+stat_t free_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order)
 {
 	UNUSED(flags); UNUSED(offset);
 
 	pm_t paddr = 0;
 	enum mm_order v_order = 0;
-	stat_vmem(b, vaddr, &paddr, &v_order, 0);
+	stat_vpage(b, vaddr, &paddr, &v_order, 0);
 	if(order != v_order)
-		return -1;
+		return MEM_REGION_TRY_AGAIN;
 
-	unmap_vmem(b, vaddr);
+	unmap_vpage(b, vaddr);
 	free_page(order, paddr);
 	return 0;
 }