Rename dirs

sched/sched_dumb.c

@@ -0,0 +1,194 @@
+#include <zinnia/alloc.h>
+#include <zinnia/assert.h>
+#include <zinnia/atomic.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/stack.h>
+#include <zinnia/tailq.h>
+#include <zinnia/vma.h>
+#include <arch/sched.h>
+#include <stdint.h>
+
+static void idle_func(uintptr_t) {
+    while (1) {
+        irq_set_state(true);
+        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 scheduler* sched) {
+    struct task* idle_task;
+    assert(task_create("idle", &kernel_vma, idle_func, 0, &idle_task) == 0, "Unable to create idle task!");
+    sched->idle_task = idle_task;
+
+    struct task* boot_task = mem_alloc(sizeof(struct task), 0);
+    assert(boot_task != nullptr, "Unable to create boot task!");
+    strncpy(boot_task->name, "boot", sizeof(boot_task->name));
+    boot_task->space = &kernel_vma;
+    sched->current = boot_task;
+
+    tailq_init(&sched->run_queue);
+
+    log("sched: Scheduler initialized\n");
+}
+
+void sched_add_task(struct scheduler* sched, struct task* task) {
+    assert(task != nullptr, "Tried to add NULL to the run queue");
+    task->state = TASK_STATE_READY;
+    tailq_insert_tail(&sched->run_queue, task, next);
+}
+
+static struct task* next_task(struct scheduler* sched) {
+    struct task* t = tailq_first(&sched->run_queue);
+
+    if (t == nullptr)
+        return sched->idle_task;
+
+    tailq_remove(&sched->run_queue, t, next);
+    t->state = TASK_STATE_RUNNING;
+
+    return t;
+}
+
+static void finish_switch(struct task* prev) {
+    if (prev->state == TASK_STATE_DEAD)
+        task_destroy(prev);
+}
+
+static void do_reschedule(struct scheduler* sched) {
+    struct task* from = sched->current;
+    struct task* to = next_task(sched);
+
+    // We'd end up on the same task, skip switching altogether.
+    if (from == to) {
+        irq_unlock();
+        return;
+    }
+
+    sched->current = to;
+    pmap_set(&to->space->pmap);
+
+    struct percpu* cpu = percpu_get();
+    from->user_stack = cpu->user_stack;
+    cpu->kernel_stack = kernel_stack_top(&to->kernel_stack);
+    cpu->user_stack = to->user_stack;
+
+    struct irq_percpu irq_state = *percpu_ref(irq_data);
+    struct task* prev = arch_sched_switch(from, to);
+    *percpu_ref(irq_data) = irq_state;
+    finish_switch(prev);
+    irq_unlock();
+}
+
+void sched_reschedule(struct scheduler* sched) {
+    irq_lock();
+    if (sched->current != sched->idle_task && sched->current->state != TASK_STATE_DEAD)
+        sched_add_task(sched, sched->current);
+    do_reschedule(sched);
+}
+
+void sched_yield(struct scheduler* sched) {
+    irq_lock();
+    do_reschedule(sched);
+}
+
+void sched_block(struct scheduler* sched) {
+    irq_lock();
+    if (atomic_exchange(&sched->current->wake_pending, false, ATOMIC_ACQ_REL)) {
+        irq_unlock();
+        return;
+    }
+    sched->current->state = TASK_STATE_BLOCKED;
+    do_reschedule(sched);
+}
+
+void sched_wake(struct task* task) {
+    irq_lock();
+    if (task->state == TASK_STATE_BLOCKED)
+        sched_add_task(&percpu_get()->sched, task);
+    else
+        atomic_store(&task->wake_pending, true, ATOMIC_RELEASE);
+    irq_unlock();
+}
+
+errno_t task_create(const char* name, struct vma* space, 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 atomic_size_t last_tid = 0;
+    new_task->id = atomic_fetch_add(&last_tid, 1, ATOMIC_ACQUIRE);
+    new_task->space = space;
+    strncpy(new_task->name, name, sizeof(new_task->name));
+
+    // Allocate a kernel stack.
+    errno_t s = stack_init(&new_task->kernel_stack, KERNEL_STACK_SIZE);
+    if (s != 0) {
+        mem_free(new_task);
+        return s;
+    }
+    new_task->user_stack = 0;
+
+    // Initialize the arch-dependent parts.
+    s = arch_task_init(&new_task->context, entry, arg0, kernel_stack_top(&new_task->kernel_stack), true);
+    if (s != 0) {
+        stack_destroy(&new_task->kernel_stack);
+        mem_free(new_task);
+        return s;
+    }
+
+    *out = new_task;
+    return 0;
+}
+
+void task_destroy(struct task* task) {
+    arch_task_fini(&task->context);
+    stack_destroy(&task->kernel_stack);
+    mem_free(task);
+}
+
+void task_entry(task_fn_t entry, uintptr_t arg0, struct task* prev) {
+    finish_switch(prev);
+
+    *percpu_ref(irq_data) = (struct irq_percpu){
+        .depth = 1,
+        .saved_state = true,
+    };
+    irq_unlock();
+
+    entry(arg0);
+
+    struct scheduler* sched = &percpu_get()->sched;
+    sched->current->state = TASK_STATE_DEAD;
+    sched_yield(sched);
+    panic("unreachable");
+}
+
+[[__init]]
+static void sched_stage_init(struct boot_info*) {
+    sched_init(&percpu_get()->sched);
+}
+INIT_TASK(sched_stage, "core.sched", sched_stage_init);
+INIT_DEPENDS(sched_stage, percpu_stage);