diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/ipi.c | 5 | ||||
| -rw-r--r-- | src/orphanage.c | 49 | ||||
| -rw-r--r-- | src/tcb.c | 51 | ||||
| -rw-r--r-- | src/uapi/conf.c | 1 | ||||
| -rw-r--r-- | src/uapi/dispatch.c | 3 | ||||
| -rw-r--r-- | src/uapi/ipc.c | 40 | ||||
| -rw-r--r-- | src/uapi/proc.c | 100 |
7 files changed, 201 insertions, 48 deletions
@@ -26,6 +26,11 @@ void send_ipi(struct tcb *t) cpu_send_ipi(t->cpu_id); } +void unqueue_ipi(struct tcb *t) +{ + queue_del(&t->ipi_queue); +} + void handle_ipi() { struct tcb *t = cur_tcb(); diff --git a/src/orphanage.c b/src/orphanage.c new file mode 100644 index 0000000..7415e8b --- /dev/null +++ b/src/orphanage.c @@ -0,0 +1,49 @@ +/* SPDX-License-Identifier: copyleft-next-0.3.1 */ +/* Copyright 2024, Kim Kuparinen < kimi.h.kuparinen@gmail.com > */ + +#include <kmi/assert.h> +#include <kmi/orphanage.h> + +#include <arch/proc.h> + +/** + * @file orphanage.c + * + * Stuff related to orphaned threads implementation. + */ + +bool orphan(struct tcb *t) +{ + struct tcb *r = get_rproc(t); + return !r || r->dead; +} + +void orphanize(struct tcb *t) +{ + catastrophic_assert(!is_rpc(t)); + + struct tcb *r = get_tcb(t->rid); + if (r) + unreference_proc(r); + + /* attach to init process */ + struct tcb *init = get_tcb(1); + reference_proc(init); + + t->rid = 1; + t->pid = 1; + t->eid = 1; + + t->proc = init->proc; + use_vmem(t->proc.vmem); + + catastrophic_assert(init->callback); + set_args3(t, 0, SYS_USER_ORPHANED, t->tid); + set_return(t, init->callback); + t->callback = init->callback; + + /** @todo release irqs, here or later? */ + + ret_userspace_fast(); + unreachable(); +} @@ -7,6 +7,7 @@ */ #include <kmi/tcb.h> +#include <kmi/ipi.h> #include <kmi/mem.h> #include <kmi/conf.h> #include <kmi/pmem.h> @@ -200,15 +201,23 @@ struct tcb *create_proc(struct tcb *p) */ static stat_t __destroy_thread_data(struct tcb *t) { + catastrophic_assert(t->refcount == 0); + + /* free memory backing rpc stack */ + destroy_rpc_stack(t); + /* free rpc vmem */ destroy_vmem(t->rpc.vmem); + /* remove ourselves from the thread pool */ + tcbs[t->tid] = 0; + + /* forcefully free last struggling bits of memory */ + destroy_uvmem(t); + /* free associated kernel stack and the structure itself */ vm_t bottom = align_down((vm_t)t, order_size(MM_O0)); free_page(MM_O0, (pm_t)bottom); - - /** \todo free stacks */ - return OK; } @@ -217,14 +226,19 @@ stat_t destroy_thread(struct tcb *t) hard_assert(tcbs, ERR_NOINIT); hard_assert(!is_proc(t), ERR_INVAL); - /* remove thread id from list */ - /** @todo what about if thread is in rpc? should it rather just be - * marked dead? */ - tcbs[t->tid] = 0; + /* mark us as zombies */ + t->rid = 0; /* remove reference to root process */ unreference_proc(get_rproc(t)); + unqueue_ipi(t); + + /* someone still relies on us existing, don't actually free thread data + * quite yet */ + if (t->refcount) + return OK; + return __destroy_thread_data(t); } @@ -238,22 +252,31 @@ stat_t destroy_proc(struct tcb *p) unreference_proc(p); catastrophic_assert(destroy_uvmem(p)); - return __destroy_thread_data(p); + + /* don't destroy thread data just yet, let the thread destroy itself + * later */ + return OK; } void reference_proc(struct tcb *p) { + if (!p) + return; + hard_assert(is_proc(p), RETURN_VOID); p->refcount++; } void unreference_proc(struct tcb *p) { + if (!p) + return; + hard_assert(is_proc(p), RETURN_VOID); p->refcount--; if (p->dead && p->refcount == 0) { dbg("thread %d is completely destroyed\n", p->tid); - /** @todo actually destroy */ + __destroy_thread_data(p); } } @@ -308,3 +331,13 @@ bool running(struct tcb *t) { return cpu_tcb(t->cpu_id) == t; } + +bool zombie(struct tcb *t) +{ + /* we shouldn't see any NULLs but they're effectively the same thing */ + if (!t) + return true; + + /* thread doesn't belong to any process, a zombie */ + return t->rid == 0; +} diff --git a/src/uapi/conf.c b/src/uapi/conf.c index 242239c..685d294 100644 --- a/src/uapi/conf.c +++ b/src/uapi/conf.c @@ -12,6 +12,7 @@ #include <kmi/sizes.h> #include <kmi/uapi.h> #include <kmi/conf.h> +#include <arch/irq.h> #include <arch/proc.h> diff --git a/src/uapi/dispatch.c b/src/uapi/dispatch.c index f0ff724..7cfce4c 100644 --- a/src/uapi/dispatch.c +++ b/src/uapi/dispatch.c @@ -66,7 +66,7 @@ void handle_syscall(sys_arg_t syscall, sys_arg_t a, sys_arg_t b, 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_IPC_NOTIFY: sys_ipc_notify(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; case SYS_EXEC: sys_exec(t, a, b, c, d, e); break; @@ -81,6 +81,7 @@ void handle_syscall(sys_arg_t syscall, sys_arg_t a, sys_arg_t b, 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_EXIT: sys_exit(t, a, b, c, d, e); break; default: error("Syscall %zu outside allowed range [0 - %i]\n", syscall, SYS_NUM - 1); diff --git a/src/uapi/ipc.c b/src/uapi/ipc.c index 069ca59..f3896f5 100644 --- a/src/uapi/ipc.c +++ b/src/uapi/ipc.c @@ -6,6 +6,7 @@ * Interprocess communication syscall implementations. */ +#include <kmi/orphanage.h> #include <kmi/debug.h> #include <kmi/uapi.h> #include <kmi/tcb.h> @@ -29,9 +30,6 @@ struct call_ctx { /** Current process ID. */ id_t pid; - - /** Whether this context should be skipped when responding. */ - bool kick; }; /** @@ -83,7 +81,9 @@ static void finalize_rpc(struct tcb *t, struct tcb *r, vm_t s) static vm_t enter_rpc(struct tcb *t, struct sys_ret a, enum ipc_kind kind) { - vm_t rpc_stack = rpc_position(t); + /* reuse current rpc stack location if we're being kicked */ + vm_t rpc_stack = (kind == IPC_KICK && + is_rpc(t)) ? t->rpc_stack :rpc_position(t); struct call_ctx *ctx = (struct call_ctx *)(rpc_stack) - 1; ctx->regs = t->regs; @@ -98,9 +98,6 @@ static vm_t enter_rpc(struct tcb *t, struct sys_ret a, ctx->eid = t->eid; ctx->rpc_stack = rpc_stack; - /* only rpcs can be kicked forward */ - ctx->kick = kind == IPC_KICK && is_rpc(t); - /** @todo if we run out of rpc_stack space we should just stop, likely * return a status? except it shouldn't happen after we've run * enough_rpc_stack(). */ @@ -223,17 +220,25 @@ static void leave_rpc(struct tcb *t, struct sys_ret a) struct call_ctx *ctx = (struct call_ctx *)(rpc_stack) - 1; vm_t top = ctx->rpc_stack; - /* find first instance of not kicked context */ - while (ctx->kick) { - rpc_stack = ctx->rpc_stack + BASE_PAGE_SIZE; - ctx = (struct call_ctx *)(rpc_stack) - 1; - unreference_proc(get_tcb(ctx->pid)); - } - t->regs = ctx->regs; /* again, get rid of args as fast as possible */ set_args(t, 6, a); + struct tcb *r = get_tcb(ctx->pid); + while (!r || r->dead) { + /* we unwound back to our root process which is apparently dead, + * we're orphaned :( */ + if (ctx->pid == t->rid) { + orphanize(t); + return; + } + + rpc_stack = ctx->rpc_stack + BASE_PAGE_SIZE; + ctx = (struct call_ctx *)(rpc_stack) - 1; + + r = get_tcb(ctx->pid); + } + set_return(t, ctx->exec); /* if we're returning from a failed rpc, this should essentially be a * no-op */ @@ -301,13 +306,12 @@ static void do_ipc(struct tcb *t, vm_t s = enter_rpc(t, SYS_RET6(t->eid, t->tid, d0, d1, d2, d3), kind); struct tcb *r = get_tcb(pid); - if (unlikely(!r)) { + if (unlikely(!r || !is_proc(r))) { leave_rpc(t, SYS_RET1(ERR_INVAL)); return; } - r = get_rproc(r); - if (unlikely(r->dead)) { + if (unlikely(zombie(r))) { leave_rpc(t, SYS_RET1(ERR_INVAL)); return; } @@ -430,7 +434,7 @@ SYSCALL_DEFINE0(ipc_ghost)(struct tcb *t) * @param tid Thread ID to notify. * @return \ref OK and 0. */ -SYSCALL_DEFINE1(ipc_notify)(struct tcb *t, sys_arg_t tid){ +SYSCALL_DEFINE1(notify)(struct tcb *t, sys_arg_t tid){ if (t->tid != tid && !has_cap(t->caps, CAP_NOTIFY)) return_args1(t, ERR_PERM); diff --git a/src/uapi/proc.c b/src/uapi/proc.c index 1b672ce..3ce808f 100644 --- a/src/uapi/proc.c +++ b/src/uapi/proc.c @@ -10,7 +10,9 @@ #include <kmi/uapi.h> #include <kmi/proc.h> #include <kmi/bits.h> +#include <kmi/power.h> #include <kmi/notify.h> +#include <kmi/orphanage.h> #include <kmi/mem_regions.h> #include <arch/irq.h> @@ -145,24 +147,94 @@ SYSCALL_DEFINE2(spawn)(struct tcb *t, sys_arg_t bin, sys_arg_t interp) * Kill syscall handler. * * @param t Current tcb. - * @param tid Thread to kill. + * @param pid Process to kill. * \todo Implement. * * @return ERR_PERM if not capable to kill, otherwise OK. */ -SYSCALL_DEFINE1(kill)(struct tcb *t, sys_arg_t tid) +SYSCALL_DEFINE1(kill)(struct tcb *t, sys_arg_t pid) { struct tcb *c = get_cproc(t); if (!(has_cap(c->caps, CAP_PROC))) return_args1(t, ERR_PERM); - /** @todo implement */ - /** @todo remember to unregister IRQ handlers */ + struct tcb *r = get_tcb(pid); + if (is_proc(r)) + return_args1(t, ERR_INVAL); + destroy_proc(r); return_args1(t, OK); } /** + * Actual worker of swapping between threads. + * Assumes that both \p t and \p s exist and that \p s isn't a zombie or + * currently running. + * + * @param t Current tcb. + * @param s Thread to swap to. + */ +static void swap(struct tcb *t, struct tcb *s) +{ + /* switch over to new thread */ + use_tcb(s); + + /* if an irq handler is directly swapping to some other thread, + * interpret it as the thread being finished with its critical section */ + enable_irqs(); + + if (!is_rpc(s) && orphan(s)) { + orphanize(s); + return; + } + + /* set return value for current thread */ + set_args1(t, OK); + + /* handle possible queued notification */ + if (s->notify_flags) + notify(s, 0); + + /* no notifications, so get register state for new thread */ + return_args(s, get_args(s)); +} + +/** + * Syscall handler for exit syscall. + * + * @param t Thread that is exiting. + * @param tid Thread to swap to. + * + * @return \ref OK or \ref ERR_INVAL is \p tid is not a thread + * or \ref ERR_NF if \p tid is a zombie + * or \ref ERR_EXT if \p tid is currently running. + */ +SYSCALL_DEFINE1(exit)(struct tcb *t, sys_arg_t tid) +{ + if (tid != 0) { + struct tcb *s = get_tcb(tid); + if (!s) + return_args1(t, ERR_INVAL); + + if (zombie(s)) + return_args1(t, ERR_NF); + + if (running(s)) + return_args1(t, ERR_EXT); + + + swap(t, s); + } + + destroy_thread(t); + + if (tid == 0) { + enable_irqs(); + sleep(); + } +} + +/** * Swap syscall handler. * * \todo Implement. @@ -183,23 +255,11 @@ SYSCALL_DEFINE1(swap)(struct tcb *t, sys_arg_t tid){ if (!s) return_args1(t, ERR_INVAL); + if (zombie(s)) + return_args1(t, ERR_NF); + if (running(s)) return_args1(t, ERR_EXT); - /* switch over to new thread */ - use_tcb(s); - - /* set return value for current thread */ - set_args1(t, OK); - - /* if an irq handler is directly swapping to some other thread, - * interpret it as the thread being finished with its critical section */ - enable_irqs(); - - /* handle possible queued notification */ - if (s->notify_flags) - notify(s, 0); - - /* no notifications, so get register state for new thread */ - return_args(s, get_args(s)); + return swap(t, s); } |