From 62d395d206171fdaf3fa62c495633990198db6c4 Mon Sep 17 00:00:00 2001 From: Kimplul Date: Mon, 21 Nov 2022 14:02:17 +0200 Subject: possible optimisations --- common/uapi/cap.c | 10 +++---- common/uapi/conf.c | 9 ++---- common/uapi/dispatch.c | 64 ++++++++++++++++++++++++++++-------------- common/uapi/ipc.c | 38 +++++++++++++------------ common/uapi/mem.c | 28 +++++++++---------- common/uapi/proc.c | 75 ++++++++++++++++++++++++++------------------------ common/uapi/timers.c | 36 ++++++++++++------------ 7 files changed, 142 insertions(+), 118 deletions(-) (limited to 'common/uapi') 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); -- cgit v1.3