start working on tests

+ Current setup will likely not last long, just a stopgap until I figure
  out how I want to build each testcase etc.

  Probably dir based, but I'll probably add some scripts that generate
  the build rules for each test case (or binary?). Also, should probably
  put ouput files in a build directory and keep the source clean, but
  again, good enough for now.

  Will have to start implementing more extensive tests, and probably
  come up with some way to compare textual output etc.

9 files changed, 56 insertions, 57 deletions

diff --git a/src/panic.c b/src/panic.c
index 03c0de8..5495ebe 100644
--- a/src/panic.c
+++ b/src/panic.c
@@ -6,6 +6,7 @@
  * Kernel panic handler implementation.
  */
 
+#include <kmi/syscalls.h>
 #include <kmi/power.h>
 #include <kmi/debug.h>
 
@@ -17,7 +18,7 @@ void kernel_panic(void *pc, void *addr, long cause)
 
 	info("attempting to reboot\n");
 
-	poweroff(COLD_REBOOT);
+	poweroff(SYS_COLD_REBOOT);
 
 	/* spin if poweroff failed for some reason */
 	error("reboot failed, spinning in place\n");
diff --git a/src/proc.c b/src/proc.c
index 09dcc5f..5753659 100644
--- a/src/proc.c
+++ b/src/proc.c
@@ -49,7 +49,7 @@ stat_t init_proc(void *fdt, vm_t *proc_fdt, vm_t *proc_initrd)
 	t->notify_id = t->tid;
 
 	/* init process has all capabilities */
