Improve await synchronization

Author: phaubertin

include/kernel/types.h

@@ -96,10 +96,12 @@ typedef struct {
 } process_t;
 
 typedef enum {
-    THREAD_STATE_ZOMBIE,
+    THREAD_STATE_CREATED,
+    THREAD_STATE_STARTING,
     THREAD_STATE_READY,
     THREAD_STATE_RUNNING,
-    THREAD_STATE_BLOCKED
+    THREAD_STATE_BLOCKED,
+    THREAD_STATE_ZOMBIE
 } thread_state_t;
 
 struct thread_t {

kernel/application/syscalls/await_thread.c

@@ -38,38 +38,27 @@
 #include <kernel/machine/spinlock.h>
 #include <kernel/machine/thread.h>
 
-int await_thread(int fd) {
-    descriptor_t desc;
-    int status = dereference_object_descriptor(&desc, get_current_process(), fd);
-
-    if(status < 0) {
-        return -JINUE_EBADF;
-    }
-
-    thread_t *thread = get_thread_from_descriptor(&desc);
+static int with_thread_referenced(descriptor_t *thread_desc) {
+    thread_t *thread = get_thread_from_descriptor(thread_desc);
 
     if(thread == NULL) {
-        unreference_descriptor_object(&desc);
         return -JINUE_EBADF;
     }
 
-    if(!descriptor_has_permissions(&desc, JINUE_PERM_AWAIT)) {
-        unreference_descriptor_object(&desc);
+    if(!descriptor_has_permissions(thread_desc, JINUE_PERM_AWAIT)) {
         return -JINUE_EPERM;
     }
 
     thread_t *current = get_current_thread();
 
     if(thread == current) {
-        unreference_descriptor_object(&desc);
         return -JINUE_EDEADLK;
     }
 
     spin_lock(&thread->await_lock);
 
-    if(thread->awaiter != NULL) {
+    if(thread->state == THREAD_STATE_CREATED || thread->awaiter != NULL) {
         spin_unlock(&thread->await_lock);
-        unreference_descriptor_object(&desc);
         return -JINUE_ESRCH;
     }
 
@@ -81,7 +70,20 @@ int await_thread(int fd) {
         block_and_unlock(&thread->await_lock);
     }
 
-    unreference_descriptor_object(&desc);
-
     return 0;
 }
+
+int await_thread(int fd) {
+    descriptor_t thread_desc;
+    int status = dereference_object_descriptor(&thread_desc, get_current_process(), fd);
+
+    if(status < 0) {
+        return -JINUE_EBADF;
+    }
+
+    status = with_thread_referenced(&thread_desc);
+
+    unreference_descriptor_object(&thread_desc);
+
+    return status;
+}

kernel/application/syscalls/start_thread.c

@@ -55,7 +55,7 @@ int start_thread(int fd, const thread_params_t *params) {
         return -JINUE_EPERM;
     }
 
-    if(thread->state != THREAD_STATE_ZOMBIE) {
+    if(thread->state != THREAD_STATE_CREATED && thread->state != THREAD_STATE_ZOMBIE) {
         unreference_descriptor_object(&desc);
         return -JINUE_EBUSY;
     }

kernel/domain/entities/thread.c

@@ -85,13 +85,9 @@ thread_t *construct_thread(process_t *process) {
     init_spinlock(&thread->await_lock);
     jinue_node_init(&thread->thread_list);
 
-    thread->state               = THREAD_STATE_ZOMBIE;
+    thread->state               = THREAD_STATE_CREATED;
     thread->process             = process;
-    /* Arbitrary non-NULL value to signify the thread hasn't run yet and
-     * shouldn't be awaited. This will fall in the condition in await_thread()
-     * that detects an attempt to await a thread that has already been awaited,
-     * so await_thread() will fail with JINUE_ESRCH. */
-    thread->awaiter             = thread;
+    thread->awaiter             = NULL;
     thread->local_storage_addr  = NULL;
     thread->local_storage_size  = 0;
 
@@ -128,7 +124,14 @@ static void free_thread(object_header_t *object) {
  */
 void prepare_thread(thread_t *thread, const thread_params_t *params) {
     thread->sender  = NULL;
+    
+    spin_lock(&thread->await_lock);
+    
     thread->awaiter = NULL;
+    thread->state   = THREAD_STATE_STARTING;
+
+    spin_unlock(&thread->await_lock);    
+    
     machine_prepare_thread(thread, params);
 }