Refactoring: thread_await() (#87)

Refactor ` thread_await()` into a separate function.

include/kernel/domain/entities/thread.h

@@ -50,6 +50,8 @@ void thread_run_first(thread_t *thread);
 
 void thread_run(thread_t *thread);
 
+void thread_yield_current(void);
+
 void thread_terminate_current(void);
 
 void thread_switch_to(thread_t *to);
@@ -58,7 +60,7 @@ void thread_switch_to_and_block(thread_t *to);
 
 void thread_block_current_and_unlock(spinlock_t *lock);
 
-void thread_yield_current(void);
+int thread_await(thread_t *thread);
 
 void thread_set_local_storage(thread_t *thread, addr_t addr, size_t size);
 

kernel/application/syscalls/await_thread.c

@@ -49,28 +49,7 @@ static int with_thread(descriptor_t *thread_desc) {
         return -JINUE_EPERM;
     }
 
-    thread_t *current = get_current_thread();
-
-    if(thread == current) {
-        return -JINUE_EDEADLK;
-    }
-
-    spin_lock(&thread->await_lock);
-
-    if(thread->state == THREAD_STATE_CREATED || thread->awaiter != NULL) {
-        spin_unlock(&thread->await_lock);
-        return -JINUE_ESRCH;
-    }
-
-    thread->awaiter = current;
-
-    if(thread->state == THREAD_STATE_ZOMBIE) {
-        spin_unlock(&thread->await_lock);
-    } else {
-        thread_block_current_and_unlock(&thread->await_lock);
-    }
-
-    return 0;
+    return thread_await(thread);
 }
 
 int await_thread(int fd) {

kernel/domain/entities/thread.c

@@ -29,6 +29,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <jinue/shared/asm/errno.h>
 #include <kernel/domain/alloc/page_alloc.h>
 #include <kernel/domain/entities/descriptor.h>
 #include <kernel/domain/entities/object.h>
@@ -270,6 +271,33 @@ static thread_t *reschedule(bool current_can_run) {
     return to;
 }
 
+/**
+ * Yield the current thread
+ * 
+ * The current thread is added at the tail of the ready queue. It continues
+ * running if no other thread is ready to run.
+ */
+void thread_yield_current(void) {
+    thread_t *current   = get_current_thread();
+    thread_t *to        = reschedule(true);
+
+    if(to == current) {
+        return;
+    }
+
+    to->state = THREAD_STATE_RUNNING;
+
+    if(current->process != to->process) {
+        process_switch_to(to->process);
+    }
+
+    spin_lock(&ready_queue.lock);
+
+    thread_ready_locked(current);
+
+    machine_switch_thread_and_unlock(current, to, &ready_queue.lock);
+}
+
 /**
  * Terminate the current thread
  * 
@@ -388,30 +416,35 @@ void thread_block_current_and_unlock(spinlock_t *lock) {
 }
 
 /**
- * Yield the current thread
+ * Block until thread terminates
  * 
- * The current thread is added at the tail of the ready queue. It continues
- * running if no other thread is ready to run.
+ * @param thread awaited thread
+ * @return zero on success, negated error code on failure
+ *
  */
-void thread_yield_current(void) {
-    thread_t *current   = get_current_thread();
-    thread_t *to        = reschedule(true);
+int thread_await(thread_t *thread) {
+    thread_t *current = get_current_thread();
 
-    if(to == current) {
-        return;
+    if(thread == current) {
+        return -JINUE_EDEADLK;
     }
 
-    to->state = THREAD_STATE_RUNNING;
+    spin_lock(&thread->await_lock);
 
-    if(current->process != to->process) {
-        process_switch_to(to->process);
+    if(thread->state == THREAD_STATE_CREATED || thread->awaiter != NULL) {
+        spin_unlock(&thread->await_lock);
+        return -JINUE_ESRCH;
     }
 
-    spin_lock(&ready_queue.lock);
+    thread->awaiter = current;
 
-    thread_ready_locked(current);
+    if(thread->state == THREAD_STATE_ZOMBIE) {
+        spin_unlock(&thread->await_lock);
+    } else {
+        thread_block_current_and_unlock(&thread->await_lock);
+    }
 
-    machine_switch_thread_and_unlock(current, to, &ready_queue.lock);
+    return 0;
 }
 
 /**