turnstile fixes

sched/core.c

@@ -28,9 +28,36 @@ void sched_to_user_context(uintptr_t ctx) {
     arch_sched_jump_to_context((struct arch_context*)ctx);
 }
 
+static struct spinlock task_cache_lock;
+static tailq_head(struct task) task_cache = {nullptr, &task_cache.tqh_first};
+
+static struct task* task_alloc() {
+    spin_lock(&task_cache_lock);
+    struct task* task = tailq_first(&task_cache);
+    if (task)
+        tailq_remove(&task_cache, task, next);
+    spin_unlock(&task_cache_lock);
+
+    if (task == nullptr)
+        return mem_alloc(sizeof(struct task), 0);
+
+    size_t keep_start = offsetof(struct task, on_cpu);
+    size_t keep_end = keep_start + sizeof(task->on_cpu);
+    memset(task, 0, keep_start);
+    memset((char*)task + keep_end, 0, sizeof(struct task) - keep_end);
+    return task;
+}
+
+static void task_release(struct task* task) {
+    spin_lock(&task_cache_lock);
+    tailq_insert_tail(&task_cache, task, next);
+    spin_unlock(&task_cache_lock);
+}
+
 static void task_init_common(struct task* task, const char* name, struct vma* space) {
     task->space = space;
     spin_init(&task->lock);
+    atomic_store(&task->lockp, &task->lock, ATOMIC_RELAXED);
     strncpy(task->name, name, sizeof(task->name));
     task->base_prio = SCHED_PRIO_DEFAULT;
     task->time_slice = SCHED_TIME_SLICE_NS;
@@ -41,13 +68,13 @@ static void task_init_common(struct task* task, const char* name, struct vma* sp
 }
 
 errno_t task_create_current(const char* name, struct vma* space, struct task** out) {
-    struct task* task = mem_alloc(sizeof(struct task), 0);
+    struct task* task = task_alloc();
     if (task == nullptr)
         return ENOMEM;
 
     task->turnstile = turnstile_alloc();
     if (task->turnstile == nullptr) {
-        mem_free(task);
+        task_release(task);
         return ENOMEM;
     }
 
@@ -62,7 +89,7 @@ errno_t task_create(const char* name, struct vma* space, task_fn_t entry, uintpt
     if (!out)
         return EINVAL;
 
-    struct task* new_task = mem_alloc(sizeof(struct task), 0);
+    struct task* new_task = task_alloc();
     if (new_task == nullptr)
         return ENOMEM;
 
@@ -70,7 +97,7 @@ errno_t task_create(const char* name, struct vma* space, task_fn_t entry, uintpt
     new_task->id = atomic_fetch_add(&last_tid, 1, ATOMIC_ACQUIRE);
     new_task->turnstile = turnstile_alloc();
     if (new_task->turnstile == nullptr) {
-        mem_free(new_task);
+        task_release(new_task);
         return ENOMEM;
     }
 
@@ -78,7 +105,7 @@ errno_t task_create(const char* name, struct vma* space, task_fn_t entry, uintpt
     errno_t s = stack_init(&new_task->kernel_stack, KERNEL_STACK_SIZE);
     if (s != 0) {
         turnstile_free(new_task->turnstile);
-        mem_free(new_task);
+        task_release(new_task);
         return s;
     }
     new_task->user_stack = 0;
@@ -88,7 +115,7 @@ errno_t task_create(const char* name, struct vma* space, task_fn_t entry, uintpt
     if (s != 0) {
         stack_destroy(&new_task->kernel_stack);
         turnstile_free(new_task->turnstile);
-        mem_free(new_task);
+        task_release(new_task);
         return s;
     }
 
@@ -102,5 +129,19 @@ void task_destroy(struct task* task) {
     turnstile_free(task->turnstile);
     arch_task_fini(&task->context);
     stack_destroy(&task->kernel_stack);
-    mem_free(task);
+    task_release(task);
+}
+
+void task_lock(struct task* task) {
+    while (true) {
+        struct spinlock* lock = atomic_load(&task->lockp, ATOMIC_ACQUIRE);
+        spin_lock(lock);
+        if (atomic_load(&task->lockp, ATOMIC_RELAXED) == lock)
+            return;
+        spin_unlock(lock);
+    }
+}
+
+void task_unlock(struct task* task) {
+    spin_unlock(atomic_load(&task->lockp, ATOMIC_RELAXED));
 }