From 4f4d9fdc89c27aa3346467a24b621954f4564d3b Mon Sep 17 00:00:00 2001 From: Kimplul Date: Wed, 29 Dec 2021 23:23:36 +0200 Subject: 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 --- common/debug.c | 16 ++--- common/elf.c | 6 +- common/fdt.c | 8 +-- common/initrd.c | 4 +- common/main.c | 52 ++++++++++++++++ common/mem.c | 22 ------- common/pmem.c | 179 ++++++++++++++++++++++++++++++++++------------------- common/proc.c | 42 +++++++++++-- common/tcb.c | 5 ++ common/uapi/conf.c | 4 ++ common/vmem.c | 7 ++- 11 files changed, 236 insertions(+), 109 deletions(-) create mode 100644 common/main.c (limited to 'common') 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 -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 +#include +#include +#include +#include +#include +#include +#include + +#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 +#include +#include #include /* memset */ #include /* __is_nset etc */ +#include /* 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 +#include +#include +#include #include /* 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 #include +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); -- cgit v1.3