make syscall handlers void

8 files changed, 163 insertions, 176 deletions

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 <apos/uapi.h>
 #include <apos/conf.h>
 
+#include <arch/proc.h>
+
 /** \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 <apos/debug.h>
 #include <apos/uapi.h>
 
-#include <arch/proc.h>
-
-/** 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 <apos/bits.h>
 #include <apos/mem_regions.h>
 
-#include <arch/proc.h>
-
 /**
  * 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));
 }