improve uapi

6 files changed, 60 insertions, 50 deletions

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 <apos/uapi.h>
 #include <apos/tcb.h>
 
-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 <apos/vmem.h>
 #include <apos/dmem.h>
 
-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 <apos/timer.h>
 #include <apos/uapi.h>
 
-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 };
 }