From 9966b49db468de0168c7a455dfb5b4c66c413c4d Mon Sep 17 00:00:00 2001 From: Kimplul Date: Sun, 19 Dec 2021 17:10:36 +0200 Subject: Massive changes to jump to userspace --- arch/riscv/common/vmem.c | 104 ------------- arch/riscv/conf/apos.its | 2 +- arch/riscv/conf/init-link.S | 31 ---- arch/riscv/conf/kernel-link.S | 4 +- arch/riscv/include/csr.h | 36 ++++- arch/riscv/include/vmem.h | 8 + arch/riscv/init/head.S | 7 - arch/riscv/init/init.c | 337 ------------------------------------------ arch/riscv/kernel/irq.c | 4 + arch/riscv/kernel/main.c | 324 +++++++++++++++++++++++++++++++++++----- arch/riscv/kernel/proc.c | 15 ++ arch/riscv/kernel/vmem.c | 52 +++++++ arch/riscv/proc.txt | 3 + arch/riscv/source.mk | 5 +- 14 files changed, 407 insertions(+), 525 deletions(-) delete mode 100644 arch/riscv/common/vmem.c delete mode 100644 arch/riscv/conf/init-link.S delete mode 100644 arch/riscv/init/head.S delete mode 100644 arch/riscv/init/init.c create mode 100644 arch/riscv/kernel/irq.c create mode 100644 arch/riscv/kernel/proc.c create mode 100644 arch/riscv/kernel/vmem.c create mode 100644 arch/riscv/proc.txt (limited to 'arch/riscv') diff --git a/arch/riscv/common/vmem.c b/arch/riscv/common/vmem.c deleted file mode 100644 index 6b022e1..0000000 --- a/arch/riscv/common/vmem.c +++ /dev/null @@ -1,104 +0,0 @@ -#include -#include -#include -#include -#include -#include - -#define pte_ppn(pte) (((pm_t)(pte)) >> 10) -#define pte_flags(pte) (((pm_t)(pte)) & 0xff) -#define to_pte(p, f) ((pm_to_pnum(p) << 10) + (f)) -#define pte_addr(pte) (pnum_to_paddr(pte_ppn(pte))) -#define vm_to_index(a, o) (pm_to_index(a, o)) - -#if defined(KERNEL) - -static vm_t *tmp_pte = 0; -void arch_init_vmem(struct vm_branch_t *branch, vm_t pte) -{ - (void)branch; - tmp_pte = (vm_t *)pte; -} - -/* this seems like an awful idea, should probably try to come up with a smarter - * approach? flushing the cache every time is probably pretty slow and also - * this code doesn't take into account the cpu ASID, although that's probably - * not relevant here */ - -/* what I probably should do is something like Linux, where the kernel has a - * direct (or linear, I suppose?) so that all direct memory accesses are also - * accessible from virtual memory. Not entirely sure how I should do that, - * wouldn't there be situations where the RAM is larger than the allocated - * memory region? - * - * Or maybe some kind of walker, where I maintain a virtual page table that - * mirrors the physical page table? Not sure yet, but this seems to work for - * _now_. - */ -#define QUOTE2(x) #x -#define QUOTE(x) QUOTE2(x) -static void *set_vptr(uint8_t flags, pm_t a) -{ - *tmp_pte = to_pte(a, flags); - __asm__ ("sfence.vma %0, %1" - :: "rk" (0), "rK" (TMP_PTE) - : "memory"); - - return (void *)TMP_PTE; -} - -#else -struct vm_branch_t *arch_get_tmp_pte(struct vm_branch_t *branch) -{ - enum mm_order_t top = __mm_max_order; - while(top){ - size_t idx = vm_to_index(TMP_PTE, top); - branch = (struct vm_branch_t *)pte_addr(branch->leaf[idx]); - top--; - } - - return branch; -} - -#define set_vptr(flags, a) (a) -#endif - -void map_vmem(struct vm_branch_t *branch, - pm_t paddr, vm_t vaddr, uint8_t flags, enum mm_order_t order) -{ - enum mm_order_t top = __mm_max_order; - while (top != order) { - size_t idx = vm_to_index(vaddr, top); - - if (!branch->leaf[idx]) { - pm_t new_leaf = alloc_page(MM_KPAGE, 0); - branch->leaf[idx] = - (struct vm_branch_t *)to_pte(new_leaf, VM_V); - - void *leaf_ptr = (void *)set_vptr(VM_R | VM_W | VM_V, new_leaf); - memset(leaf_ptr, 0, sizeof(struct vm_branch_t)); - } - - pm_t pte = (pm_t)branch->leaf[idx]; - pm_t branch_pptr = (pm_t)pte_addr(pte); - branch = (struct vm_branch_t *)set_vptr(VM_R | VM_W | VM_V, branch_pptr); - top--; - } - - size_t idx = vm_to_index(vaddr, top); - branch->leaf[idx] = (struct vm_branch_t *)to_pte(paddr, flags); -} - -void unmap_vmem(struct vm_branch_t *branch, vm_t vaddr, enum mm_order_t order) -{ - while (order) { - size_t idx = pm_to_index(vaddr, order); - branch = (struct vm_branch_t *)pte_addr(branch->leaf[idx]); - } - - size_t idx = pm_to_index(vaddr, order); - if (branch->leaf[idx]) - free_page(order, pte_addr(branch->leaf[idx])); - - branch->leaf[idx] = 0; -} diff --git a/arch/riscv/conf/apos.its b/arch/riscv/conf/apos.its index 7c05044..1581025 100644 --- a/arch/riscv/conf/apos.its +++ b/arch/riscv/conf/apos.its @@ -7,7 +7,7 @@ images { kernel { description = "Garbaggio"; - data = /incbin/("../../../apos.bin"); + data = /incbin/("../../../kernel.bin"); type = "kernel"; arch = "riscv"; os = "apos"; diff --git a/arch/riscv/conf/init-link.S b/arch/riscv/conf/init-link.S deleted file mode 100644 index c9a6da2..0000000 --- a/arch/riscv/conf/init-link.S +++ /dev/null @@ -1,31 +0,0 @@ -OUTPUT_ARCH(riscv) -ENTRY(_start) - -SECTIONS { - . = ABSOLUTE(PM_KERN); - __init_start = .; - - /* objcopy only copies these three sections (as far as I'm aware) into the - produces binary, so __init_end should point to the correct location in the - final binary - */ - .text ALIGN(4K) : AT(0) { - *(.init.start) - *(.text*); - } - - .rodata : { - *(.rodata*) - } - - .data : { - *(.data*) - } - - .bss : { - *(.bss*) *(COMMON) - } - - __kernel_size = ; - __init_end = . ; -} diff --git a/arch/riscv/conf/kernel-link.S b/arch/riscv/conf/kernel-link.S index d3b1223..bf0ad28 100644 --- a/arch/riscv/conf/kernel-link.S +++ b/arch/riscv/conf/kernel-link.S @@ -2,10 +2,10 @@ OUTPUT_ARCH(riscv) ENTRY(main) SECTIONS { - . = ABSOLUTE(VM_KERN); + . = ABSOLUTE(PM_KERN); __kernel_start = .; - .text ALIGN(4K) : AT(0) { + .text : AT(0) { *(.kernel.start); *(.text*); } diff --git a/arch/riscv/include/csr.h b/arch/riscv/include/csr.h index ab25bdd..70e60bb 100644 --- a/arch/riscv/include/csr.h +++ b/arch/riscv/include/csr.h @@ -3,11 +3,39 @@ #include -#define SATP_MODE_Sv32 0x80000000 -#define SATP_MODE_Sv39 0x8000000000000000 -#define SATP_MODE_Sv48 0x9000000000000000 +#define SATP_MODE_Sv32 0x80000000 +#define SATP_MODE_Sv39 0x8000000000000000 +#define SATP_MODE_Sv48 0x9000000000000000 -#define CSR_SATP 0x180 + +/* supervisor CSR registers */ +#define CSR_SSTATUS 0x100 +#define CSR_SIE 0x104 +#define CSR_STVEC 0x105 +#define CSR_SCOUNTEREN 0x106 + +#define CSR_SENVCFG 0x10A + +#define CSR_SSCRATCH 0x140 +#define CSR_SEPC 0x141 +#define CSR_SCAUSE 0x142 +#define CSR_STVAL 0x143 +#define CSR_SIP 0x144 + +#define CSR_SATP 0x180 + +#define CSR_SCONTEXT 0x5A8 + +/* Exception causes */ +#define EXC_INST_MISALIGNED 0 +#define EXC_INST_ACCESS 1 +#define EXC_BREAKPOINT 3 +#define EXC_LOAD_ACCESS 5 +#define EXC_STORE_ACCESS 7 +#define EXC_SYSCALL 8 +#define EXC_INST_PAGE_FAULT 12 +#define EXC_LOAD_PAGE_FAULT 13 +#define EXC_STORE_PAGE_FAULT 15 /* directly lifted from Linux:/arch/riscv/include/asm/asm.h:9-13 */ #ifdef __ASSEMBLY__ diff --git a/arch/riscv/include/vmem.h b/arch/riscv/include/vmem.h index d17aaf1..2cd3ac7 100644 --- a/arch/riscv/include/vmem.h +++ b/arch/riscv/include/vmem.h @@ -3,6 +3,7 @@ #include #include +#include #define VM_V (1 << 0) #define VM_R (1 << 1) @@ -24,4 +25,11 @@ struct __packed vm_branch_t { struct vm_branch_t *leaf[512]; }; + +void map_vmem(struct vm_branch_t *b, + pm_t paddr, vm_t vaddr, uint8_t flags, enum mm_order_t order); + +void unmap_vmem(struct vm_branch_t *b, + vm_t vaddr, enum mm_order_t order); + #endif /* APOS_RISCV_VMAP_H */ diff --git a/arch/riscv/init/head.S b/arch/riscv/init/head.S deleted file mode 100644 index 3589ead..0000000 --- a/arch/riscv/init/head.S +++ /dev/null @@ -1,7 +0,0 @@ -.section .init.start -.global _start -.type _start, @function -_start: - li sp, PM_STACK_TOP - /* go to proper init */ - j init diff --git a/arch/riscv/init/init.c b/arch/riscv/init/init.c deleted file mode 100644 index 721712c..0000000 --- a/arch/riscv/init/init.c +++ /dev/null @@ -1,337 +0,0 @@ -/* TODO: cleanup :P */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -struct pm_layout_t { - pm_t base; - pm_t top; -}; - -struct pm_orders_t { - size_t max_order; - size_t bits[10]; - size_t page_shift; -}; - -static struct pm_layout_t get_memlayout(void *fdt) -{ - struct cell_info_t 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); - - /* if riscv128 comes around we will probably see addr_cells == 4, but - * I'm not too concerned about it at the moment */ - 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); - - /* -1 because base is a legitimate memory address */ - pm_t top = (pm_t)fdt_load_int_ptr(ci.size_cells, mem_reg) + base - 1; - return (struct pm_layout_t){base, top}; -} - -#ifdef DEBUG - -static void init_debug(void *fdt) -{ - struct dbg_info_t dbg = dbg_from_fdt(fdt); - dbg_init(dbg.dbg_ptr, dbg.dev); -} - -#else -#define init_debug(...) -#endif - -static pm_t get_kerneltop() -{ - /* interesting, for some reason if I define these to be just char - * pointers I get some wacky values. Not sure why that would be, but - * this works. */ - extern char __init_end, __kernel_size; - return (pm_t)&__init_end + (pm_t)&__kernel_size; -} - -static pm_t get_initrdtop(void *fdt) -{ - int chosen_offset = fdt_path_offset(fdt, "/chosen"); - struct cell_info_t ci = get_cellinfo(fdt, chosen_offset); - - void *initrd_end_ptr = (void *)fdt_getprop(fdt, chosen_offset, - "linux,initrd-end", NULL); - - return (pm_t)fdt_load_int_ptr(ci.addr_cells, initrd_end_ptr); -} - -static pm_t get_initrdbase(void *fdt) -{ - int chosen_offset = fdt_path_offset(fdt, "/chosen"); - struct cell_info_t ci = get_cellinfo(fdt, chosen_offset); - - void *initrd_base_ptr = (void *)fdt_getprop(fdt, chosen_offset, - "linux,initrd-start", NULL); - - return (pm_t)fdt_load_int_ptr(ci.addr_cells, initrd_base_ptr); -} - -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; -} - -static void mark_area_used(pm_t base, pm_t top) -{ - size_t area_left = top - base; - /* TODO: add in a method to make sure that we use as large mappings as - * possible. */ - while(area_left >= MM_KPAGE_SIZE){ - mark_used(base, MM_KPAGE); - area_left -= MM_KPAGE_SIZE; - base += MM_KPAGE_SIZE; - } - - if(area_left != 0) - mark_used(base, MM_KPAGE_SIZE); -} - -static void mark_reserved_mem(void *fdt) -{ - int rmem_offset = fdt_path_offset(fdt, "/reserved-memory/mmode_resv0"); - struct cell_info_t 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 - 1; - mark_area_used(base, top); -} - -static struct pm_orders_t init_pmem(void *fdt) -{ - enum mm_mode_t mmode = get_mmode(fdt); - - size_t max_order = 0; - size_t order_bits = 9; - switch(mmode){ - case Sv32: - max_order = 1; - order_bits = 10; - break; - - case Sv39: - max_order = 2; - break; - - case Sv48: - max_order = 3; - break; - }; - - size_t bits[10] = {0}; - for(size_t i = 0; i <= max_order; ++i) - bits[i] = order_bits; - - init_mem(max_order, bits, 12); - - struct pm_orders_t ret = {max_order, {0}, 12}; - for(size_t i = 0; i <= __mm_max_order; ++i) - ret.bits[i] = bits[i]; - - return ret; -} - -static struct pm_layout_t setup_pmem(void *fdt) -{ - struct pm_layout_t pmem = get_memlayout(fdt); - - pm_t initrd_top = get_initrdtop(fdt); - pm_t kernel_top = get_kerneltop(); - pm_t fdt_top = get_fdttop(fdt); - - pm_t top = MAX3(kernel_top, initrd_top, fdt_top); - dbg("initrd_top:\t%#lx\n", initrd_top); - dbg("kernel_top:\t%#lx\n", kernel_top); - dbg("fdt_top:\t%#lx\n", fdt_top); - - /* TODO: check that pmap placement doesn't overwrite anything, such as - * stack or go over top address of memory */ - size_t probe_size = probe_pmap(pmem.base, pmem.top - pmem.base); - /* riscv handles two byte boundaries better than one byte, so align - * upwards */ - pm_t pmap_base = align_up(top + 1, 2); - size_t actual_size = populate_pmap(pmem.base, pmem.top - pmem.base, - pmap_base); - - /* TODO: not entirely sure what to do about this, probably give up trying to - * boot? */ - if(probe_size != actual_size){ - dbg("BUG! probe_size (%#lx) != actual_size (%#lx)\n", - probe_size, actual_size); - } - - /* mark init stack, at the moment always mapped to 2M */ - mark_used(PM_STACK_BASE, MM_MPAGE); - - /* mark kernel, at the moment it is always mapped to a 2M partition */ - mark_used(PM_KERN, MM_MPAGE); - - /* 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); - - return (struct pm_layout_t){.base = pmap_base, .top = actual_size + pmap_base}; -} - -pm_t move_kernel() -{ - extern char __init_end, __kernel_size; - pm_t dst = alloc_page(MM_MPAGE, 0); - memmove((void *)dst, &__init_end, (size_t)&__kernel_size); - - return dst; -} - -struct vm_branch_t *prepare_vmem() -{ - pm_t kernel_dst = move_kernel(); - - /* TODO: check if this actually works */ - struct vm_branch_t *branch = (struct vm_branch_t *)alloc_page(MM_KPAGE, 0); - memset(branch, 0, sizeof(struct vm_branch_t)); - - /* TODO: check mapping flags, also iron out possible bugs etc in - * map_vmem */ - /* map kernel */ - map_vmem(branch, kernel_dst, VM_KERN, VM_R | VM_W | VM_G | VM_X | VM_V, MM_MPAGE); - - /* map init */ - map_vmem(branch, PM_KERN, PM_KERN, VM_R | VM_W | VM_X | VM_V, MM_MPAGE); - - /* map stack */ - map_vmem(branch, PM_STACK_BASE, PM_STACK_BASE, VM_R | VM_W | VM_V, MM_MPAGE); - - /* map root pte */ - map_vmem(branch, (pm_t)branch, ROOT_PTE, VM_R | VM_W | VM_V, MM_KPAGE); - - /* TODO: map more stuff? */ - return branch; -} - -static vm_t prepare_tmp_pte(struct vm_branch_t *branch) -{ - /* make sure the TMP_PTE is mapped to *something* */ - map_vmem(branch, 0, TMP_PTE, VM_R | VM_W | VM_V, MM_KPAGE); - - struct vm_branch_t *tmp_pte = arch_get_tmp_pte(branch); - - vm_t addr = TMP_PTE + MM_KPAGE_SIZE; - map_vmem(branch, (vm_t)tmp_pte, addr, VM_R | VM_W | VM_V, MM_KPAGE); - return addr; -} - -void start_vmem(void *fdt, struct vm_branch_t *branch) -{ - /* TODO: get ASID from CPU id */ - - /* TODO: probably unnecessary optimisations but this could be cached? */ - enum mm_mode_t m = get_mmode(fdt); - - if(m == Sv32) - csr_write(CSR_SATP, SATP_MODE_Sv32 | pm_to_pnum((pm_t)(branch))); - else if (m == Sv39) - csr_write(CSR_SATP, SATP_MODE_Sv39 | pm_to_pnum((pm_t)(branch))); - else - csr_write(CSR_SATP, SATP_MODE_Sv48 | pm_to_pnum((pm_t)(branch))); - - __asm__ ("sfence.vma" : : : "memory"); - /* Sv57 && Sv64 in the future? */ -} - -struct init_data_t populate_initdata(void *fdt, struct pm_orders_t o, - struct pm_layout_t p, - struct vm_branch_t *b, - vm_t v) -{ - extern char __init_start, __init_end; - - struct init_data_t d = {0}; - d.init_base = (pm_t)&__init_start; - d.init_top = (pm_t)&__init_end; - - d.initrd_base = get_initrdbase(fdt); - d.initrd_top = get_initrdtop(fdt); - - d.pmap_base = p.base; - d.pmap_top = p.top; - - d.fdt_base = get_fdtbase(fdt); - d.fdt_top = get_fdttop(fdt); - - d.stack_base = PM_STACK_BASE; - d.stack_top = PM_STACK_TOP; - - d.kernel_vm_base = b; - d.tmp_pte = v; - - d.max_order = o.max_order; - for(size_t i = 0; i <= __mm_max_order; ++i) - d.bits[i] = o.bits[i]; - d.page_shift = o.page_shift; - - /* initialize pmap in vmem */ - pm_t addr = p.base; - while(addr < p.top){ - map_vmem(b, addr, addr, VM_R | VM_W | VM_V, MM_MPAGE); - addr += MM_MPAGE_SIZE; - } - - return d; -} - -void init(void *fdt) -{ - init_debug(fdt); - dbg_fdt(fdt); - - struct pm_orders_t o = init_pmem(fdt); - struct pm_layout_t p = setup_pmem(fdt); - struct vm_branch_t *b = prepare_vmem(); - vm_t v = prepare_tmp_pte(b); - struct init_data_t d = populate_initdata(fdt, o, p, b, v); - start_vmem(fdt, b); - - /* update_pmap(TODO: figure out where to place pmap in vmem); */ - void (*main)(struct init_data_t) = (void (*)(struct init_data_t))VM_KERN; - main(d); -} diff --git a/arch/riscv/kernel/irq.c b/arch/riscv/kernel/irq.c new file mode 100644 index 0000000..f015411 --- /dev/null +++ b/arch/riscv/kernel/irq.c @@ -0,0 +1,4 @@ +void irq_handler() +{ + +} diff --git a/arch/riscv/kernel/main.c b/arch/riscv/kernel/main.c index 3f524bc..c7a1290 100644 --- a/arch/riscv/kernel/main.c +++ b/arch/riscv/kernel/main.c @@ -1,51 +1,305 @@ #include -#include #include +#include +#include #include #include +#include +#include +#include +#include +#include +#include +#include +#include + +struct pm_layout_t { + pm_t base; + pm_t top; +}; + +struct pm_orders_t { + size_t max_order; + size_t bits[10]; + size_t page_shift; +}; #ifdef DEBUG -static void kernel_dbg(void *fdt) +static void init_dbg(void *fdt) { struct dbg_info_t dbg = dbg_from_fdt(fdt); - map_vmem(ROOT_PTE, (pm_t)dbg.dbg_ptr, (vm_t)dbg.dbg_ptr, - VM_R | VM_W | VM_V, MM_KPAGE); dbg_init(dbg.dbg_ptr, dbg.dev); } #else -#define kernel_dbg(...) +#define init_dbg(...) #endif -static void map_fdt(struct vm_branch_t *branch, vm_t fdt_base, vm_t fdt_top) -{ - /* TODO: fix this shit */ - map_vregion(branch, fdt_base, fdt_base, fdt_top - fdt_base, VM_R | VM_W |VM_V); -} - -void __main main(struct init_data_t d) -{ - init_pmap((void *)d.pmap_base); - init_mem(d.max_order, d.bits, d.page_shift); - init_vmem(ROOT_PTE, d.tmp_pte); - /* TODO: move pmap into vmem somewhere */ - /* TODO: mark kernel area as used */ - map_fdt(ROOT_PTE, d.fdt_base, d.fdt_top); - kernel_dbg((void *)d.fdt_base); - dbg("test\n"); - /* TODO: approximate order of business: - * setup debugging in vmem (requires mapping fdt) - * free unnecessary init - * setup interrupts (should this be done in init?) - * load init from initrd - * setup init environment (thread control blocks etc.) - * jumpstart init (free stack init setup) - */ - - /* functionality that should be implemented: - * figure out best continuous run of memory (pmap etc) - * arbitrary user and kernel mapping (memory) - * vm to pm - */ +static struct pm_layout_t get_memlayout(void *fdt) +{ + struct cell_info_t 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); + + /* if riscv128 comes around we will probably see addr_cells == 4, but + * I'm not too concerned about it at the moment */ + 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); + + /* -1 because base is a legitimate memory address */ + pm_t top = (pm_t)fdt_load_int_ptr(ci.size_cells, mem_reg) + base - 1; + return (struct pm_layout_t){base, top}; +} + +static pm_t get_kerneltop() +{ + /* interesting, for some reason if I define these to be just char + * pointers I get some wacky values. Not sure why that would be, but + * this works. */ + extern char __kernel_end; + return (pm_t)&__kernel_end; +} + +static pm_t get_initrdtop(void *fdt) +{ + int chosen_offset = fdt_path_offset(fdt, "/chosen"); + struct cell_info_t ci = get_cellinfo(fdt, chosen_offset); + + void *initrd_end_ptr = (void *)fdt_getprop(fdt, chosen_offset, + "linux,initrd-end", NULL); + + return (pm_t)fdt_load_int_ptr(ci.addr_cells, initrd_end_ptr); +} + +static pm_t get_initrdbase(void *fdt) +{ + int chosen_offset = fdt_path_offset(fdt, "/chosen"); + struct cell_info_t ci = get_cellinfo(fdt, chosen_offset); + + void *initrd_base_ptr = (void *)fdt_getprop(fdt, chosen_offset, + "linux,initrd-start", NULL); + + return (pm_t)fdt_load_int_ptr(ci.addr_cells, initrd_base_ptr); +} + +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; +} + + +static void mark_area_used(pm_t base, pm_t top) +{ + size_t area_left = top - base; + /* TODO: add in a method to make sure that we use as large mappings as + * possible. */ + while(area_left >= MM_KPAGE_SIZE){ + mark_used(base, MM_KPAGE); + area_left -= MM_KPAGE_SIZE; + base += MM_KPAGE_SIZE; + } + + if(area_left != 0) + mark_used(base, MM_KPAGE_SIZE); +} + +static void mark_reserved_mem(void *fdt) +{ + int rmem_offset = fdt_path_offset(fdt, "/reserved-memory/mmode_resv0"); + struct cell_info_t 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 - 1; + mark_area_used(base, top); +} + +static struct pm_layout_t setup_pmem(void *fdt) +{ + struct pm_layout_t pmem = get_memlayout(fdt); + + pm_t initrd_top = get_initrdtop(fdt); + pm_t kernel_top = get_kerneltop(); + pm_t fdt_top = get_fdttop(fdt); + + pm_t top = MAX3(kernel_top, initrd_top, fdt_top); + dbg("initrd_top:\t%#lx\n", initrd_top); + dbg("kernel_top:\t%#lx\n", kernel_top); + dbg("fdt_top:\t%#lx\n", fdt_top); + + /* TODO: check that pmap placement doesn't overwrite anything, such as + * stack or go over top address of memory */ + size_t probe_size = probe_pmap(pmem.base, pmem.top - pmem.base); + /* riscv handles two byte boundaries better than one byte, so align + * upwards */ + pm_t pmap_base = align_up(top + 1, 2); + size_t actual_size = populate_pmap(pmem.base, pmem.top - pmem.base, + pmap_base); + + /* TODO: not entirely sure what to do about this, probably give up trying to + * boot? */ + if(probe_size != actual_size){ + dbg("BUG! probe_size (%#lx) != actual_size (%#lx)\n", + probe_size, actual_size); + } + + /* mark init stack, at the moment always mapped to 2M */ + mark_used(PM_STACK_BASE, MM_MPAGE); + + /* mark kernel, at the moment it is always mapped to a 2M partition */ + mark_used(PM_KERN, MM_MPAGE); + + /* 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); + + return (struct pm_layout_t){.base = pmap_base, .top = actual_size + pmap_base}; +} + +static struct pm_orders_t init_pmem(void *fdt) +{ + enum mm_mode_t mmode = get_mmode(fdt); + + size_t max_order = 0; + size_t order_bits = 9; + switch(mmode){ + case Sv32: + max_order = 1; + order_bits = 10; + break; + + case Sv39: + max_order = 2; + break; + + case Sv48: + max_order = 3; + break; + }; + + size_t bits[10] = {0}; + for(size_t i = 0; i <= max_order; ++i) + bits[i] = order_bits; + + init_mem(max_order, bits, 12); + + struct pm_orders_t ret = {max_order, {0}, 12}; + for(size_t i = 0; i <= __mm_max_order; ++i) + ret.bits[i] = bits[i]; + + return ret; +} + +static void populate_root_branch(struct vm_branch_t *b, size_t mul) +{ + for(size_t i = 0; i <= (MM_KPAGE_SIZE / sizeof(size_t))/2; ++i) + b->leaf[i] = (struct vm_branch_t *)(mul * i | VM_V | VM_R | VM_W | VM_X | VM_G); +} + +static void start_vmem(struct vm_branch_t *branch, enum mm_mode_t m) +{ + /* TODO: get ASID from CPU id */ + + if(m == Sv32) + csr_write(CSR_SATP, SATP_MODE_Sv32 | pm_to_pnum((pm_t)(branch))); + else if (m == Sv39) + csr_write(CSR_SATP, SATP_MODE_Sv39 | pm_to_pnum((pm_t)(branch))); + else + csr_write(CSR_SATP, SATP_MODE_Sv48 | pm_to_pnum((pm_t)(branch))); + + __asm__ ("sfence.vma" : : : "memory"); + /* Sv57 && Sv64 in the future? */ +} + +static struct vm_branch_t *init_vmem(void *fdt) +{ + struct pm_orders_t o = init_pmem(fdt); + setup_pmem(fdt); + + struct vm_branch_t *b = (struct vm_branch_t *)alloc_page(MM_KPAGE, 0); + memset(b, 0, sizeof(struct vm_branch_t)); + + enum mm_mode_t mm = Sv48; + size_t mul = 0; + switch(o.max_order){ + case 3: /* Sv48 */ + mm = Sv48; + mul = 1UL << 37; + break; + + case 2: /* Sv39 */ + mm = Sv39; + mul = 1UL << 28; + break; + + case 1: /* Sv32 */ + mm = Sv32; + mul = 1UL << 20; + break; + } + + set_uvmem_size(mul); + populate_root_branch(b, uvmem_size()); + /* jump to vmem */ + start_vmem(b, mm); + return b; +} + +static void init_irq(void *fdt) +{ +} + +static void init_proc(void *fdt, struct vm_branch_t *b) +{ + struct tcb *t = (struct tcb *)alloc_page(MM_KPAGE, 0); + t->b_r = b; + t->pid = 0; + t->tid = 0; + threads_insert(t); + sp_mem_init(&t->sp_r, uvmem_size()); + + /* binary itself */ + size_t sz = align_up(get_init_size(fdt), BASE_PAGE_SIZE); + t->bin = alloc_uvmem(t, sz, VM_V | VM_X); + /* stack */ + t->stack = alloc_uvmem(t, SZ_2M, VM_V | VM_R | VM_W); + /* if it needs heap, it'll ask for it */ + + move_init(fdt, (void *)t->bin, sz); + jump_to_userspace(t, 0, 0); +} + +void __main main(void *fdt) +{ + init_dbg(fdt); + struct vm_branch_t *b = init_vmem(fdt); + + init_mem_blocks(); + init_irq(fdt); + init_proc(fdt, b); } diff --git a/arch/riscv/kernel/proc.c b/arch/riscv/kernel/proc.c new file mode 100644 index 0000000..3a39dd3 --- /dev/null +++ b/arch/riscv/kernel/proc.c @@ -0,0 +1,15 @@ +#include +#include +#include + +void jump_to_userspace(struct tcb *t, char **argv, int argc) +{ + csr_write(CSR_SEPC, bin_entry(t->bin)); + __asm__("mv sp, %0\n" : "=r" (t->stack) :: "memory"); + __asm__("sret\n" ::: "memory"); +} + +void return_to_userspace(struct tcb *t) +{ + /* lol */ +} diff --git a/arch/riscv/kernel/vmem.c b/arch/riscv/kernel/vmem.c new file mode 100644 index 0000000..ffe8731 --- /dev/null +++ b/arch/riscv/kernel/vmem.c @@ -0,0 +1,52 @@ +#include +#include +#include +#include +#include +#include + +#define pte_ppn(pte) (((pm_t)(pte)) >> 10) +#define pte_flags(pte) (((pm_t)(pte)) & 0xff) +#define to_pte(p, f) ((pm_to_pnum(p) << 10) + (f)) +#define pte_addr(pte) (pnum_to_paddr(pte_ppn(pte))) +#define vm_to_index(a, o) (pm_to_index(a, o)) + +void map_vmem(struct vm_branch_t *branch, + pm_t paddr, vm_t vaddr, uint8_t flags, enum mm_order_t order) +{ + enum mm_order_t top = __mm_max_order; + while (top != order) { + size_t idx = vm_to_index(vaddr, top); + + if (!branch->leaf[idx]) { + pm_t new_leaf = alloc_page(MM_KPAGE, 0); + branch->leaf[idx] = + (struct vm_branch_t *)to_pte(new_leaf, VM_V); + + void *leaf_ptr = (void *)new_leaf; + memset(leaf_ptr, 0, sizeof(struct vm_branch_t)); + } + + pm_t pte = (pm_t)branch->leaf[idx]; + pm_t branch_pptr = (pm_t)pte_addr(pte); + branch = (struct vm_branch_t *)branch_pptr; + top--; + } + + size_t idx = vm_to_index(vaddr, top); + branch->leaf[idx] = (struct vm_branch_t *)to_pte(paddr, flags); +} + +void unmap_vmem(struct vm_branch_t *branch, vm_t vaddr, enum mm_order_t order) +{ + while (order) { + size_t idx = pm_to_index(vaddr, order); + branch = (struct vm_branch_t *)pte_addr(branch->leaf[idx]); + } + + size_t idx = pm_to_index(vaddr, order); + if (branch->leaf[idx]) + free_page(order, pte_addr(branch->leaf[idx])); + + branch->leaf[idx] = 0; +} diff --git a/arch/riscv/proc.txt b/arch/riscv/proc.txt new file mode 100644 index 0000000..29b2e92 --- /dev/null +++ b/arch/riscv/proc.txt @@ -0,0 +1,3 @@ +Each thread should obviously have a thread control block (tcb) which lives in +kernelspace and has pointers to virtual memory allocations, along with PID and +other required data. That's about what I can come up with at the moment. diff --git a/arch/riscv/source.mk b/arch/riscv/source.mk index b1dd361..ecc22bd 100644 --- a/arch/riscv/source.mk +++ b/arch/riscv/source.mk @@ -1,9 +1,6 @@ -KERNEL_LOCAL != echo arch/riscv/kernel/*.[cS] arch/riscv/common/*.[cS] +KERNEL_LOCAL != echo arch/riscv/kernel/*.[cS] KERNEL_SOURCES += $(KERNEL_LOCAL) -INIT_LOCAL != echo arch/riscv/init/*.[cS] arch/riscv/common/*.[cS] -INIT_SOURCES += $(INIT_LOCAL) - CLEANUP_CMD := ./arch/riscv/conf/rmimage.sh ARCH_FLAGS := -mcmodel=medany -- cgit v1.3