test

core/sched_simple.c

@@ -0,0 +1,184 @@
+#include <zinnia/alloc.h>
+#include <zinnia/errno.h>
+#include <zinnia/irq.h>
+#include <zinnia/list.h>
+#include <zinnia/percpu.h>
+#include <zinnia/pmap.h>
+#include <zinnia/print.h>
+#include <zinnia/sched.h>
+#include <zinnia/spin.h>
+#include <zinnia/tailq.h>
+#include <zinnia/vas.h>
+#include <assert.h>
+#include <bits/irq.h>
+#include <stdatomic.h>
+#include <stdint.h>
+#include <string.h>
+
+static void idle_func(uintptr_t) {
+    while (1) {
+        arch_irq_set_state(true);
+        arch_irq_wait();
+    }
+}
+
+void sched_to_user(uintptr_t info_ptr) {
+    struct task_start_info* info = (struct task_start_info*)info_ptr;
+    uintptr_t ip = info->ip;
+    uintptr_t sp = info->sp;
+    uintptr_t arg = info->arg;
+    mem_free(info);
+    arch_sched_jump_to_user(ip, sp, arg);
+}
+
+void sched_to_user_context(uintptr_t ctx) {
+    arch_sched_jump_to_context((struct arch_context*)ctx);
+}
+
+void sched_init(struct sched_percpu* sched) {
+    struct task* idle_task;
+    assert(task_create("idle", &kernel_vas, nullptr, idle_func, 0, &idle_task) == 0, "Unable to create idle task!\n");
+    sched->idle_task = idle_task;
+    sched->current = idle_task;
+
+    tailq_init(&sched->run_queue);
+
+    printf("Scheduler initialized\n");
+}
+
+void sched_add_task(struct sched_percpu* sched, struct task* task) {
+    assert(task != nullptr, "Tried to add NULL to the run queue\n");
+    tailq_insert_tail(&sched->run_queue, task, next);
+}
+
+static struct task* next_task(struct sched_percpu* sched) {
+    struct task* t = tailq_first(&sched->run_queue);
+
+    if (t == nullptr)
+        return sched->idle_task;
+
+    tailq_remove(&sched->run_queue, t, next);
+
+    return t;
+}
+
+static void do_reschedule(struct sched_percpu* sched) {
+    struct task* from = atomic_load_explicit(&sched->current, memory_order_acquire);
+    struct task* to = next_task(sched);
+
+    if (from == to) {
+        irq_unlock();
+        return;
+    }
+
+    atomic_store_explicit(&sched->current, to, memory_order_relaxed);
+
+    pmap_set(&to->space->pmap);
+
+    struct percpu* cpu = percpu_get();
+    from->kernel_stack = cpu->kernel_stack;
+    from->user_stack = cpu->user_stack;
+    cpu->kernel_stack = to->kernel_stack;
+    cpu->user_stack = to->user_stack;
+
+    arch_sched_switch(from, to);
+}
+
+void sched_reschedule(struct sched_percpu* sched) {
+    irq_lock();
+    if (sched->current->state != TASK_STATE_DEAD)
+        sched_add_task(sched, sched->current);
+    do_reschedule(sched);
+}
+
+void sched_yield(struct sched_percpu* sched) {
+    irq_lock();
+    do_reschedule(sched);
+}
+
+errno_t task_create(
+    const char* name,
+    struct vas* space,
+    struct namespace* ns,
+    task_fn_t entry,
+    uintptr_t arg0,
+    struct task** out
+) {
+    if (!out)
+        return EINVAL;
+
+    struct task* new_task = mem_alloc(sizeof(struct task), 0);
+    if (new_task == nullptr)
+        return ENOMEM;
+
+    static size_t last_tid = 0;
+    new_task->id = atomic_fetch_add(&last_tid, 1);
+    new_task->space = space;
+    new_task->namespace = ns;
+    strncpy(new_task->name, name, sizeof(new_task->name));
+
+    // Allocate a kernel stack.
+    new_task->kernel_stack = (uintptr_t)mem_alloc(KERNEL_STACK_SIZE, 0);
+    if (!new_task->kernel_stack)
+        return ENOMEM;
+    new_task->user_stack = 0;
+
+    // Initialize the arch-dependent parts.
+    errno_t s = arch_task_init(&new_task->context, entry, arg0, new_task->kernel_stack + KERNEL_STACK_SIZE, true);
+    if (s != 0)
+        return s;
+
+    *out = new_task;
+    return 0;
+}
+
+void task_entry(task_fn_t entry, uintptr_t arg0) {
+    entry(arg0);
+
+    struct sched_percpu* sched = &percpu_get()->sched;
+    sched->current->state = TASK_STATE_DEAD;
+    sched_yield(sched);
+    panic("unreachable");
+}
+
+void wait_queue_init(struct wait_queue* wq) {
+    tailq_init(&wq->waiters);
+    wq->lock = (struct spinlock){0};
+}
+
+void sched_block(struct sched_percpu* sched, struct wait_queue* wq) {
+    irq_lock();
+    spin_lock(&wq->lock);
+
+    sched->current->state = TASK_STATE_BLOCKED;
+    tailq_insert_tail(&wq->waiters, sched->current, next);
+
+    spin_unlock(&wq->lock);
+    do_reschedule(sched);
+}
+
+void sched_wake(struct sched_percpu* sched, struct wait_queue* wq) {
+    spin_lock(&wq->lock);
+
+    struct task* t = tailq_first(&wq->waiters);
+    if (t != nullptr) {
+        tailq_remove(&wq->waiters, t, next);
+        t->state = TASK_STATE_READY;
+        sched_add_task(sched, t);
+    }
+
+    spin_unlock(&wq->lock);
+}
+
+void sched_wake_all(struct sched_percpu* sched, struct wait_queue* wq) {
+    spin_lock(&wq->lock);
+
+    struct task* t;
+    while ((t = tailq_first(&wq->waiters)) != nullptr) {
+        tailq_remove(&wq->waiters, t, next);
+        t->state = TASK_STATE_READY;
+        sched_add_task(sched, t);
+    }
+
+    spin_unlock(&wq->lock);
+}