possible optimisations

8 files changed, 144 insertions, 119 deletions

diff --git a/common/pmem.c b/common/pmem.c
index b8a453a..a245f43 100644
--- a/common/pmem.c
+++ b/common/pmem.c
@@ -622,9 +622,10 @@ void init_pmem(void *fdt)
 	size_t probe_size = probe_pmap(ram_size);
 	size_t actual_size = populate_pmap(ram_base, ram_size, pmap_base);
 
-	if (probe_size != actual_size)
+	if (probe_size != actual_size) {
 		bug("probe_size (%#lx) != actual_size (%#lx)\n", probe_size,
 		    actual_size);
+	}
 
 	/* mark init stack, this should be unmapped once we get to executing
 	 * processes */
diff --git a/common/uapi/cap.c b/common/uapi/cap.c
index 3495960..9433b2d 100644
--- a/common/uapi/cap.c
+++ b/common/uapi/cap.c
@@ -34,9 +34,8 @@ static capflags_t *__get_tcb_caps(id_t tid, size_t off)
  * @param caps Mask of capabilities to set.
  * @return \ref OK on success, \ref ERR_INVAL on invalid input.
  */
-SYSCALL_DEFINE3(set_cap)(sys_arg_t tid, sys_arg_t off, sys_arg_t caps)
+SYSCALL_DEFINE3(set_cap)(struct tcb *t, sys_arg_t tid, sys_arg_t off, sys_arg_t caps)
 {
-	struct tcb *t = cur_tcb();
 	if (!is_set(t->caps, CAP_CAPS))
 		return SYS_RET1(ERR_PERM);
 
@@ -55,8 +54,10 @@ SYSCALL_DEFINE3(set_cap)(sys_arg_t tid, sys_arg_t off, sys_arg_t caps)
  * @param off Offset of capability, multiple of \c bits(cap).
  * @return \ref OK, capabilities.
  */
-SYSCALL_DEFINE2(get_cap)(sys_arg_t tid, sys_arg_t off)
+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);
@@ -73,9 +74,8 @@ SYSCALL_DEFINE2(get_cap)(sys_arg_t tid, sys_arg_t off)
  * @return ERR_LERM if invalid permissions, ERR_INVAL if \p tid doesn't exist,
  * otherwise OK.
  */
