Refactoring

+ Mainly just moving stuff out or arch/riscv/ that should be handled in
  common/

+ Prepared separate process stack/call stack for server callbacks, rest
  to be implemeted soon ish

11 files changed, 236 insertions, 109 deletions

diff --git a/common/debug.c b/common/debug.c
index 1800b1c..d34823a 100644
--- a/common/debug.c
+++ b/common/debug.c
@@ -59,7 +59,7 @@ static void __putchar(char c)
 	port->data = c;
 }
 
-static enum serial_dev_t serial_dev_enum(const char *dev_name)
+static enum serial_dev serial_dev_enum(const char *dev_name)
 {
 	if (strncmp("ns16550", dev_name, 7) == 0)
 		return NS16550A;
@@ -67,7 +67,7 @@ static enum serial_dev_t serial_dev_enum(const char *dev_name)
 	return -1;
 }
 
-struct dbg_info_t dbg_from_fdt(void *fdt)
+struct dbg_info dbg_from_fdt(void *fdt)
 {
 	int chosen_offset = fdt_path_offset(fdt, "/chosen");
 	const char *stdout = fdt_getprop(fdt, chosen_offset, "stdout-path", NULL);
@@ -78,22 +78,22 @@ struct dbg_info_t dbg_from_fdt(void *fdt)
 	const char *dev_name = (const char *)fdt_getprop(fdt, stdout_offset,
 			"compatible", NULL);
 
-	enum serial_dev_t dev = serial_dev_enum(dev_name);
+	enum serial_dev dev = serial_dev_enum(dev_name);
 
 	/* get serial device address */
-	struct cell_info_t ci = get_reginfo(fdt, stdout);
+	struct cell_info ci = get_reginfo(fdt, stdout);
 	void *reg_ptr = (void *)fdt_getprop(fdt, stdout_offset, "reg", NULL);
 
-	void *dbg_ptr = (void *)(pm_t)fdt_load_int_ptr(ci.addr_cells, reg_ptr);
+	pm_t dbg_ptr = (pm_t)fdt_load_int_ptr(ci.addr_cells, reg_ptr);
 
-	return (struct dbg_info_t){dbg_ptr, dev};
+	return (struct dbg_info){dbg_ptr, dev};
 }
 
-void dbg_init(void *pt, enum serial_dev_t dev)
+void setup_dbg(vm_t pt, enum serial_dev dev)
 {
 	switch (dev) {
 		case NS16550A:
-			port = pt;
+			port = (struct ns16550a *)pt;
 			break;
 	}
 
diff --git a/common/elf.c b/common/elf.c
index fafef00..aab00d1 100644
--- a/common/elf.c
+++ b/common/elf.c
@@ -72,9 +72,9 @@ static vm_t __prepare_proc(struct tcb *t, uint8_t ei_c, vm_t elf)
 }
 
 /* sets up all memory regions etc, returns the entry address */
-vm_t prepare_proc(struct tcb *t, vm_t p)
+vm_t load_elf(struct tcb *t, vm_t b)
 {
-	struct elf_ident *i = (struct elf_ident *)p;
+	struct elf_ident *i = (struct elf_ident *)b;
 	if(i->ei_magic != cpu_to_be32(EI_MAGIC))
 		return 0;
 
@@ -82,5 +82,5 @@ vm_t prepare_proc(struct tcb *t, vm_t p)
 			return 0;
 
 	/* more sanity checks? */
-	return __prepare_proc(t, i->ei_class, p);
+	return __prepare_proc(t, i->ei_class, b);
 }
diff --git a/common/fdt.c b/common/fdt.c
index c554b25..f76ad64 100644
--- a/common/fdt.c
+++ b/common/fdt.c
@@ -1,19 +1,19 @@
 #include <libfdt.h>
 