-	set_caps(t->caps, 0,
+	set_caps(t->caps,
 	         CAP_CAPS | CAP_PROC | CAP_SIGNAL | CAP_POWER | CAP_NOTIFY |
 	         CAP_SHARED);
 
diff --git a/src/regions.c b/src/regions.c
index 1aa318d..4d82420 100644
--- a/src/regions.c
+++ b/src/regions.c
@@ -7,6 +7,7 @@
  * subsystems.
  */
 
+#include <kmi/syscalls.h>
 #include <kmi/regions.h>
 #include <kmi/assert.h>
 #include <kmi/pmem.h>
diff --git a/src/uapi/cap.c b/src/uapi/cap.c
index 157ef47..050d181 100644
--- a/src/uapi/cap.c
+++ b/src/uapi/cap.c
@@ -11,25 +11,6 @@
  */
 
 /**
- * Check that values are legal for thread ID and offset.
- *
- * @param tid Thread ID of thread whose caps should be fetched.
- * @param off Offset of capabilities.
- * @return Pointer to capabilities of \p tid, \c 0 otherwise.
- */
-static capflags_t *__get_tcb_caps(id_t tid, size_t off)
-{
-	if (!cap_off_ok(off))
-		return NULL;
-
-	struct tcb *t = get_tcb(tid);
-	if (!t)
-		return NULL;
-
-	return &t->caps;
-}
-
-/**
  * Set capabilities.
  *
  * @param t Current tcb.
@@ -38,17 +19,16 @@ 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)(struct tcb *t, sys_arg_t tid, sys_arg_t off,
-                         sys_arg_t caps)
+SYSCALL_DEFINE2(set_cap)(struct tcb *t, sys_arg_t tid, sys_arg_t caps)
 {
 	if (!is_set(t->caps, CAP_CAPS))
 		return_args1(t, ERR_PERM);
 
-	capflags_t *c;
-	if (!(c = __get_tcb_caps(tid, off)))
-		return_args1(t, ERR_INVAL);
+	struct tcb *c = get_tcb(tid);
+	if (!c)
+		return_args1(t, ERR_NF);
 
-	set_caps(*c, off, caps);
+	set_caps(c->caps, caps);
 	return_args1(t, OK);
 }
 
@@ -60,13 +40,13 @@ SYSCALL_DEFINE3(set_cap)(struct tcb *t, sys_arg_t tid, sys_arg_t off,
  * @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)
+SYSCALL_DEFINE1(get_cap)(struct tcb *t, sys_arg_t tid)
 {
-	capflags_t *c;
-	if (!(c = __get_tcb_caps(tid, off)))
-		return_args1(t, ERR_INVAL);
+	struct tcb *c = get_tcb(tid);
+	if (!c)
+		return_args1(t, ERR_NF);
 
-	return_args2(t, OK, get_caps(*c, off));
+	return_args2(t, OK, c->caps);
 }
 
 /**
@@ -74,21 +54,19 @@ SYSCALL_DEFINE2(get_cap)(struct tcb *t, sys_arg_t tid, sys_arg_t off)
  *
  * @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.
  * @return ERR_LERM if invalid permissions, ERR_INVAL if \p tid doesn't exist,
  * otherwise OK.
  */
-SYSCALL_DEFINE3(clear_cap)(struct tcb *t, sys_arg_t tid, sys_arg_t off,
-                           sys_arg_t caps)
+SYSCALL_DEFINE2(clear_cap)(struct tcb *t, sys_arg_t tid, sys_arg_t caps)
 {
 	if (!is_set(t->caps, CAP_CAPS))
 		return_args1(t, ERR_PERM);
 
-	capflags_t *c;
-	if (!(c = __get_tcb_caps(tid, off)))
-		return_args1(t, ERR_INVAL);
+	struct tcb *c = get_tcb(tid);
+	if (!c)
+		return_args1(t, ERR_NF);
 
-	clear_caps(*c, off, caps);
+	clear_caps(c->caps, caps);
 	return_args1(t, OK);
 }
diff --git a/src/uapi/conf.c b/src/uapi/conf.c
index c8ec964..6a801f3 100644
--- a/src/uapi/conf.c
+++ b/src/uapi/conf.c
@@ -45,7 +45,7 @@ size_t rpc_stack_size()
  * @param d0 Optional data argument for parameter.
  * @return \ref OK and parameter value.
  */
-SYSCALL_DEFINE2(conf_get)(struct tcb *t, sys_arg_t param, sys_arg_t d0)
+SYSCALL_DEFINE2(get_conf)(struct tcb *t, sys_arg_t param, sys_arg_t d0)
 {
 	/* anyone can read any current parameter, I don't think they should be
 	 * hidden. */
@@ -93,7 +93,7 @@ SYSCALL_DEFINE2(conf_get)(struct tcb *t, sys_arg_t param, sys_arg_t d0)
  * @param val Value to set \c param to.
  * @return \ref OK and \c 0.
  */
-SYSCALL_DEFINE2(conf_set)(struct tcb *t, sys_arg_t param, sys_arg_t val)
+SYSCALL_DEFINE2(set_conf)(struct tcb *t, sys_arg_t param, sys_arg_t val)
 {
 	if (!has_cap(t->caps, CAP_CONF))
 		return_args1(t, ERR_PERM);
@@ -133,9 +133,9 @@ SYSCALL_DEFINE1(poweroff)(struct tcb *t, sys_arg_t type)
 		return_args1(t, ERR_PERM);
 
 	switch (type) {
-	case SHUTDOWN:
-	case COLD_REBOOT:
-	case WARM_REBOOT:
+	case SYS_SHUTDOWN:
+	case SYS_COLD_REBOOT:
+	case SYS_WARM_REBOOT:
 		return_args1(t, poweroff(type));
 	};
 
diff --git a/src/uapi/dispatch.c b/src/uapi/dispatch.c
index 4135171..bbebd9c 100644
--- a/src/uapi/dispatch.c
+++ b/src/uapi/dispatch.c
@@ -57,15 +57,15 @@ void handle_syscall(sys_arg_t syscall, sys_arg_t a, sys_arg_t b,
 	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_NOTIFICATION: sys_req_notification(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_FREE_TIMER: sys_free_timer(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_KICK: sys_ipc_kick(t, a, b, c, d, e); break;
 	case SYS_IPC_RESP: sys_ipc_resp(t, a, b, c, d, e); break;
 	case SYS_IPC_GHOST: sys_ipc_ghost(t, a, b, c, d, e); break;
+	case SYS_SET_HANDLER: sys_set_handler(t, a, b, c, d, e); break;
 	case SYS_NOTIFY: sys_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;
@@ -73,14 +73,15 @@ void handle_syscall(sys_arg_t syscall, sys_arg_t a, sys_arg_t b,
 	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_CONF: sys_set_conf(t, a, b, c, d, e); break;
+	case SYS_GET_CONF: sys_get_conf(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;
 	case SYS_SLEEP: sys_sleep(t, a, b, c, d, e); break;
 	case SYS_IRQ_REQ: sys_irq_req(t, a, b, c, d, e); break;
+	case SYS_FREE_IRQ: sys_free_irq(t, a, b, c, d, e); break;
 	case SYS_DETACH: sys_detach(t, a, b, c, d, e); break;
 	case SYS_EXIT: sys_exit(t, a, b, c, d, e); break;
 	default:
diff --git a/src/uapi/irq.c b/src/uapi/irq.c
index 9f3931c..69602af 100644
--- a/src/uapi/irq.c
+++ b/src/uapi/irq.c
@@ -28,16 +28,25 @@ SYSCALL_DEFINE1(irq_req)(struct tcb *t, sys_arg_t id)
 	return_args1(t, register_irq(t, id));
 }
 
+SYSCALL_DEFINE1(free_irq)(struct tcb *t, sys_arg_t id)
+{
+	if (!has_cap(t->caps, CAP_IRQ))
+		return_args1(t, ERR_PERM);
+
+	return_args1(t, unregister_irq(t, id));
+}
+
 /**
  * Actual notification handler setter.
  *
  * @param t Current tcb.
- * @param tid Thread whose handler to set.
+ * @param tid Thread whose handler to set. Still not sure if this should just be
+ * the current thread, but I guess this might be a bit easier?
  * @param pid Process that is willing to handle notifications for the thread.
  *
  * @return OK on success, non-zero otherwise.
  */
-SYSCALL_DEFINE2(req_notification)(struct tcb *t, sys_arg_t tid, sys_arg_t pid)
+SYSCALL_DEFINE2(set_handler)(struct tcb *t, sys_arg_t tid, sys_arg_t pid)
 {
 	if (!has_cap(t->caps, CAP_SIGNAL))
 		return_args1(t, ERR_PERM);
diff --git a/src/uapi/mem.c b/src/uapi/mem.c
index b4b2df8..aeff7c5 100644
--- a/src/uapi/mem.c
+++ b/src/uapi/mem.c
@@ -140,7 +140,7 @@ SYSCALL_DEFINE2(req_page)(struct tcb *t, sys_arg_t size, sys_arg_t flags)
  * @param t Current tcb.
  * @param size Minimum size of allocation.
  * @param flags Flags of allocation.
- * @return \ref OK, start and size
+ * @return \ref OK, start
  * in that order, \ref ERR_OOMEM otherwise.
  */
 SYSCALL_DEFINE2(req_sharedmem)(struct tcb *t, sys_arg_t size, sys_arg_t flags)
@@ -154,7 +154,7 @@ SYSCALL_DEFINE2(req_sharedmem)(struct tcb *t, sys_arg_t size, sys_arg_t flags)
 	if (ERR_CODE(start))
 		return_args1(t, start);
 
-	return_args3(t, OK, start, size);
+	return_args2(t, OK, start);
 }
 
 /**
@@ -185,5 +185,5 @@ SYSCALL_DEFINE3(ref_sharedmem)(struct tcb *t, sys_arg_t tid, sys_arg_t addr,
 	if (ERR_CODE(start))
 		return_args1(t, start);
 
-	return_args3(t, OK, start, size);
+	return_args2(t, OK, start);
 }
diff --git a/src/uapi/proc.c b/src/uapi/proc.c
index eddbab8..74f211c 100644
--- a/src/uapi/proc.c
+++ b/src/uapi/proc.c
@@ -47,7 +47,7 @@ SYSCALL_DEFINE5(create)(struct tcb *t, sys_arg_t func,
 	set_return(c, func);
 
 	c->notify_id = t->notify_id;
-	return_args2(t, OK, c->tid);
+	return_args1(t, c->tid);
 }
 
 /**
@@ -78,10 +78,10 @@ SYSCALL_DEFINE0(fork)(struct tcb *t)
 
 	/* prepare args for when we eventually swap to the new proc, giving
 	 * parent ID as third return value */
-	set_args3(n, OK, 0, get_eproc(t)->pid);
+	set_args2(n, 0, get_eproc(t)->pid);
 
 	n->notify_id = c->notify_id;
-	return_args2(t, OK, n->pid);
+	return_args1(t, n->pid);
 }
 
 /**
@@ -161,8 +161,17 @@ SYSCALL_DEFINE2(spawn)(struct tcb *t, sys_arg_t bin, sys_arg_t interp)
 	if (!n)
 		return_args1(t, ERR_OOMEM);
 
+	/** @todo copy over bin and interp into new process, this is not enough */
 	n->notify_id = c->notify_id;
-	return_args2(t, prepare_proc(n, bin, interp), n->pid);
+	stat_t ret = OK;
+	if ((ret = prepare_proc(n, bin, interp))) {
+		/* this kills the thread */
+		orphanize(t);
+		unorphanize(t);
+		return_args1(t, ret);
+	}
+
+	return_args1(t, n->pid);
 }
 
 /**