new: vma反向映射

kernel/common/Makefile

@@ -10,7 +10,7 @@ $(kernel_common_subdirs): ECHO
 
 	$(MAKE) -C $@ all CFLAGS="$(CFLAGS)" ASFLAGS="$(ASFLAGS)" PIC="$(PIC)"
 
-all: glib.o printk.o cpu.o bitree.o kfifo.o wait_queue.o mutex.o wait.o unistd.o string.o $(kernel_common_subdirs)
+all: glib.o printk.o cpu.o bitree.o kfifo.o wait_queue.o mutex.o wait.o unistd.o string.o semaphore.o $(kernel_common_subdirs)
 
 
 glib.o: glib.c
@@ -42,3 +42,6 @@ unistd.o: unistd.c
 
 string.o: string.c
 	gcc $(CFLAGS) -c string.c -o string.o
+
+semaphore.o: semaphore.c
+	gcc $(CFLAGS) -c semaphore.c -o semaphore.o

kernel/common/semaphore.c

@@ -0,0 +1,43 @@
+#include "semaphore.h"
+#include <sched/sched.h>
+#include <process/process.h>
+
+
+void semaphore_down(semaphore_t *sema)
+{
+    if (atomic_read(&sema->counter) > 0) // 信号量大于0，资源充足
+        atomic_dec(&sema->counter);
+    else // 资源不足，进程休眠
+    {
+        // 将当前进程加入信号量的等待队列
+        wait_queue_node_t wait;
+        wait_queue_init(&wait, current_pcb);
+
+        current_pcb->state = PROC_UNINTERRUPTIBLE;
+
+        list_append(&sema->wait_queue.wait_list, &wait.wait_list);
+
+        // 执行调度
+        sched_cfs();
+    }
+}
+
+void semaphore_up(semaphore_t *sema)
+{
+    if (list_empty(&sema->wait_queue.wait_list)) // 没有进程在等待资源
+    {
+        atomic_inc(&sema->counter);
+    }
+    else    // 有进程在等待资源，唤醒进程
+    {
+
+        wait_queue_node_t *wq = container_of(list_next(&sema->wait_queue.wait_list), wait_queue_node_t, wait_list);
+        list_del(&wq->wait_list);
+
+        wq->pcb->state = PROC_RUNNING;
+        sched_cfs_enqueue(wq->pcb);
+
+        // 当前进程缺少需要的资源，立即标为需要被调度
+        current_pcb->flags |= PF_NEED_SCHED;
+    }
+};

kernel/common/semaphore.h

@@ -12,10 +12,7 @@
 #pragma once
 #include <common/atomic.h>
 
-#include <process/process.h>
-#include <sched/sched.h>
-#include "wait_queue.h"
-
+#include <common/wait_queue.h>
 
 /**
  * @brief 信号量的结构体
@@ -27,13 +24,16 @@ typedef struct
     wait_queue_node_t wait_queue;
 } semaphore_t;
 
+void __semaphore_invoke_sched();
+void __semaphore_sched_enqueue(struct process_control_block *pcb);
+
 /**
  * @brief 初始化信号量
  *
  * @param sema 信号量对象
  * @param count 信号量的初始值
  */