-struct cell_info_t get_cellinfo(void *fdt, int offset)
+struct cell_info get_cellinfo(void *fdt, int offset)
 {
-	return (struct cell_info_t){
+	return (struct cell_info){
 		fdt_size_cells(fdt, offset),
 		fdt_address_cells(fdt, offset)
 	};
 }
 
 /* how "reg" is interpreted depends on the parent node */
-struct cell_info_t get_reginfo(void *fdt, const char *path)
+struct cell_info get_reginfo(void *fdt, const char *path)
 {
 	const char *i = strrchr(path, '/');
 	if(!i)
-		return (struct cell_info_t){0, 0};
+		return (struct cell_info){0, 0};
 
 	size_t baselen = i - path;
 	if(i == 0)
diff --git a/common/initrd.c b/common/initrd.c
index 18db836..afce2ec 100644
--- a/common/initrd.c
+++ b/common/initrd.c
@@ -56,7 +56,7 @@ static struct cpio_header *find_file(char *c, char* fname, size_t fname_len)
 pm_t get_initrdtop(void *fdt)
 {
 	int chosen_offset = fdt_path_offset(fdt, "/chosen");
-	struct cell_info_t ci = get_cellinfo(fdt, chosen_offset);
+	struct cell_info ci = get_cellinfo(fdt, chosen_offset);
 
 	void *initrd_end_ptr = (void *)fdt_getprop(fdt, chosen_offset,
 			"linux,initrd-end", NULL);
@@ -68,7 +68,7 @@ pm_t get_initrdtop(void *fdt)
 pm_t get_initrdbase(void *fdt)
 {
 	int chosen_offset = fdt_path_offset(fdt, "/chosen");
-	struct cell_info_t ci = get_cellinfo(fdt, chosen_offset);
+	struct cell_info ci = get_cellinfo(fdt, chosen_offset);
 
 	void *initrd_base_ptr = (void *)fdt_getprop(fdt, chosen_offset,
 			"linux,initrd-start", NULL);
diff --git a/common/main.c b/common/main.c
new file mode 100644
index 0000000..f91fc22
--- /dev/null
+++ b/common/main.c
@@ -0,0 +1,52 @@
+#include <apos/mem_nodes.h>
+#include <apos/attrs.h>
+#include <apos/proc.h>
+#include <apos/debug.h>
+#include <apos/vmem.h>
+#include <apos/arch.h>
+#include <apos/irq.h>
+#include <libfdt.h>
+
+#ifdef DEBUG
+static struct dbg_info dbg_info = (struct dbg_info){0};
+
+static void init_dbg(void *fdt)
+{
+	dbg_info = dbg_from_fdt(fdt);
+}
+
+static void setup_dmap_dbg()
+{
+	setup_dbg(dbg_info.dbg_ptr, dbg_info.dev);
+}
+
+static void setup_io_dbg(struct vm_branch *b)
+{
+	vm_t io_ptr = setup_kernel_io(b, dbg_info.dbg_ptr);
+	setup_dbg(io_ptr, dbg_info.dev);
+}
+#else
+#define init_dbg(...)
+#define setup_dmap_dbg(...)
+#define setup_io_dbg(...)
+#endif
+
+void __main main(void *fdt)
+{
+	/* dbg uses direct mapping at this point */
+	init_dbg(fdt);
+	setup_dmap_dbg();
+	dbg_fdt(fdt);
+
+	arch_setup(fdt);
+
+	init_pmem(fdt);
+	init_mem_blocks();
+	struct vm_branch *b = init_vmem(fdt);
+
+	/* start up debugging in kernel IO */
+	setup_io_dbg(b);
+
+	init_irq(fdt);
+	init_proc(fdt, b);
+}
diff --git a/common/mem.c b/common/mem.c
index cff11b7..7a7eff6 100644
--- a/common/mem.c
+++ b/common/mem.c
@@ -24,25 +24,3 @@ void init_mem(size_t max_order, size_t bits[10], size_t page_shift)
 		__mm_sizes[i] = 1UL << __mm_shifts[i] << __mm_page_shift;
 	}
 }
-
-enum mm_mode_t get_mmode(void *fdt)
-{
-	int mmu_offset = fdt_path_offset(fdt, "/cpus/cpu");
-	const char *mmu = fdt_getprop(fdt, mmu_offset, "mmu-type", NULL);
-
-	if(strncmp("riscv,sv48", mmu, 10) == 0)
-		return Sv48;
-
-	if(strncmp("riscv,sv39", mmu, 10) == 0)
-		return Sv39;
-
-	if(strncmp("riscv,sv32", mmu, 10) == 0)
-		return Sv32;
-
-	/* fdt is missing mmu-type for some reason, but we can probably use
-	 * these values as fallback */
-	if(__riscv_xlen == 32)
-		return Sv32;
-	else
-		return Sv39;
-}
diff --git a/common/pmem.c b/common/pmem.c
index e40d160..d9cdd50 100644
--- a/common/pmem.c
+++ b/common/pmem.c
@@ -1,6 +1,9 @@
 #include <apos/pmem.h>
+#include <apos/debug.h>
+#include <apos/initrd.h>
 #include <apos/string.h> /* memset */
 #include <apos/bits.h> /* __is_nset etc */
+#include <libfdt.h>
 
 /* NOTE: these are all for pnum_t, i.e. O0_SHIFT is from 0 */
 #define __foreach_page(var, start, end, attr, neg)\
@@ -41,7 +44,7 @@ struct mm_branch_t {
 struct mm_omap_t {
 	pm_t base;
 	mm_node_t **orders;
-	enum mm_order_t order;
+	enum mm_order order;
 };
 
 struct mm_pmap_t {
@@ -50,8 +53,8 @@ struct mm_pmap_t {
 
 static struct mm_pmap_t *pmap = 0;
 
-static void __mark_free(mm_node_t * op, pnum_t pnum, enum mm_order_t tgt,
-	enum mm_order_t src, enum mm_order_t dst)
+static void __mark_free(mm_node_t * op, pnum_t pnum, enum mm_order tgt,
+	enum mm_order src, enum mm_order dst)
 {
 	size_t idx = pnum_to_index(pnum, src);
 
@@ -69,7 +72,7 @@ static void __mark_free(mm_node_t * op, pnum_t pnum, enum mm_order_t tgt,
 	__clear_nbit(o->full[__o_container(idx)], __o_bit(idx));
 }
 
-void free_page(enum mm_order_t order, pm_t paddr)
+void free_page(enum mm_order order, pm_t paddr)
 {
 	for (size_t i = MM_O0; i <= __mm_max_order; ++i) {
 		if (!pmap->omap[i])
@@ -88,8 +91,8 @@ void free_page(enum mm_order_t order, pm_t paddr)
 	}
 }
 
-static bool __mark_used(mm_node_t * op, pnum_t pnum, enum mm_order_t tgt,
-	enum mm_order_t src, enum mm_order_t dst)
+static bool __mark_used(mm_node_t * op, pnum_t pnum, enum mm_order tgt,
+	enum mm_order src, enum mm_order dst)
 {
 	size_t idx = pnum_to_index(pnum, src);
 
@@ -123,7 +126,7 @@ static bool __mark_used(mm_node_t * op, pnum_t pnum, enum mm_order_t tgt,
 	return false;
 }
 
-void mark_used(enum mm_order_t order, pm_t paddr)
+void mark_used(enum mm_order order, pm_t paddr)
 {
 	for (size_t i = MM_O0; i <= __mm_max_order; ++i) {
 		if (!pmap->omap[i])
@@ -143,7 +146,7 @@ void mark_used(enum mm_order_t order, pm_t paddr)
 }
 
 static pnum_t __enum_order(mm_node_t * op, pnum_t offset,
-	enum mm_order_t src, enum mm_order_t dst)
+	enum mm_order src, enum mm_order dst)
 {
 	size_t idx = pnum_to_index(offset, src);
 
@@ -173,7 +176,7 @@ static pnum_t __enum_order(mm_node_t * op, pnum_t offset,
 	return -1;
 }
 
-pm_t alloc_page(enum mm_order_t order, pm_t offset)
+pm_t alloc_page(enum mm_order order, pm_t offset)
 {
 	if (order > __mm_max_order)
 		return 0;
@@ -204,57 +207,9 @@ pm_t alloc_page(enum mm_order_t order, pm_t offset)
 	return paddr;
 }
 
-
-
-static void __update_order(mm_node_t * op, pm_t base, pm_t offset,
-	enum mm_order_t src, enum mm_order_t dst)
-{
-	if (src == dst) {
-		struct mm_leaf_t *o = (struct mm_leaf_t *)op;
-		o->used = (mm_info_t *) move_paddr(o->used, base, offset);
-		return;
-	}
-
-	struct mm_branch_t *o = (struct mm_branch_t *)op;
-	o->full = (mm_info_t *) move_paddr(o->full, base, offset);
-	for (size_t i = 0; i < o->entries; ++i) {
-		__update_order(o->next[i], base, offset, src - 1, dst);
-		o->next[i] =
-			(mm_node_t **) move_paddr(o->next[i], base, offset);
-	}
-
-	o->next = (mm_node_t **) move_paddr(o->next, base, offset);
-}
-
-static void __update_omap(struct mm_omap_t *omap, pm_t base, pm_t offset)
-{
-	for (size_t i = MM_O0; i <= omap->order; ++i) {
-		__update_order(omap->orders[i], base, offset, omap->order, i);
-		omap->orders[i] =
-			(mm_node_t *) move_paddr(omap->orders[i], base, offset);
-	}
-
-	omap->orders = (mm_node_t **) move_paddr(omap->orders, base, offset);
-}
-
-void update_pmap(pm_t offset)
-{
-	pm_t base = (pm_t) pmap;
-	for (size_t i = 0; i <= __mm_max_order; ++i) {
-		if (!pmap->omap[i])
-			continue;
-
-		__update_omap(pmap->omap[i], base, offset);
-		pmap->omap[i] = (struct mm_omap_t *)move_paddr(pmap->omap[i],
-			base, offset);
-	}
-
-	pmap = (struct mm_pmap_t *)move_paddr(pmap, base, offset);
-}
-
 /* unfortunate that populating the mm info is so complicated */
 static pm_t __populate_order(mm_node_t ** op, pm_t cont,
-	enum mm_order_t src, enum mm_order_t dst, size_t num)
+	enum mm_order src, enum mm_order dst, size_t num)
 {
 	if (src == dst) {
 		struct mm_leaf_t *o = (struct mm_leaf_t *)
@@ -286,7 +241,7 @@ static pm_t __populate_order(mm_node_t ** op, pm_t cont,
 	return cont;
 }
 
-static pm_t __probe_order(pm_t cont, enum mm_order_t src, enum mm_order_t dst,
+static pm_t __probe_order(pm_t cont, enum mm_order src, enum mm_order dst,
 		size_t num)
 {
 	if(src == dst){
@@ -306,7 +261,7 @@ static pm_t __probe_order(pm_t cont, enum mm_order_t src, enum mm_order_t dst,
 }
 
 static pm_t __populate_omap(struct mm_omap_t **omap, pm_t cont,
-	pm_t base, size_t entries, enum mm_order_t order)
+	pm_t base, size_t entries, enum mm_order order)
 {
 	struct mm_omap_t *lomap = (struct mm_omap_t *)
 		move_forward(cont, sizeof(struct mm_omap_t));
@@ -327,7 +282,7 @@ static pm_t __populate_omap(struct mm_omap_t **omap, pm_t cont,
 	return cont;
 }
 
-static pm_t __probe_omap(pm_t cont, size_t entries, enum mm_order_t order)
+static pm_t __probe_omap(pm_t cont, size_t entries, enum mm_order order)
 {
 	cont += sizeof(struct mm_omap_t);
 	cont += (order + 1) * sizeof(mm_node_t **);
@@ -388,8 +343,104 @@ pm_t probe_pmap(pm_t ram_base, size_t ram_size)
 	return cont;
 }
 
-/* only call from kernel */
-void init_pmap(void *p)
+static void mark_area_used(pm_t base, pm_t top)
 {
-	pmap = (struct mm_pmap_t *)p;
+	size_t area_left = top - base;
+	pm_t runner = base;
+	while(area_left >= BASE_PAGE_SIZE){
+		mark_used(BASE_PAGE, runner);
+		runner += BASE_PAGE_SIZE;
+		area_left -= BASE_PAGE_SIZE;
+	}
+
+	if(area_left != 0)
+		mark_used(BASE_PAGE, runner);
+}
+
+static void mark_reserved_mem(void *fdt)
+{
+	int rmem_offset = fdt_path_offset(fdt, "/reserved-memory/mmode_resv0");
+	struct cell_info ci = get_reginfo(fdt, "/reserved-memory/mmode_resv0");
+	uint8_t *rmem_reg = (uint8_t *)fdt_getprop(fdt, rmem_offset, "reg", NULL);
+
+	pm_t base = (pm_t)fdt_load_int_ptr(ci.addr_cells, rmem_reg);
+
+	if(ci.addr_cells == 2)
+		rmem_reg += sizeof(fdt64_t);
+	else
+		rmem_reg += sizeof(fdt32_t);
+
+	pm_t top = (pm_t)fdt_load_int_ptr(ci.size_cells, rmem_reg) + base;
+	mark_area_used((pm_t)__va(base), (pm_t)__va(top));
+}
+
+static pm_t get_ramtop(void *fdt)
+{
+	struct cell_info ci = get_reginfo(fdt, "/memory");
+	int mem_offset = fdt_path_offset(fdt, "/memory");
+	uint8_t *mem_reg = (uint8_t *)fdt_getprop(fdt, mem_offset, "reg", NULL);
+
+	pm_t base = (pm_t)fdt_load_int_ptr(ci.addr_cells, mem_reg);
+
+	if(ci.addr_cells == 2)
+		mem_reg += sizeof(fdt64_t);
+	else
+		mem_reg += sizeof(fdt32_t);
+
+	return (pm_t)fdt_load_int_ptr(ci.size_cells, mem_reg) + base;
+}
+
+static pm_t get_fdttop(void *fdt)
+{
+	const char *b = (const char *)fdt;
+	return (pm_t)(b + fdt_totalsize(fdt));
+}
+
+static pm_t get_fdtbase(void *fdt)
+{
+	/* lol */
+	return (pm_t)fdt;
+}
+
+void init_pmem(void *fdt)
+{
+	size_t max_order = 0;
+	size_t base_bits = 0;
+	size_t bits[ORDERS_NUM] = {0};
+	arch_pmem_conf(fdt, &max_order, &base_bits, bits);
+	init_mem(max_order, bits, base_bits);
+
+	pm_t ram_size = get_ramtop(fdt) - RAM_BASE;
+	pm_t ram_base = (pm_t)__va(RAM_BASE);
+
+	pm_t initrd_top = get_initrdtop(fdt);
+	pm_t fdt_top = get_fdttop(fdt);
+
+	/* find probably most suitable contiguous region of ram for our physical
+	 * ram map */
+	pm_t pmap_base = align_up(MAX(initrd_top, fdt_top), sizeof(int));
+
+	size_t probe_size = probe_pmap(ram_base, ram_size);
+	size_t actual_size = populate_pmap(ram_base, ram_size, pmap_base);
+
+	if(probe_size != actual_size)
+		dbg("BUG! probe_size (%#lx) != actual_size (%#lx)\n",
+				probe_size, actual_size);
+
+	/* mark init stack, this should be unmapped once we get to executing
+	 * processes */
+	mark_area_used((pm_t)__va(PM_STACK_BASE), (pm_t)__va(PM_STACK_TOP));
+
+	/* mark kernel */
+	mark_area_used((pm_t)__va(PM_KERN_BASE), (pm_t)__va(PM_KERN_TOP));
+
+	/* mark fdt and initrd */
+	mark_area_used(get_initrdbase(fdt), initrd_top);
+	mark_area_used(get_fdtbase(fdt), fdt_top);
+
+	/* mark pmap */
+	mark_area_used(pmap_base, pmap_base + actual_size);
+
+	/* mark reserved mem */
+	mark_reserved_mem(fdt);
 }
diff --git a/common/proc.c b/common/proc.c
index 5fdf413..ccd60bd 100644
--- a/common/proc.c
+++ b/common/proc.c
@@ -1,16 +1,50 @@
+#include <apos/conf.h>
+#include <apos/elf.h>
+#include <apos/string.h>
+#include <apos/initrd.h>
 #include <apos/proc.h>
 
 /* TODO: add error checking */
-vm_t setup_call_stack(struct tcb *t, vm_t start, size_t bytes)
+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;
-	for(size_t i = 0; i < pages; ++i)
+	for(size_t i = 1; i <= pages; ++i)
 	{
 		offset = alloc_page(BASE_PAGE, offset);
-		map_vmem(t->b_r, offset, start + BASE_PAGE_SIZE * i, flags, BASE_PAGE);
+		map_vmem(t->b_r, offset, PROC_STACK_TOP - BASE_PAGE_SIZE * i, flags, BASE_PAGE);
 	}
 
-	return start;
+	return PROC_STACK_TOP - BASE_PAGE_SIZE * pages;
+}
+
+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)
+{
+	struct tcb *t = (struct tcb *)alloc_page(BASE_PAGE, 0);
+	memset(t, 0, sizeof(struct tcb));
+	t->b_r = b;
+	t->pid = 0;
+	t->tid = 0;
+
+	threads_insert(t);
+
+	sp_mem_init(&t->sp_r, UVMEM_START, UVMEM_END);
+
+	/* the binary gets to choose first what memory regions it requires */
+	t->entry = load_elf(t, get_init_base(fdt));
+
+	t->proc_stack = setup_proc_stack(t, __proc_stack_size);
+	t->call_stack = setup_call_stack(t, __call_stack_size);
+
+
+	flush_tlb();
+
+	/* TODO: move fdt into process space */
+	jump_to_userspace(t, 1, 0);
 }
diff --git a/common/tcb.c b/common/tcb.c
index 1547d49..cbbfa47 100644
--- a/common/tcb.c
+++ b/common/tcb.c
@@ -67,3 +67,8 @@ struct tcb *cur_tcb()
 {
 	return __tcb_cache[cpu_id()];
 }
+
+void set_tcb(struct tcb *t)
+{
+	__tcb_cache[cpu_id()] = t;
+}
diff --git a/common/uapi/conf.c b/common/uapi/conf.c
index 01c4ada..6f4faff 100644
--- a/common/uapi/conf.c
+++ b/common/uapi/conf.c
@@ -1,5 +1,9 @@
+#include <apos/sizes.h>
 #include <apos/uapi.h>
 
+size_t __proc_stack_size = SZ_2M;
+size_t __call_stack_size = SZ_2M;
+
 vm_t sys_conf(vm_t param, vm_t val, vm_t u0, vm_t u1)
 {
 	UNUSED(u0); UNUSED(u1);
diff --git a/common/vmem.c b/common/vmem.c
index ffe9b32..9ff3b96 100644
--- a/common/vmem.c
+++ b/common/vmem.c
@@ -182,6 +182,9 @@ static struct sp_mem *sp_find_used_closest(struct sp_reg_root *r, vm_t start)
 	struct sp_mem *closest = 0;
 	size_t md = (size_t)(-1);
 	struct sp_node *n = sp_root(r->used_regions);
+	if(!n)
+		return mem_container(sp_root(r->free_regions));
+
 	while(n){
 		struct sp_mem *t = mem_container(n);
 		size_t d = ABS((ssize_t)start - (ssize_t)t->start);
@@ -415,12 +418,12 @@ 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_t *b, vm_t start, size_t bytes, uint8_t flags)
+vm_t map_fill_region(struct vm_branch *b, vm_t start, size_t bytes, uint8_t flags)
 {
 	pm_t offset = 0;
 	pm_t runner = __page(start);
 	size_t pages = __pages(bytes);
-	enum mm_order_t top = __mm_max_order;
+	enum mm_order top = __mm_max_order;
 
 	/* actual start might not be the same as the user specified start */
 	start = __addr(runner);