diff options
| -rw-r--r-- | Makefile | 2 | ||||
| -rw-r--r-- | arch/riscv64/kernel/vmem.c | 2 | ||||
| -rw-r--r-- | common/pmem.c | 3 | ||||
| -rw-r--r-- | common/uapi/cap.c | 10 | ||||
| -rw-r--r-- | common/uapi/conf.c | 9 | ||||
| -rw-r--r-- | common/uapi/dispatch.c | 64 | ||||
| -rw-r--r-- | common/uapi/ipc.c | 38 | ||||
| -rw-r--r-- | common/uapi/mem.c | 28 | ||||
| -rw-r--r-- | common/uapi/proc.c | 75 | ||||
| -rw-r--r-- | common/uapi/timers.c | 36 | ||||
| -rw-r--r-- | include/apos/syscalls.h | 2 | ||||
| -rw-r--r-- | include/apos/tcb.h | 12 | ||||
| -rw-r--r-- | include/apos/uapi.h | 51 | ||||
| -rw-r--r-- | include/arch/vmem.h | 2 |
14 files changed, 186 insertions, 148 deletions
@@ -2,7 +2,7 @@ DO != echo -n > deps.mk # this could be done better DEBUGFLAGS != [ $(RELEASE) ] \ - && echo "-flto -O2 -g -DNDEBUG" \ + && echo "-flto -O2 -g -DDEBUG" \ || echo "-O0 -g -DDEBUG" CFLAGS = -ffreestanding -nostdlib -static -fno-pie -std=c17 -Wall -Wextra -Wvla -D$(ARCH) diff --git a/arch/riscv64/kernel/vmem.c b/arch/riscv64/kernel/vmem.c index 547cbfc..f9a6784 100644 --- a/arch/riscv64/kernel/vmem.c +++ b/arch/riscv64/kernel/vmem.c @@ -444,7 +444,7 @@ vm_t setup_kernel_io(struct vmem *b, vm_t paddr) } #endif -void clone_uvmem(struct vmem *r, struct vmem *b) +void clone_uvmem(struct vmem * restrict r, struct vmem * restrict b) { size_t i = 0; for (; i < CSTACK_PAGE; i += 8) { 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); diff --git a/include/apos/syscalls.h b/include/apos/syscalls.h index dd383c8..a5c805d 100644 --- a/include/apos/syscalls.h +++ b/include/apos/syscalls.h @@ -126,6 +126,8 @@ enum { /** Shutdown, reboot, etc. */ SYS_POWEROFF, /** @} */ + + SYS_NUM, }; /* function declarations should be somewhere else, this file could be used in diff --git a/include/apos/tcb.h b/include/apos/tcb.h index 981f352..34b0457 100644 --- a/include/apos/tcb.h +++ b/include/apos/tcb.h @@ -31,13 +31,23 @@ #define is_rpc(t) (t->rid != t->pid) /** - * Get the process thread of current thread. + * Get the effective process thread of current thread. * * @param t Thread whose effective process thread to get. * @return The process thread of the current thread. */ #define get_proc(t) (get_tcb(t->eid)) +#define get_eproc(t) get_proc(t) + +/** + * Get the current process thread of current thread. + * + * @param t Thread whose current process thread to get. + * @return The current process thread of the current thread. + */ +#define get_cproc(t) (get_tcb(t->pid)) + /** * Get the root process thread of current thread. * diff --git a/include/apos/uapi.h b/include/apos/uapi.h index fea82e4..99ab4e1 100644 --- a/include/apos/uapi.h +++ b/include/apos/uapi.h @@ -16,7 +16,7 @@ * Syscall function type. * Let's start with five arguments and see where that goes */ -typedef struct sys_ret (*sys_t)(long, long, long, long, long); +typedef struct sys_ret (*sys_t)(struct tcb *t, long, long, long, long, long); /** * Syscall argument type. @@ -83,7 +83,8 @@ struct sys_ret { * @param name Name of syscall. */ #define SYSCALL_DECLARE0(name) \ - struct sys_ret sys_##name(sys_arg_t a, \ + struct sys_ret sys_##name(struct tcb *t, \ + sys_arg_t a, \ sys_arg_t b, \ sys_arg_t c, \ sys_arg_t d, \ @@ -96,7 +97,7 @@ struct sys_ret { * @param a Name of argument. */ #define SYSCALL_DECLARE1(name, a) \ - struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + struct sys_ret sys_##name(struct tcb *t, sys_arg_t a, sys_arg_t b, sys_arg_t c, \ sys_arg_t d, sys_arg_t e); /** @@ -107,7 +108,7 @@ struct sys_ret { * @param b Name of second argument. */ #define SYSCALL_DECLARE2(name, a, b) \ - struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + struct sys_ret sys_##name(struct tcb *t, sys_arg_t a, sys_arg_t b, sys_arg_t c, \ sys_arg_t d, sys_arg_t e); /** @@ -119,7 +120,7 @@ struct sys_ret { * @param c Name of third argument. */ #define SYSCALL_DECLARE3(name, a, b, c) \ - struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + struct sys_ret sys_##name(struct tcb *t, sys_arg_t a, sys_arg_t b, sys_arg_t c, \ sys_arg_t d, sys_arg_t e); /** @@ -132,7 +133,7 @@ struct sys_ret { * @param d Name of fourth argument. */ #define SYSCALL_DECLARE4(name, a, b, c, d) \ - struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + struct sys_ret sys_##name(struct tcb *t, sys_arg_t a, sys_arg_t b, sys_arg_t c, \ sys_arg_t d, sys_arg_t e); /** @@ -146,7 +147,7 @@ struct sys_ret { * @param e Name of fifth argument. */ #define SYSCALL_DECLARE5(name, a, b, c, d, e) \ - struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + struct sys_ret sys_##name(struct tcb *t, sys_arg_t a, sys_arg_t b, sys_arg_t c, \ sys_arg_t d, sys_arg_t e); /** @@ -155,8 +156,8 @@ struct sys_ret { * @param name Name of syscall. */ #define SYSCALL_DEFINE0(name) \ - static inline struct sys_ret __##name(); \ - struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + static inline struct sys_ret __##name(struct tcb *t); \ + struct sys_ret sys_##name(struct tcb *t, sys_arg_t a, sys_arg_t b, sys_arg_t c, \ sys_arg_t d, sys_arg_t e) \ { \ UNUSED(a); \ @@ -164,7 +165,7 @@ struct sys_ret { UNUSED(c); \ UNUSED(d); \ UNUSED(e); \ - return __##name(); \ + return __##name(t); \ } \ static struct sys_ret __##name @@ -174,15 +175,15 @@ struct sys_ret { * @param name Name of syscall. */ #define SYSCALL_DEFINE1(name) \ - static inline struct sys_ret __##name(sys_arg_t); \ - struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + static inline struct sys_ret __##name(struct tcb *, sys_arg_t); \ + struct sys_ret sys_##name(struct tcb *t, sys_arg_t a, sys_arg_t b, sys_arg_t c, \ sys_arg_t d, sys_arg_t e) \ { \ UNUSED(b); \ UNUSED(c); \ UNUSED(d); \ UNUSED(e); \ - return __##name(a); \ + return __##name(t, a); \ } \ static inline struct sys_ret __##name @@ -192,14 +193,14 @@ struct sys_ret { * @param name Name of syscall. */ #define SYSCALL_DEFINE2(name) \ - static inline struct sys_ret __##name(sys_arg_t, sys_arg_t); \ - struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + static inline struct sys_ret __##name(struct tcb *, sys_arg_t, sys_arg_t); \ + struct sys_ret sys_##name(struct tcb *t, sys_arg_t a, sys_arg_t b, sys_arg_t c, \ sys_arg_t d, sys_arg_t e) \ { \ UNUSED(c); \ UNUSED(d); \ UNUSED(e); \ - return __##name(a, b); \ + return __##name(t, a, b); \ } \ static inline struct sys_ret __##name @@ -209,14 +210,14 @@ struct sys_ret { * @param name Name of syscall. */ #define SYSCALL_DEFINE3(name) \ - static inline struct sys_ret __##name(sys_arg_t, sys_arg_t, \ + static inline struct sys_ret __##name(struct tcb *, sys_arg_t, sys_arg_t, \ sys_arg_t); \ - struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + struct sys_ret sys_##name(struct tcb *t, sys_arg_t a, sys_arg_t b, sys_arg_t c, \ sys_arg_t d, sys_arg_t e) \ { \ UNUSED(d); \ UNUSED(e); \ - return __##name(a, b, c); \ + return __##name(t, a, b, c); \ } \ static inline struct sys_ret __##name @@ -226,13 +227,13 @@ struct sys_ret { * @param name Name of syscall. */ #define SYSCALL_DEFINE4(name) \ - static inline struct sys_ret __##name(sys_arg_t, sys_arg_t, sys_arg_t, \ + static inline struct sys_ret __##name(struct tcb *, sys_arg_t, sys_arg_t, sys_arg_t, \ sys_arg_t); \ - struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + struct sys_ret sys_##name(struct tcb *t, sys_arg_t a, sys_arg_t b, sys_arg_t c, \ sys_arg_t d, sys_arg_t e) \ { \ UNUSED(e); \ - return __##name(a, b, c, d); \ + return __##name(t, a, b, c, d); \ } \ static inline struct sys_ret __##name @@ -242,12 +243,12 @@ struct sys_ret { * @param name Name of syscall. */ #define SYSCALL_DEFINE5(name) \ - static inline struct sys_ret __##name(sys_arg_t, sys_arg_t, sys_arg_t, \ + static inline struct sys_ret __##name(struct tcb *, sys_arg_t, sys_arg_t, sys_arg_t, \ sys_arg_t, sys_arg_t); \ - struct sys_ret sys_##name(sys_arg_t a, sys_arg_t b, sys_arg_t c, \ + struct sys_ret sys_##name(struct tcb *t, sys_arg_t a, sys_arg_t b, sys_arg_t c, \ sys_arg_t d, sys_arg_t e) \ { \ - return __##name(a, b, c, d, e); \ + return __##name(t, a, b, c, d, e); \ } \ static inline struct sys_ret __##name diff --git a/include/arch/vmem.h b/include/arch/vmem.h index c829629..ce43a55 100644 --- a/include/arch/vmem.h +++ b/include/arch/vmem.h @@ -162,6 +162,6 @@ stat_t destroy_vmem(struct vmem *b); * @param r Source virtual memory of clone. * @param b Destination virtual memory of clone. */ -void clone_uvmem(struct vmem *r, struct vmem *b); +void clone_uvmem(struct vmem * restrict r, struct vmem * restrict b); #endif /* APOS_ARCH_PAGES_H */ |