From 42a1e087ce99f07b48aaea5552f8e1ce5219d228 Mon Sep 17 00:00:00 2001 From: Kimplul Date: Mon, 9 May 2022 00:12:05 +0300 Subject: improve uapi --- arch/riscv64/kernel/entry.S | 139 ++++++++++++++++++++++++++++++++++++++++++++ arch/riscv64/kernel/head.S | 134 ------------------------------------------ arch/riscv64/source.mk | 2 +- common/uapi/conf.c | 10 ++-- common/uapi/dispatch.c | 7 ++- common/uapi/ipc.c | 15 ++--- common/uapi/mem.c | 35 ++++++----- common/uapi/proc.c | 21 +++---- common/uapi/timers.c | 22 ++++--- include/apos/uapi.h | 53 +++++++++++------ 10 files changed, 235 insertions(+), 203 deletions(-) create mode 100644 arch/riscv64/kernel/entry.S delete mode 100644 arch/riscv64/kernel/head.S diff --git a/arch/riscv64/kernel/entry.S b/arch/riscv64/kernel/entry.S new file mode 100644 index 0000000..0ff1a69 --- /dev/null +++ b/arch/riscv64/kernel/entry.S @@ -0,0 +1,139 @@ +#include +#include + +#if __riscv_xlen == 64 +#define sr sd +#define lr ld +#else +#define sr sw +#define lr lw +#endif + +/* very much based on linux, but why change it if works, eh? */ +.section .text +.align 4 +.global handle_irq +handle_irq: + csrrw tp, CSR_SSCRATCH, tp + bnez tp, _save_context + /* the exception came from the kernel, should probably handle but for + * now just spin in place */ + 1: j 1b +_save_context: + /* store user stack pointer and replace it with kernel stack */ + addi tp, tp,-sizeof_registers + sr sp, offsetof_sp(tp) + mv sp, tp + + /* set scratch to 0 and move thread pointer back */ + csrrw tp, CSR_SSCRATCH, x0 + + /* save registers */ + sr ra, offsetof_ra(sp) + sr gp, offsetof_gp(sp) + sr tp, offsetof_tp(sp) + sr t0, offsetof_t0(sp) + sr t1, offsetof_t1(sp) + sr t2, offsetof_t2(sp) + sr s0, offsetof_s0(sp) + sr a0, offsetof_a0(sp) + sr a1, offsetof_a1(sp) + sr a2, offsetof_a2(sp) + sr a3, offsetof_a3(sp) + sr a4, offsetof_a4(sp) + sr a5, offsetof_a5(sp) + sr a6, offsetof_a6(sp) + sr a7, offsetof_a7(sp) + sr s1, offsetof_s1(sp) + sr s2, offsetof_s2(sp) + sr s3, offsetof_s3(sp) + sr s4, offsetof_s4(sp) + sr s5, offsetof_s5(sp) + sr s6, offsetof_s6(sp) + sr s7, offsetof_s7(sp) + sr s8, offsetof_s8(sp) + sr s9, offsetof_s9(sp) + sr s10,offsetof_s10(sp) + sr s11,offsetof_s11(sp) + sr t3, offsetof_t3(sp) + sr t4, offsetof_t4(sp) + sr t5, offsetof_t5(sp) + sr t6, offsetof_t6(sp) + + /* load supervisor cause */ + csrr s4, CSR_SCAUSE + /* interrupts fall through, exceptions jump */ + bge s4, zero, handle_exception + /* TODO: handle interrupts */ + j restore_all + +handle_exception: + li t0, EXC_SYSCALL + /* system exceptions fall through, syscalls jump */ + beq s4, t0, handle_syscall + j restore_all + +handle_syscall: + /* TODO: CSR_EPC should be moved forward one instruction when dealing + * with syscalls */ + jal syscall_dispatch + /* if we had a thread switch, load kernel stack of current thread and + * restore its context */ + /* TODO: is a whole function call necessary? */ + mv s0, a0 + mv s1, a1 + /* get current tcb */ + call cur_tcb + mv tp, a0 + /* get associated kernel stack */ + mv sp, tp + addi sp, sp, -sizeof_registers + /* restore system call result */ + mv a0, s0 + mv a1, s1 + j restore_noreturn + +restore_all: + lr a0, offsetof_a0(sp) + lr a1, offsetof_a1(sp) + +restore_noreturn: + /* restore registers besides possible return value, assume instruction + * to return to has already been set (CSR_EPC) */ + csrw CSR_SSCRATCH, tp + + lr ra, offsetof_ra(sp) + lr gp, offsetof_gp(sp) + lr tp, offsetof_tp(sp) + lr t0, offsetof_t0(sp) + lr t1, offsetof_t1(sp) + lr t2, offsetof_t2(sp) + /* a0 and a1 should not be restored when coming from a syscall */ + lr a2, offsetof_a2(sp) + lr a3, offsetof_a3(sp) + lr a4, offsetof_a4(sp) + lr a5, offsetof_a5(sp) + lr a6, offsetof_a6(sp) + lr s0, offsetof_s0(sp) + lr s1, offsetof_s1(sp) + lr s2, offsetof_s2(sp) + lr s3, offsetof_s3(sp) + lr s4, offsetof_s4(sp) + lr s5, offsetof_s4(sp) + lr s6, offsetof_s6(sp) + lr s7, offsetof_s7(sp) + lr s8, offsetof_s8(sp) + lr s9, offsetof_s9(sp) + lr s10,offsetof_s10(sp) + lr s11,offsetof_s11(sp) + lr a7, offsetof_a7(sp) + lr t3, offsetof_t3(sp) + lr t4, offsetof_t4(sp) + lr t5, offsetof_t5(sp) + lr t6, offsetof_t6(sp) + + /* restore stack pointer */ + lr sp, offsetof_sp(sp) + + /* assume supervisor for now */ + sret diff --git a/arch/riscv64/kernel/head.S b/arch/riscv64/kernel/head.S deleted file mode 100644 index cef74ba..0000000 --- a/arch/riscv64/kernel/head.S +++ /dev/null @@ -1,134 +0,0 @@ -#include -#include - -#if __riscv_xlen == 64 -#define sr sd -#define lr ld -#else -#define sr sw -#define lr lw -#endif - -/* very much based on linux, but why change it if works, eh? */ -.section .text -.align 4 -.global handle_irq -handle_irq: - csrrw tp, CSR_SSCRATCH, tp - bnez tp, _save_context - /* the exception came from the kernel, should probably handle but for - * now just spin in place */ - 1: j 1b -_save_context: - /* store user stack pointer and replace it with kernel stack */ - addi tp, tp,-sizeof_registers - sr sp, offsetof_sp(tp) - mv sp, tp - - /* set scratch to 0 and move thread pointer back */ - csrrw tp, CSR_SSCRATCH, x0 - - /* save registers */ - sr ra, offsetof_ra(sp) - sr gp, offsetof_gp(sp) - sr tp, offsetof_tp(sp) - sr t0, offsetof_t0(sp) - sr t1, offsetof_t1(sp) - sr t2, offsetof_t2(sp) - sr s0, offsetof_s0(sp) - sr a0, offsetof_a0(sp) - sr a1, offsetof_a1(sp) - sr a2, offsetof_a2(sp) - sr a3, offsetof_a3(sp) - sr a4, offsetof_a4(sp) - sr a5, offsetof_a5(sp) - sr a6, offsetof_a6(sp) - sr a7, offsetof_a7(sp) - sr s1, offsetof_s1(sp) - sr s2, offsetof_s2(sp) - sr s3, offsetof_s3(sp) - sr s4, offsetof_s4(sp) - sr s5, offsetof_s5(sp) - sr s6, offsetof_s6(sp) - sr s7, offsetof_s7(sp) - sr s8, offsetof_s8(sp) - sr s9, offsetof_s9(sp) - sr s10,offsetof_s10(sp) - sr s11,offsetof_s11(sp) - sr t3, offsetof_t3(sp) - sr t4, offsetof_t4(sp) - sr t5, offsetof_t5(sp) - sr t6, offsetof_t6(sp) - - /* load supervisor cause */ - csrr s4, CSR_SCAUSE - /* interrupts fall through, exceptions jump */ - bge s4, zero, handle_exception - /* TODO: handle interrupts */ - j restore_all - -handle_exception: - li t0, EXC_SYSCALL - /* system exceptions fall through, syscalls jump */ - beq s4, t0, handle_syscall - j restore_all - -handle_syscall: - /* TODO: CSR_EPC should be moved forward one instruction when dealing - * with syscalls */ - jal syscall_dispatch - /* if we had a thread switch, load kernel stack of current thread and - * restore its context */ - /* TODO: is a whole function call necessary? */ - mv s0, a0 - /* get current tcb */ - call cur_tcb - mv tp, a0 - /* get associated kernel stack */ - mv sp, tp - addi sp, sp, -sizeof_registers - j restore_noreturn - -restore_all: - lr s0, offsetof_s0(sp) - -restore_noreturn: - /* restore registers besides possible return value, assume instruction - * to return to has already been set (CSR_EPC) */ - csrw CSR_SSCRATCH, tp - - lr ra, offsetof_ra(sp) - lr gp, offsetof_gp(sp) - lr tp, offsetof_tp(sp) - lr t0, offsetof_t0(sp) - lr t1, offsetof_t1(sp) - lr t2, offsetof_t2(sp) - lr a0, offsetof_a0(sp) - lr a1, offsetof_a1(sp) - lr a2, offsetof_a2(sp) - lr a3, offsetof_a3(sp) - lr a4, offsetof_a4(sp) - lr a5, offsetof_a5(sp) - lr a6, offsetof_a6(sp) - lr s1, offsetof_s1(sp) - lr s2, offsetof_s2(sp) - lr s3, offsetof_s3(sp) - lr s4, offsetof_s4(sp) - lr s5, offsetof_s4(sp) - lr s6, offsetof_s6(sp) - lr s7, offsetof_s7(sp) - lr s8, offsetof_s8(sp) - lr s9, offsetof_s9(sp) - lr s10,offsetof_s10(sp) - lr s11,offsetof_s11(sp) - lr a7, offsetof_a7(sp) - lr t3, offsetof_t3(sp) - lr t4, offsetof_t4(sp) - lr t5, offsetof_t5(sp) - lr t6, offsetof_t6(sp) - - /* restore stack pointer */ - lr sp, offsetof_sp(sp) - - /* assume supervisor for now */ - sret diff --git a/arch/riscv64/source.mk b/arch/riscv64/source.mk index fcb7f69..bcbb809 100644 --- a/arch/riscv64/source.mk +++ b/arch/riscv64/source.mk @@ -21,4 +21,4 @@ run: include $(ARCH_SOURCE)/gen/source.mk # dependecy generation -$(ARCH_BUILD)/kernel/head.o: $(ARCH_SOURCE)/include/gen/asm-offsets.h +$(ARCH_BUILD)/kernel/entry.o: $(ARCH_SOURCE)/include/gen/asm-offsets.h diff --git a/common/uapi/conf.c b/common/uapi/conf.c index 3fe6481..25677ef 100644 --- a/common/uapi/conf.c +++ b/common/uapi/conf.c @@ -5,23 +5,23 @@ size_t __proc_stack_size = SZ_2M; size_t __call_stack_size = SZ_2M; -SYSCALL_DEFINE2(conf)(vm_t param, vm_t val) +SYSCALL_DEFINE2(conf)(sys_arg_t param, sys_arg_t val) { UNUSED(param); UNUSED(val); /* no parameters supported atm */ - return OK; + return (struct sys_ret){ OK, 0 }; } -SYSCALL_DEFINE1(poweroff)(vm_t type) +SYSCALL_DEFINE1(poweroff)(sys_arg_t type) { switch (type) { case SHUTDOWN: case COLD_REBOOT: case WARM_REBOOT: - return poweroff(type); + return (struct sys_ret){ OK, poweroff(type) }; }; - return ERR_INVAL; + return (struct sys_ret){ ERR_INVAL, 0 }; } diff --git a/common/uapi/dispatch.c b/common/uapi/dispatch.c index 92fa954..8ffaffb 100644 --- a/common/uapi/dispatch.c +++ b/common/uapi/dispatch.c @@ -33,14 +33,15 @@ static const sys_t syscall_table[] = { SYSCALL_DEFINE0(noop)() { - return 0; + return (struct sys_ret){ OK, 0 }; } -vm_t syscall_dispatch(vm_t syscall, vm_t a, vm_t b, vm_t c, vm_t d) +struct sys_ret syscall_dispatch(sys_arg_t syscall, sys_arg_t a, sys_arg_t b, + sys_arg_t c, sys_arg_t d) { sys_t call = syscall_table[syscall]; if (!call) - return ERR_INVAL; + return (struct sys_ret){ ERR_INVAL, 0 }; return call(a, b, c, d); } diff --git a/common/uapi/ipc.c b/common/uapi/ipc.c index 3244100..7181490 100644 --- a/common/uapi/ipc.c +++ b/common/uapi/ipc.c @@ -1,26 +1,27 @@ #include #include -SYSCALL_DEFINE1(ipc_server)(vm_t callback) +SYSCALL_DEFINE1(ipc_server)(sys_arg_t callback) { struct tcb *r = cur_tcb(); if (r->callback) /* server can't be reinitialized */ - return 1; + return (struct sys_ret){ ERR_EXT, 0 }; r->callback = callback; - return 0; + return (struct sys_ret){ OK, 0 }; } -SYSCALL_DEFINE4(ipc_req)(vm_t pid, vm_t d0, vm_t d1, vm_t d2) +SYSCALL_DEFINE4(ipc_req) +(sys_arg_t pid, sys_arg_t d0, sys_arg_t d1, sys_arg_t d2) { struct tcb *t = get_tcb(pid); /* something like jump_to_callback(t, d0, d1, d2) */ - return 0; + return (struct sys_ret){ OK, 0 }; } -SYSCALL_DEFINE2(ipc_resp)(vm_t pid, vm_t ret) +SYSCALL_DEFINE3(ipc_resp)(sys_arg_t pid, sys_arg_t ret, sys_arg_t val) { struct tcb *r = get_tcb(pid); /* something like return_from_callback(t, r) */ - return 0; /* oh yeah probably unreachable? */ + return (struct sys_ret){ ret, val }; } diff --git a/common/uapi/mem.c b/common/uapi/mem.c index d4893b3..bc3c7fa 100644 --- a/common/uapi/mem.c +++ b/common/uapi/mem.c @@ -3,31 +3,34 @@ #include #include -SYSCALL_DEFINE2(req_mem)(vm_t size, vm_t flags) +SYSCALL_DEFINE2(req_mem)(sys_arg_t size, sys_arg_t flags) { /* proc_tcb should give the tcb of the TID currently running */ struct tcb *r = cur_tcb(); - return alloc_uvmem(r, size, flags); + return (struct sys_ret){ OK, alloc_uvmem(r, size, flags) }; } -SYSCALL_DEFINE3(req_fixmem)(vm_t start, vm_t size, vm_t flags) +SYSCALL_DEFINE3(req_fixmem)(sys_arg_t start, sys_arg_t size, sys_arg_t flags) { struct tcb *r = cur_tcb(); - return alloc_fixed_uvmem(r, start, size, flags); + /* should probably check if the allocation succeeded...? TODO */ + return (struct sys_ret){ OK, alloc_fixed_uvmem(r, start, size, flags) }; } -SYSCALL_DEFINE1(free_mem)(vm_t start) +SYSCALL_DEFINE1(free_mem)(sys_arg_t start) { struct tcb *r = cur_tcb(); - if (start > __pre_top && start < __post_base) - free_uvmem(r, start); + vm_t vm_start = (vm_t)start; + + if (vm_start > __pre_top && vm_start < __post_base) + free_uvmem(r, vm_start); else - free_devmem(r, start); + free_devmem(r, vm_start); - return 0; + return (struct sys_ret){ OK, 0 }; } -SYSCALL_DEFINE3(req_pmem)(vm_t paddr, vm_t size, vm_t flags) +SYSCALL_DEFINE3(req_pmem)(sys_arg_t paddr, sys_arg_t size, sys_arg_t flags) { /* this will require some pondering, but essentially this syscall should * only be used for device access, so any addresses requested should be @@ -35,13 +38,13 @@ SYSCALL_DEFINE3(req_pmem)(vm_t paddr, vm_t size, vm_t flags) * that keeps track of used regions outside of RAM. We'll see. */ struct tcb *r = cur_tcb(); - return alloc_devmem(r, paddr, size, flags); + return (struct sys_ret){ OK, alloc_devmem(r, paddr, size, flags) }; } -SYSCALL_DEFINE4(req_sharedmem)(vm_t pid, vm_t start, vm_t size, vm_t flags) +SYSCALL_DEFINE4(req_sharedmem) +(sys_arg_t tid, sys_arg_t start, sys_arg_t size, sys_arg_t flags) { - /* take memory in PID's vaddr and map it somewhere in our own memory - * region. - */ - return 0; + /* called by server, take memory allocation at start and map it into + * tid's address space? */ + return (struct sys_ret){ OK, 0 }; } diff --git a/common/uapi/proc.c b/common/uapi/proc.c index a5ce839..bd5874d 100644 --- a/common/uapi/proc.c +++ b/common/uapi/proc.c @@ -10,27 +10,28 @@ * would have to periodically ask the kernel about all threads it is aware of * via sys_sync. Dunno. */ -SYSCALL_DEFINE1(fork)(vm_t pid) +SYSCALL_DEFINE0(fork)() { - /* fork might not actually even need pid...? */ /* TODO: create new thread in the same process family */ - return 0; + return (struct sys_ret){ OK, 0 }; } -SYSCALL_DEFINE4(exec)(vm_t pid, vm_t bin, vm_t argc, vm_t argv) +SYSCALL_DEFINE3(exec)(sys_arg_t bin, sys_arg_t argc, sys_arg_t argv) { - /* TODO: execute new process */ - return 0; + /* TODO: execute new process, probably with more sensible argc passing */ + return (struct sys_ret){ OK, 0 }; } -SYSCALL_DEFINE2(signal)(vm_t pid, vm_t signal) +SYSCALL_DEFINE2(signal)(sys_arg_t tid, sys_arg_t signal) { /* TODO: signals? */ - return 0; + return (struct sys_ret){ OK, 0 }; } -SYSCALL_DEFINE1(switch)(vm_t pid) +SYSCALL_DEFINE1(switch)(sys_arg_t tid) { /* TODO: switch to process */ - return 0; + /* TODO: should switch return the registers of the new thread that would + * be used for message passing? */ + return (struct sys_ret){ OK, 0 }; } diff --git a/common/uapi/timers.c b/common/uapi/timers.c index 5ce596f..97a1d30 100644 --- a/common/uapi/timers.c +++ b/common/uapi/timers.c @@ -1,7 +1,7 @@ #include #include -static ticks_t scaled_ticks(vm_t ticks, vm_t repeat) +static ticks_t scaled_ticks(sys_arg_t ticks, sys_arg_t repeat) { #if __WORDSIZE == 64 UNUSED(repeat); @@ -13,25 +13,29 @@ static ticks_t scaled_ticks(vm_t ticks, vm_t repeat) SYSCALL_DEFINE0(timebase)() { - return secs_to_ticks(1); + return (struct sys_ret){ OK, secs_to_ticks(1) }; } -SYSCALL_DEFINE2(req_rel_timer)(vm_t ticks, vm_t repeat) +SYSCALL_DEFINE2(req_rel_timer)(sys_arg_t ticks, sys_arg_t repeat) { - return new_rel_timer(cur_tcb()->tid, scaled_ticks(ticks, repeat)); + return (struct sys_ret){ + OK, new_rel_timer(cur_tcb()->tid, scaled_ticks(ticks, repeat)) + }; } -SYSCALL_DEFINE2(req_abs_timer)(vm_t ticks, vm_t repeat) +SYSCALL_DEFINE2(req_abs_timer)(sys_arg_t ticks, sys_arg_t repeat) { - return new_abs_timer(cur_tcb()->tid, scaled_ticks(ticks, repeat)); + return (struct sys_ret){ + OK, new_abs_timer(cur_tcb()->tid, scaled_ticks(ticks, repeat)) + }; } -SYSCALL_DEFINE1(free_timer)(vm_t cid) +SYSCALL_DEFINE1(free_timer)(sys_arg_t cid) { struct timer *timer = find_timer(cid); if (!timer) - return ERR_NF; + return (struct sys_ret){ ERR_NF, 0 }; remove_timer(timer); - return OK; + return (struct sys_ret){ OK, 0 }; } diff --git a/include/apos/uapi.h b/include/apos/uapi.h index b4a3c6f..ff3f4d0 100644 --- a/include/apos/uapi.h +++ b/include/apos/uapi.h @@ -6,13 +6,23 @@ /* syscall function type, let's start with four arguments and see where that * goes */ -typedef vm_t (*sys_t)(vm_t, vm_t, vm_t, vm_t); +typedef struct sys_ret (*sys_t)(long, long, long, long); +/* TODO: should this be arch specific? should be the size of an integer register */ +typedef long sys_arg_t; -#define SYSCALL_DECLARE(name) vm_t sys_##name(vm_t a, vm_t b, vm_t c, vm_t d); +struct sys_ret { + sys_arg_t err; + sys_arg_t val; +}; + +#define SYSCALL_DECLARE(name) \ + struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + sys_arg_t d); #define SYSCALL_DEFINE0(name) \ - static vm_t __##name(); \ - vm_t sys_##name(vm_t a, vm_t b, vm_t c, vm_t d) \ + static inline struct sys_ret __##name(); \ + struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + sys_arg_t d) \ { \ UNUSED(a); \ UNUSED(b); \ @@ -20,45 +30,51 @@ typedef vm_t (*sys_t)(vm_t, vm_t, vm_t, vm_t); UNUSED(d); \ return __##name(); \ } \ - static vm_t __##name + static struct sys_ret __##name #define SYSCALL_DEFINE1(name) \ - static vm_t __##name(vm_t); \ - vm_t sys_##name(vm_t a, vm_t b, vm_t c, vm_t d) \ + static inline struct sys_ret __##name(sys_arg_t); \ + struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + sys_arg_t d) \ { \ UNUSED(b); \ UNUSED(c); \ UNUSED(d); \ return __##name(a); \ } \ - static vm_t __##name + static inline struct sys_ret __##name #define SYSCALL_DEFINE2(name) \ - static vm_t __##name(vm_t, vm_t); \ - vm_t sys_##name(vm_t a, vm_t b, vm_t c, vm_t d) \ + static inline struct sys_ret __##name(sys_arg_t, sys_arg_t); \ + struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + sys_arg_t d) \ { \ UNUSED(c); \ UNUSED(d); \ return __##name(a, b); \ } \ - static vm_t __##name + static inline struct sys_ret __##name #define SYSCALL_DEFINE3(name) \ - static vm_t __##name(vm_t, vm_t, vm_t); \ - vm_t sys_##name(vm_t a, vm_t b, vm_t c, vm_t d) \ + static inline struct sys_ret __##name(sys_arg_t, sys_arg_t, \ + sys_arg_t); \ + struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + sys_arg_t d) \ { \ UNUSED(d); \ return __##name(a, b, c); \ } \ - static vm_t __##name + static inline struct sys_ret __##name #define SYSCALL_DEFINE4(name) \ - static vm_t __##name(vm_t, vm_t, vm_t, vm_t); \ - vm_t sys_##name(vm_t a, vm_t b, vm_t c, vm_t d) \ + static inline struct sys_ret __##name(sys_arg_t, sys_arg_t, sys_arg_t, \ + sys_arg_t); \ + struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + sys_arg_t d) \ { \ return __##name(a, b, c, d); \ } \ - static vm_t __##name + static inline struct sys_ret __##name /* noop */ SYSCALL_DECLARE(noop); @@ -91,6 +107,7 @@ SYSCALL_DECLARE(switch); SYSCALL_DECLARE(conf); SYSCALL_DECLARE(poweroff); -vm_t syscall_dispatch(vm_t syscall, vm_t a, vm_t b, vm_t c, vm_t d); +struct sys_ret syscall_dispatch(sys_arg_t syscall, sys_arg_t a, sys_arg_t b, + sys_arg_t c, sys_arg_t d); #endif /* APOS_UAPI_H */ -- cgit v1.3