-SYSCALL_DEFINE3(clear_cap)(sys_arg_t tid, sys_arg_t off, sys_arg_t caps)
+SYSCALL_DEFINE3(clear_cap)(struct tcb *t, sys_arg_t tid, sys_arg_t off, sys_arg_t caps)
 {
-	struct tcb *t = cur_tcb();
 	if (!is_set(t->caps, CAP_CAPS))
 		return SYS_RET1(ERR_PERM);
 
diff --git a/common/uapi/conf.c b/common/uapi/conf.c
index dcba6a3..c405e2e 100644
--- a/common/uapi/conf.c
+++ b/common/uapi/conf.c
@@ -35,9 +35,8 @@ enum conf_param {
  * @param param Parameter to read.
  * @return \ref OK and parameter value.
  */
-SYSCALL_DEFINE1(conf_get)(sys_arg_t param)
+SYSCALL_DEFINE1(conf_get)(struct tcb *t, sys_arg_t param)
 {
-	struct tcb *t = cur_tcb();
 	if (!has_cap(t->caps, CAP_CONF))
 		return SYS_RET1(ERR_PERM);
 
@@ -71,9 +70,8 @@ SYSCALL_DEFINE1(conf_get)(sys_arg_t param)
  * @param val Value to set \c param to.
  * @return \ref OK and \c 0.
  */
-SYSCALL_DEFINE2(conf_set)(sys_arg_t param, sys_arg_t val)
+SYSCALL_DEFINE2(conf_set)(struct tcb *t, sys_arg_t param, sys_arg_t val)
 {
-	struct tcb *t = cur_tcb();
 	if (!has_cap(t->caps, CAP_CONF))
 		return SYS_RET1(ERR_PERM);
 
@@ -110,9 +108,8 @@ SYSCALL_DEFINE2(conf_set)(sys_arg_t param, sys_arg_t val)
  * @return \ref ERR_INVAL and \c 0 if incorrect poweroff \c type give, otherwise
  * does not return.
  */
-SYSCALL_DEFINE1(poweroff)(sys_arg_t type)
+SYSCALL_DEFINE1(poweroff)(struct tcb *t, sys_arg_t type)
 {
-	struct tcb *t = cur_tcb();
 	if (!(has_cap(t->caps, CAP_POWER)))
 		return SYS_RET1(ERR_PERM);
 
diff --git a/common/uapi/dispatch.c b/common/uapi/dispatch.c
index 2cf19fb..30f29b3 100644
--- a/common/uapi/dispatch.c
+++ b/common/uapi/dispatch.c
@@ -63,7 +63,9 @@ static const sys_t syscall_table[] = {
  *
  * @return \ref OK and \c 0.
  */
-SYSCALL_DEFINE0(noop)(){
+SYSCALL_DEFINE0(noop)(struct tcb *t)
+{
+	UNUSED(t);
 	info("sys_noop\n");
 	return SYS_RET1(OK);
 }
@@ -74,7 +76,10 @@ SYSCALL_DEFINE0(noop)(){
  * @param a Character to put.
  * @return \ref OK and 0.
  */
-SYSCALL_DEFINE1(putch)(sys_arg_t a){
+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);
@@ -82,31 +87,48 @@ SYSCALL_DEFINE1(putch)(sys_arg_t a){
 }
 
 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)
+		sys_arg_t syscall, sys_arg_t a, sys_arg_t b,
+		sys_arg_t c, sys_arg_t d, sys_arg_t e)
 {
 	adjust_syscall(t);
 
-	size_t sc = syscall;
-	if (sc >= ARRAY_SIZE(syscall_table)) {
-		error("Syscall %zu outside allowed range [0 - %zu]\n", sc,
-		      ARRAY_SIZE(syscall_table));
-		return SYS_RET1(ERR_INVAL);
-	}
-
-	sys_t call = syscall_table[sc];
-	if (!call) {
-		error("Syscall %zu not legitimate value\n", sc);
-		return SYS_RET1(ERR_INVAL);
-	}
-
-	struct sys_ret r = call(a, b, c, d, e);
+	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;
+	default:
+			   error("Syscall %zu outside allowed range [0 - %i]\n", syscall,
+					   SYS_NUM - 1);
+			   r = SYS_RET1(ERR_INVAL);
+	};
 
 	if (check_canary(t)) {
 		bug("Syscall %zu overwrote stack canary\n", syscall);
-		/** @todo should probably halt, as the system is likely in an
-		 * unstable state. */
-		return SYS_RET1(ERR_INT);
 	}
 
 	return r;
diff --git a/common/uapi/ipc.c b/common/uapi/ipc.c
index 5d91588..80d4906 100644
--- a/common/uapi/ipc.c
+++ b/common/uapi/ipc.c
@@ -16,9 +16,9 @@
  * @param callback Address of server callback.
  * @return \ref OK and \c 0.
  */
-SYSCALL_DEFINE1(ipc_server)(sys_arg_t callback)
+SYSCALL_DEFINE1(ipc_server)(struct tcb *t, sys_arg_t callback)
 {
-	cur_proc()->callback = callback;
+	get_cproc(t)->callback = callback;
 	return SYS_RET1(OK);
 }
 
@@ -33,14 +33,14 @@ SYSCALL_DEFINE1(ipc_server)(sys_arg_t callback)
  * @param fwd Whether to forward.
  * @return
  */
-static struct sys_ret do_ipc(sys_arg_t pid,
+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)
 {
-	struct tcb *t = cur_tcb();
 	if (!enough_rpc_stack(t))
 		return SYS_RET1(ERR_OOMEM);
 
@@ -77,10 +77,10 @@ static struct sys_ret do_ipc(sys_arg_t pid,
  * @param d3 IPC argument 3.
  * @return When succesful: OK, thread id of the caller and the arguments as-is.
  */
-SYSCALL_DEFINE5(ipc_req)(sys_arg_t pid,
+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(pid, d0, d1, d2, d3, false);
+	return do_ipc(t, pid, d0, d1, d2, d3, false);
 }
 
 /**
@@ -93,10 +93,10 @@ SYSCALL_DEFINE5(ipc_req)(sys_arg_t pid,
  * @param d3 IPC argument 3.
  * @return
  */
-SYSCALL_DEFINE5(ipc_fwd)(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(pid, d0, d1, d2, d3, true);
+	return do_ipc(t, pid, d0, d1, d2, d3, true);
 }
 
 /**
@@ -108,11 +108,10 @@ SYSCALL_DEFINE5(ipc_fwd)(sys_arg_t pid,
  * @param d3 IPC return value 3.
  * @return \c d0 and \c d1.
  */
-SYSCALL_DEFINE4(ipc_resp)(sys_arg_t d0, sys_arg_t d1, sys_arg_t d2,
+SYSCALL_DEFINE4(ipc_resp)(struct tcb *t, sys_arg_t d0, sys_arg_t d1, sys_arg_t d2,
                           sys_arg_t d3)
 {
-	struct tcb *t = cur_tcb();
-	struct tcb *r = cur_proc();
+	struct tcb *r = get_cproc(t);
 	load_context(t);
 	detach_rpc(r, t);
 
@@ -132,19 +131,22 @@ SYSCALL_DEFINE4(ipc_resp)(sys_arg_t d0, sys_arg_t d1, sys_arg_t d2,
  * @param tid Thread ID to notify.
  * @return \ref OK and 0.
  */
-SYSCALL_DEFINE1(ipc_notify)(sys_arg_t tid){
-	struct tcb *t = get_tcb(tid);
-	if (t->notify_state == NOTIFY_QUEUED)
+SYSCALL_DEFINE1(ipc_notify)(struct tcb *t, sys_arg_t tid){
+	if (!has_cap(t->caps, CAP_CALL))
+		return SYS_RET1(ERR_PERM);
+
+	struct tcb *r = get_tcb(tid);
+	if (r->notify_state == NOTIFY_QUEUED)
 		return SYS_RET1(OK);
 
-	if (t->notify_state == NOTIFY_RUNNING) {
+	if (r->notify_state == NOTIFY_RUNNING) {
 		t->notify_state = NOTIFY_QUEUED;
 		return SYS_RET1(OK);
 	}
 
-	t->notify_state = NOTIFY_QUEUED;
-	if (running(t))
-		send_ipi(t);
+	r->notify_state = NOTIFY_QUEUED;
+	if (running(r))
+		send_ipi(r);
 
 	return SYS_RET1(OK);
 }
diff --git a/common/uapi/mem.c b/common/uapi/mem.c
index 599c971..fccb0f7 100644
--- a/common/uapi/mem.c
+++ b/common/uapi/mem.c
@@ -20,10 +20,9 @@
  * @return \ref OK and start of allocation when succesful,
  * \ref ERR_OOMEM and \c NULL otherwise.
  */
-SYSCALL_DEFINE2(req_mem)(sys_arg_t size, sys_arg_t flags)
+SYSCALL_DEFINE2(req_mem)(struct tcb *t, sys_arg_t size, sys_arg_t flags)
 {
-	/* get current effective process */
-	struct tcb *r = cur_proc();
+	struct tcb *r = get_cproc(t);
 	vm_t start = 0;
 	if ((start = alloc_uvmem(r, size, flags)))
 		return SYS_RET1(ERR_OOMEM);
@@ -40,9 +39,9 @@ SYSCALL_DEFINE2(req_mem)(sys_arg_t size, sys_arg_t flags)
  * @return \ref OK and start of allocation when succesful,
  * \ref ERR_OOMEM and \c NULL otherwise.
  */
-SYSCALL_DEFINE3(req_fixmem)(sys_arg_t fixed, sys_arg_t size, sys_arg_t flags)
+SYSCALL_DEFINE3(req_fixmem)(struct tcb *t, sys_arg_t fixed, sys_arg_t size, sys_arg_t flags)
 {
-	struct tcb *r = cur_proc();
+	struct tcb *r = get_cproc(t);
 	vm_t start = 0;
 	if ((start = alloc_fixed_uvmem(r, fixed, size, flags)))
 		return SYS_RET1(ERR_OOMEM);
@@ -56,9 +55,9 @@ SYSCALL_DEFINE3(req_fixmem)(sys_arg_t fixed, sys_arg_t size, sys_arg_t flags)
  * @param start Start of allocation to free.
  * @return \ref OK and \c 0 when succesful, \ref ERR_NF and \c 0 otherwise.
  */
-SYSCALL_DEFINE1(free_mem)(sys_arg_t start)
+SYSCALL_DEFINE1(free_mem)(struct tcb *t, sys_arg_t start)
 {
-	struct tcb *r = cur_proc();
+	struct tcb *r = get_cproc(t);
 	vm_t vm_start = (vm_t)start;
 
 	stat_t status = OK;
@@ -82,14 +81,14 @@ SYSCALL_DEFINE1(free_mem)(sys_arg_t start)
  * @return \ref OK and start of allocation when succesful,
  * \ref ERR_OOMEM and \c NULL otherwise.
  */
-SYSCALL_DEFINE3(req_pmem)(sys_arg_t paddr, sys_arg_t size, sys_arg_t flags)
+SYSCALL_DEFINE3(req_pmem)(struct tcb *t, 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
 	 * outside the RAM area, and I'll probably have to implement some method
 	 * that keeps track of used regions outside of RAM. We'll see.
 	 */
-	struct tcb *r = cur_proc();
+	struct tcb *r = get_cproc(t);
 	vm_t start = 0;
 	if ((start = alloc_devmem(r, paddr, size, flags)))
 		return SYS_RET1(ERR_OOMEM);
@@ -105,12 +104,12 @@ SYSCALL_DEFINE3(req_pmem)(sys_arg_t paddr, sys_arg_t size, sys_arg_t flags)
  * @return \ref OK and start of allocation when succesful,
  * \ref ERR_OOMEM and \c NULL otherwise.
  */
-SYSCALL_DEFINE2(req_sharedmem)(sys_arg_t size, sys_arg_t flags)
+SYSCALL_DEFINE2(req_sharedmem)(struct tcb *t, sys_arg_t size, sys_arg_t flags)
 {
 	/** \todo check that requester is server */
-	struct tcb *t = cur_proc();
+	struct tcb *r = get_cproc(t);
 	vm_t start = 0;
-	if ((start = alloc_shared_uvmem(t, size, flags)))
+	if ((start = alloc_shared_uvmem(r, size, flags)))
 		return SYS_RET1(ERR_OOMEM);
 
 	return SYS_RET2(OK, start);
@@ -125,12 +124,11 @@ SYSCALL_DEFINE2(req_sharedmem)(sys_arg_t size, sys_arg_t flags)
  * @return \ref OK and start of reference when succesful,
  * \ref ERR_OOMEM and \c NULL otherwise.
  */
-SYSCALL_DEFINE3(ref_sharedmem)(sys_arg_t tid, sys_arg_t va, sys_arg_t flags)
+SYSCALL_DEFINE3(ref_sharedmem)(struct tcb *t, sys_arg_t tid, sys_arg_t va, sys_arg_t flags)
 {
-	struct tcb *t1 = cur_tcb();
 	struct tcb *t2 = get_tcb(tid);
 	vm_t start = 0;
-	if ((start = ref_shared_uvmem(t1, t2, va, flags)))
+	if ((start = ref_shared_uvmem(t, t2, va, flags)))
 		return SYS_RET1(ERR_OOMEM);
 
 	return SYS_RET2(OK, start);
diff --git a/common/uapi/proc.c b/common/uapi/proc.c
index 7a078da..2ce3382 100644
--- a/common/uapi/proc.c
+++ b/common/uapi/proc.c
@@ -26,18 +26,19 @@
  * @return ERR_OOMEM if thread creation was unsuccessful, otherwise OK and the
  * thread id.
  */
-SYSCALL_DEFINE5(create)(sys_arg_t func,
-                        sys_arg_t d0, sys_arg_t d1, sys_arg_t d2, sys_arg_t d3){
-	struct tcb *t = create_thread(cur_tcb());
-	if (!t)
+SYSCALL_DEFINE5(create)(struct tcb *t, sys_arg_t func,
+                        sys_arg_t d0, sys_arg_t d1, sys_arg_t d2, sys_arg_t d3)
+{
+	struct tcb *c = create_thread(t);
+	if (!c)
 		return SYS_RET1(ERR_OOMEM);
 
-	alloc_stack(t);
+	alloc_stack(c);
 
-	set_args(t, SYS_RET5(t->tid, d0, d1, d2, d3));
-	set_return(t, func);
+	set_args(c, SYS_RET5(c->tid, d0, d1, d2, d3));
+	set_return(c, func);
 
-	return SYS_RET2(OK, t->tid);
+	return SYS_RET2(OK, c->tid);
 }
 
 /**
@@ -55,20 +56,21 @@ SYSCALL_DEFINE5(create)(sys_arg_t func,
  *
  * @return \ref OK and 0.
  */
-SYSCALL_DEFINE0(fork)(){
-	struct tcb *c = cur_proc();
+SYSCALL_DEFINE0(fork)(struct tcb *t)
+{
+	struct tcb *c = get_cproc(t);
 	if (!(has_cap(c->caps, CAP_PROC)))
 		return SYS_RET1(ERR_PERM);
 
-	struct tcb *t = create_proc(eff_proc());
-	if (!t)
+	struct tcb *n = create_proc(get_eproc(t));
+	if (!n)
 		return SYS_RET1(ERR_OOMEM);
 
 	/* prepare args for when we eventually swap to the new proc, giving
 	 * parent ID as third return value */
-	set_args(t, SYS_RET3(OK, 0, c->pid));
+	set_args(n, SYS_RET3(OK, 0, n->pid));
 
-	return SYS_RET2(OK, t->pid);
+	return SYS_RET2(OK, n->pid);
 }
 
 /**
@@ -78,12 +80,11 @@ SYSCALL_DEFINE0(fork)(){
  * @param interp Optional interpreter binary.
  * @return \see prepare_proc().
  */
-SYSCALL_DEFINE2(exec)(sys_arg_t bin, sys_arg_t interp){
-	/** \todo execute new process, probably with more sensible argc passing */
-	struct tcb *r = cur_tcb();
-
+SYSCALL_DEFINE2(exec)(struct tcb *t, sys_arg_t bin, sys_arg_t interp)
+{
+	/** @todo probably make sure thread is root thread of process? */
 	/* mark binary to be kept */
-	struct mem_region *b = find_used_region(&r->sp_r, bin);
+	struct mem_region *b = find_used_region(&t->sp_r, bin);
 	if (!b)
 		return SYS_RET1(ERR_INVAL);
 
@@ -92,7 +93,7 @@ SYSCALL_DEFINE2(exec)(sys_arg_t bin, sys_arg_t interp){
 	struct mem_region *i = 0;
 	if (interp) {
 		/* mark interpreter to be kept */
-		i = find_used_region(&r->sp_r, interp);
+		i = find_used_region(&t->sp_r, interp);
 		if (!i)
 			return SYS_RET1(ERR_INVAL);
 
@@ -100,14 +101,14 @@ SYSCALL_DEFINE2(exec)(sys_arg_t bin, sys_arg_t interp){
 	}
 
 	/* free everything except regions to be kept */
-	clear_uvmem(r);
+	clear_uvmem(t);
 
 	/* restore to normal */
 	clear_bit(b->flags, MR_KEEP);
 	if (interp)
 		clear_bit(b->flags, MR_KEEP);
 
-	return SYS_RET1(prepare_proc(r, bin, interp));
+	return SYS_RET1(prepare_proc(t, bin, interp));
 }
 
 /**
@@ -117,17 +118,17 @@ SYSCALL_DEFINE2(exec)(sys_arg_t bin, sys_arg_t interp){
  * @param interp Optional interpreter binary.
  * @return \see prepare_proc() and process id of the new process.
  */
-SYSCALL_DEFINE2(spawn)(sys_arg_t bin, sys_arg_t interp)
+SYSCALL_DEFINE2(spawn)(struct tcb *t, sys_arg_t bin, sys_arg_t interp)
 {
-	struct tcb *c = cur_proc();
+	struct tcb *c = get_proc(t);
 	if (!(has_cap(c->caps, CAP_PROC)))
 		return SYS_RET1(ERR_PERM);
 
-	struct tcb *t = create_proc(NULL);
-	if (!t)
+	struct tcb *n = create_proc(NULL);
+	if (!n)
 		return SYS_RET1(ERR_OOMEM);
 
-	return SYS_RET2(prepare_proc(t, bin, interp), t->pid);
+	return SYS_RET2(prepare_proc(n, bin, interp), n->pid);
 }
 
 /**
@@ -138,12 +139,14 @@ SYSCALL_DEFINE2(spawn)(sys_arg_t bin, sys_arg_t interp)
  *
  * @return ERR_PERM if not capable to kill, otherwise OK.
  */
-SYSCALL_DEFINE1(kill)(sys_arg_t tid)
+SYSCALL_DEFINE1(kill)(struct tcb *t, sys_arg_t tid)
 {
-	struct tcb *c = cur_proc();
+	struct tcb *c = get_cproc(t);
 	if (!(has_cap(c->caps, CAP_PROC)))
 		return SYS_RET1(ERR_PERM);
 
+	/** @todo implement */
+
 	return SYS_RET1(OK);
 }
 
@@ -157,21 +160,21 @@ SYSCALL_DEFINE1(kill)(sys_arg_t tid)
  * @param tid Thread ID to swap to.
  * @return \ref OK.
  */
-SYSCALL_DEFINE1(swap)(sys_arg_t tid){
-	struct tcb *c = cur_proc();
+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);
 
-	struct tcb *t = get_tcb(tid);
-	if (!t)
+	struct tcb *s = get_tcb(tid);
+	if (!s)
 		return SYS_RET1(ERR_INVAL);
 
 	/* switch over to new thread */
-	use_tcb(t);
+	use_tcb(s);
 
 	/* set return value for current thread */
-	set_args(c, SYS_RET1(OK));
+	set_args(t, SYS_RET1(OK));
 
 	/* get register state for new thread */
-	return get_args(t);
+	return get_args(s);
 }
diff --git a/common/uapi/timers.c b/common/uapi/timers.c
index 80cef1d..b7c0ddd 100644
--- a/common/uapi/timers.c
+++ b/common/uapi/timers.c
@@ -38,13 +38,15 @@ static ticks_t scaled_ticks(sys_arg_t ticks, sys_arg_t mult)
  * @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)()
+SYSCALL_DEFINE0(timebase)(struct tcb *t)
 {
-	ticks_t t = secs_to_ticks(1);
+	UNUSED(t);
+
+	ticks_t tm = secs_to_ticks(1);
 #if defined(_LP64)
-	return SYS_RET2(OK, t);
+	return SYS_RET2(OK, tm);
 #else
-	return SYS_RET3(OK, t >> 32, t);
+	return SYS_RET3(OK, tm >> 32, tm);
 #endif
 }
 
@@ -58,13 +60,15 @@ SYSCALL_DEFINE0(timebase)()
  * @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)()
+SYSCALL_DEFINE0(ticks)(struct tcb *t)
 {
-	ticks_t t = current_ticks();
+	UNUSED(t);
+
+	ticks_t tm = current_ticks();
 #if defined(_LP64)
-	return SYS_RET2(OK, t);
+	return SYS_RET2(OK, tm);
 #else
-	return SYS_RET3(OK, t >> 32, t);
+	return SYS_RET3(OK, tm >> 32, tm);
 #endif
 }
 
@@ -79,11 +83,9 @@ SYSCALL_DEFINE0(ticks)()
  * @param mult Multiply \c ticks by this value.
  * @return \ref OK and \c cid of created timer.
  */
-SYSCALL_DEFINE2(req_rel_timer)(sys_arg_t ticks, sys_arg_t mult)
+SYSCALL_DEFINE2(req_rel_timer)(struct tcb *t, sys_arg_t ticks, sys_arg_t mult)
 {
-	return SYS_RET2(OK,
-	                new_rel_timer(cur_tcb()->tid,
-	                              scaled_ticks(ticks, mult)));
+	return SYS_RET2(OK, new_rel_timer(t->tid, scaled_ticks(ticks, mult)));
 }
 
 /**
@@ -94,11 +96,9 @@ SYSCALL_DEFINE2(req_rel_timer)(sys_arg_t ticks, sys_arg_t mult)
  * @return \ref OK and \c cid of created timer.
  * \see req_rel_timer().
  */
-SYSCALL_DEFINE2(req_abs_timer)(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(cur_tcb()->tid,
-	                              scaled_ticks(ticks, mult)));
+	return SYS_RET2(OK, new_abs_timer(t->tid, scaled_ticks(ticks, mult)));
 }
 
 /**
@@ -108,8 +108,10 @@ SYSCALL_DEFINE2(req_abs_timer)(sys_arg_t ticks, sys_arg_t mult)
  * @return \ref ERR_NF and \c 0if no timer could be found with \c cid, \ref OK
  * and 0 otherwise.
  */
-SYSCALL_DEFINE1(free_timer)(sys_arg_t cid)
+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);