new: mutex

kernel/common/Makefile

@@ -3,7 +3,7 @@ CFLAGS += -I .
 
 kernel_common_subdirs:=libELF math
 
-all: glib.o printk.o cpu.o bitree.o kfifo.o wait_queue.o
+all: glib.o printk.o cpu.o bitree.o kfifo.o wait_queue.o mutex.o wait.o
 	@list='$(kernel_common_subdirs)'; for subdir in $$list; do \
     		echo "make all in $$subdir";\
     		cd $$subdir;\
@@ -28,3 +28,9 @@ kfifo.o: kfifo.c
 
 wait_queue.o: wait_queue.c
 	gcc $(CFLAGS) -c wait_queue.c -o wait_queue.o
+
+mutex.o: mutex.c
+	gcc $(CFLAGS) -c mutex.c -o mutex.o
+
+wait.o: sys/wait.c
+	gcc $(CFLAGS) -c sys/wait.c -o sys/wait.o

kernel/common/mutex.c

@@ -0,0 +1,120 @@
+#include <common/mutex.h>
+#include <mm/slab.h>
+#include <sched/sched.h>
+
+/**
+ * @brief 初始化互斥量
+ *
+ * @param lock mutex结构体
+ */
+void mutex_init(mutex_t *lock)
+{
+    atomic_set(&lock->count, 1);
+    spin_init(&lock->wait_lock);
+    list_init(&lock->wait_list);
+}
+
+static void __mutex_sleep()
+{
+    current_pcb->state = PROC_UNINTERRUPTIBLE;
+    sched_cfs();
+}
+
+static void __mutex_acquire(mutex_t *lock)
+{
+}
+/**
+ * @brief 对互斥量加锁
+ *
+ * @param lock mutex结构体
+ */
+void mutex_lock(mutex_t *lock)
+{
+    bool lock_ok = 0;
+
+    while (lock_ok == false)
+    {
+        spin_lock(&lock->wait_lock);
+        if (likely(mutex_is_locked(lock)))
+        {
+            struct mutex_waiter_t *waiter = (struct mutex_waiter_t *)kmalloc(sizeof(struct mutex_waiter_t), 0);
+            if (waiter == NULL)
+            {
+                kerror("In mutex_lock: no memory to alloc waiter. Program's behaviour might be indetermined!");
+                spin_unlock(&lock->wait_lock);
+                return;
+            }
+            memset(waiter, 0, sizeof(struct mutex_waiter_t));
+            waiter->pcb = current_pcb;
+            list_init(&waiter->list);
+            list_append(&lock->wait_list, &waiter->list);
+
+            spin_unlock(&lock->wait_lock);
+
+            __mutex_sleep();
+        }
+        else
+        {
+            atomic_dec(&lock->count);
+            spin_unlock(&lock->wait_lock);
+            lock_ok = true;
+        }
+    }
+}
+
+/**
+ * @brief 对互斥量解锁
+ *
+ * @param lock mutex结构体
+ */
+void mutex_unlock(mutex_t *lock)
+{
+    if (unlikely(!mutex_is_locked(lock)))
+        return;
+    
+    spin_lock(&lock->wait_lock);
+    struct mutex_waiter_t *wt = NULL;
+    if (mutex_is_locked(lock))
+    {
+        if (!list_empty(&lock->wait_list))
+            wt = container_of(list_next(&lock->wait_list), struct mutex_waiter_t, list);
+
+        atomic_inc(&lock->count);
+        if (wt != NULL)
+            list_del(&wt->list);
+    }
+
+    spin_unlock(&lock->wait_lock);
+
+    if (wt != NULL)
+    {
+        process_wakeup(wt->pcb);
+        kfree(wt);
+    }
+}
+
+/**
+ * @brief 尝试对互斥量加锁
+ *
+ * @param lock mutex结构体
+ *
+ * @return 成功加锁->1, 加锁失败->0
+ */
+int mutex_trylock(mutex_t *lock)
+{
+    if (mutex_is_locked(lock))
+        return 0;
+
+    spin_lock(&lock->wait_lock);
+    if (mutex_is_locked(lock))
+    {
+        spin_unlock(&lock->wait_lock);
+        return 0;
+    }
+    else
+    {
+        atomic_dec(&lock->count);
+        spin_unlock(&lock->wait_lock);
+        return 1;
+    }
+}

kernel/common/mutex.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <common/atomic.h>
+#include <common/spinlock.h>
+#include <common/glib.h>
+#include <process/process.h>
+
+/**
+ * @brief Mutex - 互斥锁
+ *
+ * - 同一时间只有1个任务可以持有mutex
+ * - 不允许递归地加锁、解锁
+ * - 只允许通过mutex的api来操作mutex
+ * - 在硬中断、软中断中不能使用mutex
+ */
+typedef struct
+{
+
+    atomic_t count; // 锁计数。1->已解锁。 0->已上锁,且有可能存在等待者
+    spinlock_t wait_lock;
+    struct List wait_list;
+} mutex_t;
+
+/**
+ * @brief 在mutex上的等待者的结构体
+ *
+ */
+struct mutex_waiter_t
+{
+    struct List list;
+    struct process_control_block *pcb;
+};
+
+/**
+ * @brief 初始化互斥量
+ *
+ * @param lock mutex结构体
+ */
+void mutex_init(mutex_t *lock);
+
+/**
+ * @brief 对互斥量加锁
+ *
+ * @param lock mutex结构体
+ */
+void mutex_lock(mutex_t *lock);
+
+/**
+ * @brief 对互斥量解锁
+ *
+ * @param lock mutex结构体
+ */
+void mutex_unlock(mutex_t *lock);
+
+/**
+ * @brief 尝试对互斥量加锁
+ *
+ * @param lock mutex结构体
+ *
+ * @return 成功加锁->1, 加锁失败->0
+ */
+int mutex_trylock(mutex_t *lock);
+
+/**
+ * @brief 判断mutex是否已被加锁
+ *
+ * @return 已加锁->1, 未加锁->0
+ */
+#define mutex_is_locked(lock) ((atomic_read(&(lock)->count) == 1) ? 0 : 1)

kernel/common/sys/wait.c

@@ -0,0 +1,15 @@
+#include <syscall/syscall_num.h>
+#include <syscall/syscall.h>
+
+/**
+ * @brief 等待指定pid的子进程退出
+ *
+ * @param pid 子进程的pid
+ * @param stat_loc 返回的子进程结束状态
+ * @param options 额外的控制选项
+ * @return pid_t
+ */
+pid_t waitpid(pid_t pid, int *stat_loc, int options)
+{
+    return (pid_t)enter_syscall_int(SYS_WAIT4, (uint64_t)pid, (uint64_t)stat_loc, options, 0, 0, 0, 0, 0);
+}

kernel/common/sys/wait.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "types.h"
+
+/**
+ * @brief 等待指定pid的子进程退出
+ *
+ * @param pid 子进程的pid
+ * @param stat_loc 返回的子进程结束状态
+ * @param options 额外的控制选项
+ * @return pid_t
+ */
+pid_t waitpid(pid_t pid, int *stat_loc, int options);