aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/panic.c3
-rw-r--r--src/proc.c2
-rw-r--r--src/regions.c1
-rw-r--r--src/uapi/cap.c52
-rw-r--r--src/uapi/conf.c10
-rw-r--r--src/uapi/dispatch.c9
-rw-r--r--src/uapi/irq.c13
-rw-r--r--src/uapi/mem.c6
-rw-r--r--src/uapi/proc.c17
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);
}
/**
generated by cgit v1.3 (git 2.53.0) at 2026-08-27 09:21:52 +0000