From e1599d8ab33f3f7d09c6a8a05f954209c969c8c1 Mon Sep 17 00:00:00 2001 From: Kimplul Date: Mon, 21 Nov 2022 17:38:57 +0200 Subject: make syscall handlers void --- common/dispatch.c | 15 +++--- common/uapi/cap.c | 21 +++++---- common/uapi/conf.c | 25 ++++++---- common/uapi/dispatch.c | 124 +++++++++++++++---------------------------------- common/uapi/ipc.c | 50 ++++++++++++-------- common/uapi/mem.c | 30 +++++++----- common/uapi/proc.c | 43 ++++++++++------- common/uapi/timers.c | 31 +++++++------ 8 files changed, 163 insertions(+), 176 deletions(-) (limited to 'common') diff --git a/common/dispatch.c b/common/dispatch.c index 7fc13cf..25ff0eb 100644 --- a/common/dispatch.c +++ b/common/dispatch.c @@ -22,14 +22,17 @@ * @param d Argument 2. * @param e Argument 3. * @param f Argument 4. - * @return Return value of taken action. + * + * Returns value of taken action. */ -struct sys_ret dispatch(sys_arg_t a, sys_arg_t b, sys_arg_t c, - sys_arg_t d, sys_arg_t e, sys_arg_t f) +void dispatch(sys_arg_t a, sys_arg_t b, sys_arg_t c, + sys_arg_t d, sys_arg_t e, sys_arg_t f) { struct tcb *t = cur_tcb(); - if (clear_ipi(t)) - return handle_ipi(t); + if (clear_ipi(t)) { + handle_ipi(t); + return; + } - return handle_syscall(t, a, b, c, d, e, f); + handle_syscall(a, b, c, d, e, f, t); } diff --git a/common/uapi/cap.c b/common/uapi/cap.c index b094c43..f681e8d 100644 --- a/common/uapi/cap.c +++ b/common/uapi/cap.c @@ -29,6 +29,7 @@ static capflags_t *__get_tcb_caps(id_t tid, size_t off) /** * Set capabilities. * + * @param t Current tcb. * @param tid Thread ID whose capabilities to set. * @param off Offset of capability, multiple of \c bits(cap). * @param caps Mask of capabilities to set. @@ -38,37 +39,37 @@ SYSCALL_DEFINE3(set_cap)(struct tcb *t, sys_arg_t tid, sys_arg_t off, sys_arg_t caps) { if (!is_set(t->caps, CAP_CAPS)) - return SYS_RET1(ERR_PERM); + return_args(t, SYS_RET1(ERR_PERM)); capflags_t *c; if (!(c = __get_tcb_caps(tid, off))) - return SYS_RET1(ERR_INVAL); + return_args(t, SYS_RET1(ERR_INVAL)); set_caps(*c, off, caps); - return SYS_RET1(OK); + return_args(t, SYS_RET1(OK)); } /** * Get capabilities. * + * @param t Current tcb. * @param tid Thread ID whose capabilities to get. * @param off Offset of capability, multiple of \c bits(cap). * @return \ref OK, capabilities. */ SYSCALL_DEFINE2(get_cap)(struct tcb *t, sys_arg_t tid, sys_arg_t off) { - UNUSED(t); - capflags_t *c; if (!(c = __get_tcb_caps(tid, off))) - return SYS_RET1(ERR_INVAL); + return_args(t, SYS_RET1(ERR_INVAL)); - return SYS_RET2(OK, get_caps(*c, off)); + return_args(t, SYS_RET2(OK, get_caps(*c, off))); } /** * Clear capabilities. * + * @param t Current tcb. * @param tid Thread ID whose capabilities to clear. * @param off Offset of capability, multiple of \c bits(cap). * @param caps Mask of capabilities to clear. @@ -79,12 +80,12 @@ SYSCALL_DEFINE3(clear_cap)(struct tcb *t, sys_arg_t tid, sys_arg_t off, sys_arg_t caps) { if (!is_set(t->caps, CAP_CAPS)) - return SYS_RET1(ERR_PERM); + return_args(t, SYS_RET1(ERR_PERM)); capflags_t *c; if (!(c = __get_tcb_caps(tid, off))) - return SYS_RET1(ERR_INVAL); + return_args(t, SYS_RET1(ERR_INVAL)); clear_caps(*c, off, caps); - return SYS_RET1(OK); + return_args(t, SYS_RET1(OK)); } diff --git a/common/uapi/conf.c b/common/uapi/conf.c index c405e2e..b3ac693 100644 --- a/common/uapi/conf.c +++ b/common/uapi/conf.c @@ -13,6 +13,8 @@ #include #include +#include + /** \todo stack size should really be set on a per-thread basis, and are the * conf*-syscalls even necessary? */ size_t __thread_stack_size = SZ_2M; @@ -32,13 +34,14 @@ enum conf_param { * * \todo Implement parameters. * + * @param t Current tcb. * @param param Parameter to read. * @return \ref OK and parameter value. */ SYSCALL_DEFINE1(conf_get)(struct tcb *t, sys_arg_t param) { if (!has_cap(t->caps, CAP_CONF)) - return SYS_RET1(ERR_PERM); + return_args(t, SYS_RET1(ERR_PERM)); long val = 0; switch (param) { @@ -55,10 +58,10 @@ SYSCALL_DEFINE1(conf_get)(struct tcb *t, sys_arg_t param) break; default: - return SYS_RET1(ERR_NF); + return_args(t, SYS_RET1(ERR_NF)); } - return SYS_RET2(OK, val); + return_args(t, SYS_RET2(OK, val)); } /** @@ -66,6 +69,7 @@ SYSCALL_DEFINE1(conf_get)(struct tcb *t, sys_arg_t param) * * \todo Implement parameters. * + * @param t Current tcb. * @param param Parameter to write. * @param val Value to set \c param to. * @return \ref OK and \c 0. @@ -73,7 +77,7 @@ SYSCALL_DEFINE1(conf_get)(struct tcb *t, sys_arg_t param) SYSCALL_DEFINE2(conf_set)(struct tcb *t, sys_arg_t param, sys_arg_t val) { if (!has_cap(t->caps, CAP_CONF)) - return SYS_RET1(ERR_PERM); + return_args(t, SYS_RET1(ERR_PERM)); size_t size = 0; switch (param) { @@ -84,7 +88,7 @@ SYSCALL_DEFINE2(conf_set)(struct tcb *t, sys_arg_t param, sys_arg_t val) case CONF_CALL_STACK: size = align_up(val, RPC_STACK_RATIO * BASE_PAGE_SIZE); if (size < __rpc_stack_size * RPC_STACK_RATIO) - return SYS_RET1(ERR_MISC); + return_args(t, SYS_RET1(ERR_MISC)); __call_stack_size = size; break; @@ -92,18 +96,19 @@ SYSCALL_DEFINE2(conf_set)(struct tcb *t, sys_arg_t param, sys_arg_t val) case CONF_RPC_STACK: size = align_up(val, BASE_PAGE_SIZE); if (size > __call_stack_size / RPC_STACK_RATIO) - return SYS_RET1(ERR_MISC); + return_args(t, SYS_RET1(ERR_MISC)); __rpc_stack_size = size; break; } - return SYS_RET1(OK); + return_args(t, SYS_RET1(OK)); } /** * Poweroff syscall handler. * + * @param t Current tcb. * @param type Type of poweroff. * @return \ref ERR_INVAL and \c 0 if incorrect poweroff \c type give, otherwise * does not return. @@ -111,14 +116,14 @@ SYSCALL_DEFINE2(conf_set)(struct tcb *t, sys_arg_t param, sys_arg_t val) SYSCALL_DEFINE1(poweroff)(struct tcb *t, sys_arg_t type) { if (!(has_cap(t->caps, CAP_POWER))) - return SYS_RET1(ERR_PERM); + return_args(t, SYS_RET1(ERR_PERM)); switch (type) { case SHUTDOWN: case COLD_REBOOT: case WARM_REBOOT: - return SYS_RET2(OK, poweroff(type)); + return_args(t, SYS_RET2(OK, poweroff(type))); }; - return SYS_RET1(ERR_INVAL); + return_args(t, SYS_RET1(ERR_INVAL)); } diff --git a/common/uapi/dispatch.c b/common/uapi/dispatch.c index 37b551a..aa63170 100644 --- a/common/uapi/dispatch.c +++ b/common/uapi/dispatch.c @@ -10,126 +10,78 @@ #include #include -#include - -/** Syscall number to syscall handler conversion. */ -static const sys_t syscall_table[] = { - /* noop */ - [SYS_NOOP] = sys_noop, - - /* debugging */ - [SYS_PUTCH] = sys_putch, - - /* mem */ - [SYS_REQ_MEM] = sys_req_mem, - [SYS_REQ_PMEM] = sys_req_pmem, - [SYS_REQ_FIXMEM] = sys_req_fixmem, - [SYS_FREE_MEM] = sys_free_mem, - - /* timers */ - [SYS_TIMEBASE] = sys_timebase, - [SYS_TICKS] = sys_ticks, - [SYS_REQ_REL_TIMER] = sys_req_rel_timer, - [SYS_REQ_ABS_TIMER] = sys_req_abs_timer, - [SYS_FREE_TIMER] = sys_free_timer, - - /* ipc */ - [SYS_IPC_SERVER] = sys_ipc_server, - [SYS_IPC_REQ] = sys_ipc_req, - [SYS_IPC_FWD] = sys_ipc_fwd, - [SYS_IPC_RESP] = sys_ipc_resp, - [SYS_IPC_NOTIFY] = sys_ipc_notify, - - /* proc */ - [SYS_CREATE] = sys_create, - [SYS_FORK] = sys_fork, - [SYS_EXEC] = sys_exec, - [SYS_SPAWN] = sys_spawn, - [SYS_SWAP] = sys_swap, - - /* conf */ - [SYS_CONF_SET] = sys_conf_set, - [SYS_CONF_GET] = sys_conf_get, - - [SYS_SET_CAP] = sys_set_cap, - [SYS_GET_CAP] = sys_get_cap, - [SYS_CLEAR_CAP] = sys_clear_cap, - - [SYS_POWEROFF] = sys_poweroff, -}; +/* not sure why doxygen requires these two definitions to state their return + * values, when they don't actually return anything but eh */ /** * Noop syscall handler. * + * @param t Current tcb. + * * @return \ref OK and \c 0. */ SYSCALL_DEFINE0(noop)(struct tcb *t) { - UNUSED(t); info("sys_noop\n"); - return SYS_RET1(OK); + set_args(t, SYS_RET1(OK)); } /** * Putch syscall handler. * + * @param t Current tcb. * @param a Character to put. + * * @return \ref OK and 0. */ SYSCALL_DEFINE1(putch)(struct tcb *t, sys_arg_t a) { - UNUSED(t); - const char c[2] = {a, 0}; MAYBE_UNUSED(c); dbg((const char *)&c); - return SYS_RET1(OK); + set_args(t, SYS_RET1(OK)); } -struct sys_ret handle_syscall(struct tcb *t, - sys_arg_t syscall, sys_arg_t a, sys_arg_t b, - sys_arg_t c, sys_arg_t d, sys_arg_t e) +void handle_syscall(sys_arg_t syscall, sys_arg_t a, sys_arg_t b, + sys_arg_t c, sys_arg_t d, sys_arg_t e, struct tcb *t) { adjust_syscall(t); - struct sys_ret r; switch (syscall) { - case SYS_NOOP: r = sys_noop(t, a, b, c, d, e); break; - case SYS_PUTCH: r = sys_putch(t, a, b, c, d, e); break; - case SYS_REQ_MEM: r = sys_req_mem(t, a, b, c, d, e); break; - case SYS_REQ_PMEM: r = sys_req_pmem(t, a, b, c, d, e); break; - case SYS_REQ_FIXMEM: r = sys_req_fixmem(t, a, b, c, d, e); break; - case SYS_FREE_MEM: r = sys_free_mem(t, a, b, c, d, e); break; - case SYS_TIMEBASE: r = sys_timebase(t, a, b, c, d, e); break; - case SYS_TICKS: r = sys_ticks(t, a, b, c, d, e); break; - case SYS_REQ_REL_TIMER: r = sys_req_rel_timer(t, a, b, c, d, e); break; - case SYS_REQ_ABS_TIMER: r = sys_req_abs_timer(t, a, b, c, d, e); break; - case SYS_IPC_SERVER: r = sys_ipc_server(t, a, b, c, d, e); break; - case SYS_IPC_REQ: r = sys_ipc_req(t, a, b, c, d, e); break; - case SYS_IPC_FWD: r = sys_ipc_fwd(t, a, b, c, d, e); break; - case SYS_IPC_RESP: r = sys_ipc_resp(t, a, b, c, d, e); break; - case SYS_IPC_NOTIFY: r = sys_ipc_notify(t, a, b, c, d, e); break; - case SYS_CREATE: r = sys_create(t, a, b, c, d, e); break; - case SYS_FORK: r = sys_fork(t, a, b, c, d, e); break; - case SYS_EXEC: r = sys_exec(t, a, b, c, d, e); break; - case SYS_SPAWN: r = sys_spawn(t, a, b, c, d, e); break; - case SYS_KILL: r = sys_kill(t, a, b, c, d, e); break; - case SYS_SWAP: r = sys_swap(t, a, b, c, d, e); break; - case SYS_CONF_SET: r = sys_conf_set(t, a, b, c, d, e); break; - case SYS_CONF_GET: r = sys_conf_get(t, a, b, c, d, e); break; - case SYS_SET_CAP: r = sys_set_cap(t, a, b, c, d, e); break; - case SYS_GET_CAP: r = sys_get_cap(t, a, b, c, d, e); break; - case SYS_CLEAR_CAP: r = sys_clear_cap(t, a, b, c, d, e); break; - case SYS_POWEROFF: r = sys_poweroff(t, a, b, c, d, e); break; + case SYS_NOOP: sys_noop(t, a, b, c, d, e); break; + case SYS_PUTCH: sys_putch(t, a, b, c, d, e); break; + case SYS_REQ_MEM: sys_req_mem(t, a, b, c, d, e); break; + case SYS_REQ_PMEM: sys_req_pmem(t, a, b, c, d, e); break; + case SYS_REQ_FIXMEM: sys_req_fixmem(t, a, b, c, d, e); break; + case SYS_FREE_MEM: sys_free_mem(t, a, b, c, d, e); break; + case SYS_TIMEBASE: sys_timebase(t, a, b, c, d, e); break; + case SYS_TICKS: sys_ticks(t, a, b, c, d, e); break; + case SYS_REQ_REL_TIMER: sys_req_rel_timer(t, a, b, c, d, e); break; + case SYS_REQ_ABS_TIMER: sys_req_abs_timer(t, a, b, c, d, e); break; + case SYS_IPC_SERVER: sys_ipc_server(t, a, b, c, d, e); break; + case SYS_IPC_REQ: sys_ipc_req(t, a, b, c, d, e); break; + case SYS_IPC_FWD: sys_ipc_fwd(t, a, b, c, d, e); break; + case SYS_IPC_RESP: sys_ipc_resp(t, a, b, c, d, e); break; + case SYS_IPC_NOTIFY: sys_ipc_notify(t, a, b, c, d, e); break; + case SYS_CREATE: sys_create(t, a, b, c, d, e); break; + case SYS_FORK: sys_fork(t, a, b, c, d, e); break; + case SYS_EXEC: sys_exec(t, a, b, c, d, e); break; + case SYS_SPAWN: sys_spawn(t, a, b, c, d, e); break; + case SYS_KILL: sys_kill(t, a, b, c, d, e); break; + case SYS_SWAP: sys_swap(t, a, b, c, d, e); break; + case SYS_CONF_SET: sys_conf_set(t, a, b, c, d, e); break; + case SYS_CONF_GET: sys_conf_get(t, a, b, c, d, e); break; + case SYS_SET_CAP: sys_set_cap(t, a, b, c, d, e); break; + case SYS_GET_CAP: sys_get_cap(t, a, b, c, d, e); break; + case SYS_CLEAR_CAP: sys_clear_cap(t, a, b, c, d, e); break; + case SYS_POWEROFF: sys_poweroff(t, a, b, c, d, e); break; default: error("Syscall %zu outside allowed range [0 - %i]\n", syscall, SYS_NUM - 1); - r = SYS_RET1(ERR_INVAL); + set_args(t, SYS_RET1(ERR_INVAL)); }; if (check_canary(t)) { bug("Syscall %zu overwrote stack canary\n", syscall); } - - return r; } diff --git a/common/uapi/ipc.c b/common/uapi/ipc.c index 860ec54..93717e4 100644 --- a/common/uapi/ipc.c +++ b/common/uapi/ipc.c @@ -13,45 +13,51 @@ /** * IPC server notification syscall handler. * + * @param t Current tcb. * @param callback Address of server callback. * @return \ref OK and \c 0. */ SYSCALL_DEFINE1(ipc_server)(struct tcb *t, sys_arg_t callback) { get_cproc(t)->callback = callback; - return SYS_RET1(OK); + return_args(t, SYS_RET1(OK)); } /** * Actual IPC syscall handler. * + * @param t Current tcb. * @param pid Process to request RPC to. * @param d0 IPC argument 0. * @param d1 IPC argument 1. * @param d2 IPC argument 2. * @param d3 IPC argument 3. * @param fwd Whether to forward. - * @return + * + * Returns \ref ERR_OOMEM if there isn't enough IPC stack left, \ref ERR_INVAL + * if the the target process doesn't exist, \ref ERR_NOINIT if the target + * process hasn't defined a callback. Otherwise \ref OK and whatever the target + * process sends back. */ -static struct sys_ret do_ipc(struct tcb *t, - sys_arg_t pid, - sys_arg_t d0, - sys_arg_t d1, - sys_arg_t d2, - sys_arg_t d3, - bool fwd) +static void do_ipc(struct tcb *t, + sys_arg_t pid, + sys_arg_t d0, + sys_arg_t d1, + sys_arg_t d2, + sys_arg_t d3, + bool fwd) { if (!enough_rpc_stack(t)) - return SYS_RET1(ERR_OOMEM); + return_args(t, SYS_RET1(ERR_OOMEM)); struct tcb *r = get_tcb(pid); if (!r) - return SYS_RET1(ERR_INVAL); + return_args(t, SYS_RET1(ERR_INVAL)); r = get_rproc(r); if (!r->callback) - return SYS_RET1(ERR_NOINIT); + return_args(t, SYS_RET1(ERR_NOINIT)); clone_uvmem(r->proc.vmem, t->rpc.vmem); use_vmem(t->rpc.vmem); @@ -65,11 +71,12 @@ static struct sys_ret do_ipc(struct tcb *t, t->pid = r->rid; - return SYS_RET6(OK, t->eid, d0, d1, d2, d3); + return_args(t, SYS_RET6(OK, t->eid, d0, d1, d2, d3)); } /** * IPC request syscall handler. * + * @param t Current tcb. * @param pid Process to request RPC to. * @param d0 IPC argument 0. * @param d1 IPC argument 1. @@ -80,12 +87,13 @@ static struct sys_ret do_ipc(struct tcb *t, SYSCALL_DEFINE5(ipc_req)(struct tcb *t, sys_arg_t pid, sys_arg_t d0, sys_arg_t d1, sys_arg_t d2, sys_arg_t d3) { - return do_ipc(t, pid, d0, d1, d2, d3, false); + do_ipc(t, pid, d0, d1, d2, d3, false); } /** * IPC forwarding syscall handler. * + * @param t Current tcb. * @param pid Process to request RPC to. * @param d0 IPC argument 0. * @param d1 IPC argument 1. @@ -96,12 +104,13 @@ SYSCALL_DEFINE5(ipc_req)(struct tcb *t, sys_arg_t pid, SYSCALL_DEFINE5(ipc_fwd)(struct tcb *t, sys_arg_t pid, sys_arg_t d0, sys_arg_t d1, sys_arg_t d2, sys_arg_t d3) { - return do_ipc(t, pid, d0, d1, d2, d3, true); + do_ipc(t, pid, d0, d1, d2, d3, true); } /** * IPC response syscall handler. * + * @param t Current tcb. * @param d0 IPC return value 0. * @param d1 IPC return value 1. * @param d2 IPC return value 2. @@ -121,7 +130,7 @@ SYSCALL_DEFINE4(ipc_resp)(struct tcb *t, sys_arg_t d0, sys_arg_t d1, else use_vmem(t->proc.vmem); - return SYS_RET6(OK, t->tid, d0, d1, d2, d3); + return_args(t, SYS_RET6(OK, t->tid, d0, d1, d2, d3)); } /** @@ -129,25 +138,26 @@ SYSCALL_DEFINE4(ipc_resp)(struct tcb *t, sys_arg_t d0, sys_arg_t d1, * * \todo Implement. * + * @param t Current tcb. * @param tid Thread ID to notify. * @return \ref OK and 0. */ SYSCALL_DEFINE1(ipc_notify)(struct tcb *t, sys_arg_t tid){ if (!has_cap(t->caps, CAP_CALL)) - return SYS_RET1(ERR_PERM); + return_args(t, SYS_RET1(ERR_PERM)); struct tcb *r = get_tcb(tid); if (r->notify_state == NOTIFY_QUEUED) - return SYS_RET1(OK); + return_args(t, SYS_RET1(OK)); if (r->notify_state == NOTIFY_RUNNING) { t->notify_state = NOTIFY_QUEUED; - return SYS_RET1(OK); + return_args(t, SYS_RET1(OK)); } r->notify_state = NOTIFY_QUEUED; if (running(r)) send_ipi(r); - return SYS_RET1(OK); + return_args(t, SYS_RET1(OK)); } diff --git a/common/uapi/mem.c b/common/uapi/mem.c index 1644a16..1de63f1 100644 --- a/common/uapi/mem.c +++ b/common/uapi/mem.c @@ -15,6 +15,7 @@ /** * Memory request syscall handler. * + * @param t Current tcb. * @param size Minimum size of allocation. * @param flags Flags of allocation. * @return \ref OK and start of allocation when succesful, @@ -25,14 +26,15 @@ SYSCALL_DEFINE2(req_mem)(struct tcb *t, sys_arg_t size, sys_arg_t flags) struct tcb *r = get_cproc(t); vm_t start = 0; if ((start = alloc_uvmem(r, size, flags))) - return SYS_RET1(ERR_OOMEM); + return_args(t, SYS_RET1(ERR_OOMEM)); - return SYS_RET2(OK, start); + return_args(t, SYS_RET2(OK, start)); } /** * Fixed memory request syscall handler. * + * @param t Current tcb. * @param fixed Address which should be included in allocation. * @param size Minimum size of allocation after \c start. * @param flags Flags of allocation. @@ -45,14 +47,15 @@ SYSCALL_DEFINE3(req_fixmem)(struct tcb *t, sys_arg_t fixed, sys_arg_t size, struct tcb *r = get_cproc(t); vm_t start = 0; if ((start = alloc_fixed_uvmem(r, fixed, size, flags))) - return SYS_RET1(ERR_OOMEM); + return_args(t, SYS_RET1(ERR_OOMEM)); - return SYS_RET2(OK, start); + return_args(t, SYS_RET2(OK, start)); } /** * Free memory syscall handler. * + * @param t Current tcb. * @param start Start of allocation to free. * @return \ref OK and \c 0 when succesful, \ref ERR_NF and \c 0 otherwise. */ @@ -68,14 +71,15 @@ SYSCALL_DEFINE1(free_mem)(struct tcb *t, sys_arg_t start) status = free_devmem(r, vm_start); if (status) - return SYS_RET1(ERR_NF); + return_args(t, SYS_RET1(ERR_NF)); - return SYS_RET1(OK); + return_args(t, SYS_RET1(OK)); } /** * Request physical memory syscall handler. * + * @param t Current tcb. * @param paddr Physical address to map. * @param size Minimum size of allocation. * @param flags Flags of allocation. @@ -93,14 +97,15 @@ SYSCALL_DEFINE3(req_pmem)(struct tcb *t, sys_arg_t paddr, sys_arg_t size, struct tcb *r = get_cproc(t); vm_t start = 0; if ((start = alloc_devmem(r, paddr, size, flags))) - return SYS_RET1(ERR_OOMEM); + return_args(t, SYS_RET1(ERR_OOMEM)); - return SYS_RET2(OK, start); + return_args(t, SYS_RET2(OK, start)); } /** * Request shared memory syscall handler. * + * @param t Current tcb. * @param size Minimum size of allocation. * @param flags Flags of allocation. * @return \ref OK and start of allocation when succesful, @@ -112,14 +117,15 @@ SYSCALL_DEFINE2(req_sharedmem)(struct tcb *t, sys_arg_t size, sys_arg_t flags) struct tcb *r = get_cproc(t); vm_t start = 0; if ((start = alloc_shared_uvmem(r, size, flags))) - return SYS_RET1(ERR_OOMEM); + return_args(t, SYS_RET1(ERR_OOMEM)); - return SYS_RET2(OK, start); + return_args(t, SYS_RET2(OK, start)); } /** * Reference shared memory syscall handler. * + * @param t Current tcb. * @param tid Thread ID of shared memory owner. * @param va Start of shared memory in \c tid. * @param flags Flags of reference. @@ -132,9 +138,9 @@ SYSCALL_DEFINE3(ref_sharedmem)(struct tcb *t, sys_arg_t tid, sys_arg_t va, struct tcb *t2 = get_tcb(tid); vm_t start = 0; if ((start = ref_shared_uvmem(t, t2, va, flags))) - return SYS_RET1(ERR_OOMEM); + return_args(t, SYS_RET1(ERR_OOMEM)); - return SYS_RET2(OK, start); + return_args(t, SYS_RET2(OK, start)); } /** \todo add some way to specify who gets to access the shared memory? */ diff --git a/common/uapi/proc.c b/common/uapi/proc.c index 2ce3382..607f028 100644 --- a/common/uapi/proc.c +++ b/common/uapi/proc.c @@ -12,11 +12,10 @@ #include #include -#include - /** * Create syscall handler. * + * @param t Current tcb. * @param func Function to jump to at thread creation. * @param d0 Argument 0. * @param d1 Argument 1. @@ -31,14 +30,14 @@ SYSCALL_DEFINE5(create)(struct tcb *t, sys_arg_t func, { struct tcb *c = create_thread(t); if (!c) - return SYS_RET1(ERR_OOMEM); + return_args(t, SYS_RET1(ERR_OOMEM)); alloc_stack(c); set_args(c, SYS_RET5(c->tid, d0, d1, d2, d3)); set_return(c, func); - return SYS_RET2(OK, c->tid); + return_args(t, SYS_RET2(OK, c->tid)); } /** @@ -54,30 +53,33 @@ SYSCALL_DEFINE5(create)(struct tcb *t, sys_arg_t func, * would have to periodically ask the kernel about all threads it is aware of * via sys_sync. Dunno. * + * @param t Current tcb. * @return \ref OK and 0. */ SYSCALL_DEFINE0(fork)(struct tcb *t) { struct tcb *c = get_cproc(t); if (!(has_cap(c->caps, CAP_PROC))) - return SYS_RET1(ERR_PERM); + return_args(t, SYS_RET1(ERR_PERM)); struct tcb *n = create_proc(get_eproc(t)); if (!n) - return SYS_RET1(ERR_OOMEM); + return_args(t, SYS_RET1(ERR_OOMEM)); /* prepare args for when we eventually swap to the new proc, giving * parent ID as third return value */ set_args(n, SYS_RET3(OK, 0, n->pid)); - return SYS_RET2(OK, n->pid); + return_args(t, SYS_RET2(OK, n->pid)); } /** * Exec syscall handler. * + * @param t Current tcb. * @param bin Binary to execute. * @param interp Optional interpreter binary. + * * @return \see prepare_proc(). */ SYSCALL_DEFINE2(exec)(struct tcb *t, sys_arg_t bin, sys_arg_t interp) @@ -86,7 +88,7 @@ SYSCALL_DEFINE2(exec)(struct tcb *t, sys_arg_t bin, sys_arg_t interp) /* mark binary to be kept */ struct mem_region *b = find_used_region(&t->sp_r, bin); if (!b) - return SYS_RET1(ERR_INVAL); + return_args(t, SYS_RET1(ERR_INVAL)); set_bit(b->flags, MR_KEEP); @@ -95,7 +97,7 @@ SYSCALL_DEFINE2(exec)(struct tcb *t, sys_arg_t bin, sys_arg_t interp) /* mark interpreter to be kept */ i = find_used_region(&t->sp_r, interp); if (!i) - return SYS_RET1(ERR_INVAL); + return_args(t, SYS_RET1(ERR_INVAL)); set_bit(i->flags, MR_KEEP); } @@ -108,32 +110,35 @@ SYSCALL_DEFINE2(exec)(struct tcb *t, sys_arg_t bin, sys_arg_t interp) if (interp) clear_bit(b->flags, MR_KEEP); - return SYS_RET1(prepare_proc(t, bin, interp)); + return_args(t, SYS_RET1(prepare_proc(t, bin, interp))); } /** * Spawn syscall handler. * + * @param t Current tcb. * @param bin Binary to execute. * @param interp Optional interpreter binary. + * * @return \see prepare_proc() and process id of the new process. */ SYSCALL_DEFINE2(spawn)(struct tcb *t, sys_arg_t bin, sys_arg_t interp) { struct tcb *c = get_proc(t); if (!(has_cap(c->caps, CAP_PROC))) - return SYS_RET1(ERR_PERM); + return_args(t, SYS_RET1(ERR_PERM)); struct tcb *n = create_proc(NULL); if (!n) - return SYS_RET1(ERR_OOMEM); + return_args(t, SYS_RET1(ERR_OOMEM)); - return SYS_RET2(prepare_proc(n, bin, interp), n->pid); + return_args(t, SYS_RET2(prepare_proc(n, bin, interp), n->pid)); } /** * Kill syscall handler. * + * @param t Current tcb. * @param tid Thread to kill. * \todo Implement. * @@ -143,11 +148,11 @@ SYSCALL_DEFINE1(kill)(struct tcb *t, sys_arg_t tid) { struct tcb *c = get_cproc(t); if (!(has_cap(c->caps, CAP_PROC))) - return SYS_RET1(ERR_PERM); + return_args(t, SYS_RET1(ERR_PERM)); /** @todo implement */ - return SYS_RET1(OK); + return_args(t, SYS_RET1(OK)); } /** @@ -157,17 +162,19 @@ SYSCALL_DEFINE1(kill)(struct tcb *t, sys_arg_t tid) * \todo Should swap return the registers of the new thread that would be used * for message passing? * + * @param t Current tcb. * @param tid Thread ID to swap to. + * * @return \ref OK. */ SYSCALL_DEFINE1(swap)(struct tcb *t, sys_arg_t tid){ struct tcb *c = get_cproc(t); if (!(has_cap(c->caps, CAP_PROC))) - return SYS_RET1(ERR_PERM); + return_args(t, SYS_RET1(ERR_PERM)); struct tcb *s = get_tcb(tid); if (!s) - return SYS_RET1(ERR_INVAL); + return_args(t, SYS_RET1(ERR_INVAL)); /* switch over to new thread */ use_tcb(s); @@ -176,5 +183,5 @@ SYSCALL_DEFINE1(swap)(struct tcb *t, sys_arg_t tid){ set_args(t, SYS_RET1(OK)); /* get register state for new thread */ - return get_args(s); + return_args(t, get_args(s)); } diff --git a/common/uapi/timers.c b/common/uapi/timers.c index b7c0ddd..929b630 100644 --- a/common/uapi/timers.c +++ b/common/uapi/timers.c @@ -35,18 +35,17 @@ static ticks_t scaled_ticks(sys_arg_t ticks, sys_arg_t mult) /** * Timebase syscall handler. * + * @param t Current tcb. * @return \ref OK and timebase in second argument if 64bit, otherwise high 32 * bits of timebase in second argument and low 32 bits in third argument. */ SYSCALL_DEFINE0(timebase)(struct tcb *t) { - UNUSED(t); - ticks_t tm = secs_to_ticks(1); #if defined(_LP64) - return SYS_RET2(OK, tm); + return_args(t, SYS_RET2(OK, tm)); #else - return SYS_RET3(OK, tm >> 32, tm); + return_args(t, SYS_RET3(OK, tm >> 32, tm)); #endif } @@ -57,18 +56,17 @@ SYSCALL_DEFINE0(timebase)(struct tcb *t) * should be preferred over this syscall on such platforms. Still, for * completeness sake. * + * @param t Current tcb. * @return \ref OK and the current ticks when on 64bit systems, otherwise high * 32 bits of ticks in second argument and low 32 bits in third. */ SYSCALL_DEFINE0(ticks)(struct tcb *t) { - UNUSED(t); - ticks_t tm = current_ticks(); #if defined(_LP64) - return SYS_RET2(OK, tm); + return_args(t, SYS_RET2(OK, tm)); #else - return SYS_RET3(OK, tm >> 32, tm); + return_args(t, SYS_RET3(OK, tm >> 32, tm)); #endif } @@ -79,18 +77,22 @@ SYSCALL_DEFINE0(ticks)(struct tcb *t) * enough to contain essentially any timepoint we want. A couple thousand years * when the clock runs at 5GHz, if I'm not completely mistaken. * + * @param t Current tcb. * @param ticks Number of ticks from now. * @param mult Multiply \c ticks by this value. * @return \ref OK and \c cid of created timer. */ SYSCALL_DEFINE2(req_rel_timer)(struct tcb *t, sys_arg_t ticks, sys_arg_t mult) { - return SYS_RET2(OK, new_rel_timer(t->tid, scaled_ticks(ticks, mult))); + return_args(t, + SYS_RET2(OK, + new_rel_timer(t->tid, scaled_ticks(ticks, mult)))); } /** * Absolute timer request syscall handler. * + * @param t Current tcb. * @param ticks Absolute timepoint relative to some start point defined at boot. * @param mult Multiply \c ticks by this value. * @return \ref OK and \c cid of created timer. @@ -98,24 +100,25 @@ SYSCALL_DEFINE2(req_rel_timer)(struct tcb *t, sys_arg_t ticks, sys_arg_t mult) */ SYSCALL_DEFINE2(req_abs_timer)(struct tcb *t, sys_arg_t ticks, sys_arg_t mult) { - return SYS_RET2(OK, new_abs_timer(t->tid, scaled_ticks(ticks, mult))); + return_args(t, + SYS_RET2(OK, + new_abs_timer(t->tid, scaled_ticks(ticks, mult)))); } /** * Free timer request syscall handler. * + * @param t Current tcb. * @param cid \c cid of timer to free. * @return \ref ERR_NF and \c 0if no timer could be found with \c cid, \ref OK * and 0 otherwise. */ SYSCALL_DEFINE1(free_timer)(struct tcb *t, sys_arg_t cid) { - UNUSED(t); - struct timer *timer = find_timer(cid); if (!timer) - return SYS_RET1(ERR_NF); + return_args(t, SYS_RET1(ERR_NF)); remove_timer(timer); - return SYS_RET1(OK); + return_args(t, SYS_RET1(OK)); } -- cgit v1.3