-void semaphore_init(semaphore_t *sema, ul count)
+static __always_inline void semaphore_init(semaphore_t *sema, ul count)
 {
     atomic_set(&sema->counter, count);
     wait_queue_init(&sema->wait_queue, NULL);
@@ -44,40 +44,6 @@ void semaphore_init(semaphore_t *sema, ul count)
  *
  * @param sema
  */
-void semaphore_down(semaphore_t *sema)
-{
-    if (atomic_read(&sema->counter) > 0) // 信号量大于0，资源充足
-        atomic_dec(&sema->counter);
-    else // 资源不足，进程休眠
-    {
-        // 将当前进程加入信号量的等待队列
-        wait_queue_node_t wait;
-        wait_queue_init(&wait, current_pcb);
+void semaphore_down(semaphore_t *sema);
 
-        current_pcb->state = PROC_UNINTERRUPTIBLE;
-
-        list_append(&sema->wait_queue.wait_list, &wait.wait_list);
-
-        // 执行调度
-        sched_cfs();
-    }
-}
-
-void semaphore_up(semaphore_t *sema)
-{
-    if (list_empty(&sema->wait_queue.wait_list)) // 没有进程在等待资源
-    {
-        atomic_inc(&sema->counter);
-    }
-    else    // 有进程在等待资源，唤醒进程
-    {
-
-        wait_queue_node_t *wq = container_of(list_next(&sema->wait_queue.wait_list), wait_queue_node_t, wait_list);
-        list_del(&wq->wait_list);
-
-        wq->pcb->state = PROC_RUNNING;
-        sched_cfs_enqueue(wq->pcb);
-        // 当前进程缺少需要的资源，立即标为需要被调度
-        current_pcb->flags |= PF_NEED_SCHED;
-    }
-}
+void semaphore_up(semaphore_t *sema);

kernel/common/spinlock.h

@@ -18,18 +18,9 @@
  */
 typedef struct
 {
-    __volatile__ char lock; // 1:unlocked 0:locked
+    int8_t lock; // 1:unlocked 0:locked
 } spinlock_t;
 
-/**
- * @brief 初始化自旋锁
- *
- * @param lock
- */
-void spin_init(spinlock_t *lock)
-{
-    lock->lock = 1;
-}
 
 /**
  * @brief 自旋锁加锁
@@ -53,8 +44,8 @@ void spin_lock(spinlock_t *lock)
 
 /**
  * @brief 自旋锁解锁
- * 
- * @param lock 
+ *
+ * @param lock
  */
 void spin_unlock(spinlock_t *lock)
 {
@@ -63,14 +54,26 @@ void spin_unlock(spinlock_t *lock)
                          : "=m"(lock->lock)::"memory");
 }
 
+/**
+ * @brief 初始化自旋锁
+ *
+ * @param lock
+ */
+void spin_init(spinlock_t *lock)
+{
+    barrier();
+    lock->lock = 1;
+    barrier();
+}
+
 /**
  * @brief 自旋锁加锁（不改变自旋锁持有计数）
- * 
+ *
  * @warning 慎用此函数，除非你有十足的把握不会产生自旋锁计数错误
  */
 void spin_lock_no_preempt(spinlock_t *lock)
 {
-     __asm__ __volatile__("1:    \n\t"
+    __asm__ __volatile__("1:    \n\t"
                          "lock decq %0   \n\t" // 尝试-1
                          "jns 3f    \n\t"      // 加锁成功，跳转到步骤3
                          "2:    \n\t"          // 加锁失败，稍后再试
@@ -83,17 +86,15 @@ void spin_lock_no_preempt(spinlock_t *lock)
 }
 /**
  * @brief 自旋锁解锁（不改变自旋锁持有计数）
- * 
+ *
  * @warning 慎用此函数，除非你有十足的把握不会产生自旋锁计数错误
  */
-void spin_unlock_no_preempt(spinlock_t * lock)
+void spin_unlock_no_preempt(spinlock_t *lock)
 {
     __asm__ __volatile__("movq $1, %0   \n\t"
                          : "=m"(lock->lock)::"memory");
 }
 
-
-
 /**
  * @brief 尝试加锁
  *
@@ -125,7 +126,7 @@ long spin_trylock(spinlock_t *lock)
 
 /**
  * @brief 保存中断状态，关闭中断，并自旋锁加锁
- * 
+ *
  */
 #define spin_lock_irqsave(lock, flags) \
     do                                 \
@@ -136,7 +137,7 @@ long spin_trylock(spinlock_t *lock)
 
 /**
  * @brief 恢复rflags以及中断状态并解锁自旋锁
- * 
+ *
  */
 #define spin_unlock_irqrestore(lock, flags) \
     do                                      \
@@ -147,7 +148,7 @@ long spin_trylock(spinlock_t *lock)
 
 /**
  * @brief 关闭中断并加锁
- * 
+ *
  */
 #define spin_lock_irq(lock)  \
     do                       \
@@ -158,7 +159,7 @@ long spin_trylock(spinlock_t *lock)
 
 /**
  * @brief 解锁并开启中断
- * 
+ *
  */
 #define spin_unlock_irq(lock) \
     do                        \