foo

core/sched/sched_dumb.c

@@ -1,6 +1,5 @@
 #include <zinnia/alloc.h>
 #include <zinnia/assert.h>
-#include <zinnia/atomic.h>
 #include <zinnia/errno.h>
 #include <zinnia/irq.h>
 #include <zinnia/list.h>
@@ -9,11 +8,12 @@
 #include <zinnia/print.h>
 #include <zinnia/sched.h>
 #include <zinnia/spin.h>
+#include <zinnia/string.h>
 #include <zinnia/tailq.h>
 #include <zinnia/vma.h>
 #include <arch/sched.h>
+#include <stdatomic.h>
 #include <stdint.h>
-#include <zinnia/string.h>
 
 static void idle_func(uintptr_t) {
     while (1) {
@@ -39,7 +39,12 @@ 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!\n");
     sched->idle_task = idle_task;
-    sched->current = idle_task;
+
+    struct task* boot_task = mem_alloc(sizeof(struct task), 0);
+    assert(boot_task != nullptr, "Unable to create boot task!\n");
+    strncpy(boot_task->name, "boot", sizeof(boot_task->name));
+    boot_task->space = &kernel_vma;
+    sched->current = boot_task;
 
     tailq_init(&sched->run_queue);
 
@@ -76,17 +81,19 @@ static void do_reschedule(struct scheduler* sched) {
     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->kernel_stack = to->kernel_stack + KERNEL_STACK_SIZE;
     cpu->user_stack = to->user_stack;
 
-    struct task* old = arch_sched_switch(from, to);
+    struct irq_percpu irq_state = *percpu_ref(irq_data);
+    arch_sched_switch(from, to);
+    *percpu_ref(irq_data) = irq_state;
+    irq_unlock();
 }
 
 void sched_reschedule(struct scheduler* sched) {
     irq_lock();
-    if (sched->current->state != TASK_STATE_DEAD)
+    if (sched->current != sched->idle_task && sched->current->state != TASK_STATE_DEAD)
         sched_add_task(sched, sched->current);
     do_reschedule(sched);
 }
@@ -104,27 +111,38 @@ errno_t task_create(const char* name, struct vma* space, task_fn_t entry, uintpt
     if (new_task == nullptr)
         return ENOMEM;
 
-    static size_t last_tid = 0;
-    new_task->id = atomic_fetch_add(&last_tid, 1, ATOMIC_ACQUIRE);
+    static _Atomic(size_t) last_tid = 0;
+    new_task->id = atomic_fetch_add_explicit(&last_tid, 1, memory_order_acquire);
     new_task->space = space;
     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)
+    if (!new_task->kernel_stack) {
+        mem_free(new_task);
         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)
+    if (s != 0) {
+        mem_free((void*)new_task->kernel_stack);
+        mem_free(new_task);
         return s;
+    }
 
     *out = new_task;
     return 0;
 }
 
 void task_entry(task_fn_t entry, uintptr_t arg0) {
+    *percpu_ref(irq_data) = (struct irq_percpu){
+        .depth = 1,
+        .saved_state = true,
+    };
+    irq_unlock();
+
     entry(arg0);
 
     struct scheduler* sched = &percpu_get()->sched;