Replace interrupt masking with spinlock in semaphore for SMP support

The original semaphore implementation used NOSCHED_ENTER() and
NOSCHED_LEAVE() to protect critical sections by disabling interrupts,
which was sufficient in single-core environments.

To support SMP, we replace these macros with a spinlock based on RV32A
atomic instructions. This ensures safe access to shared semaphore
state, including the count and wait queue, when multiple harts operate
concurrently.

This change is necessary to avoid race conditions during mo_sem_wait(),
mo_sem_signal(), and other semaphore operations under multi-hart
scheduling.

Author: visitorckw

kernel/semaphore.c

@@ -8,6 +8,7 @@
  */
 
 #include <hal.h>
+#include <spinlock.h>
 #include <sys/semaphore.h>
 #include <sys/task.h>
 
@@ -24,6 +25,9 @@ struct sem_t {
 /* Magic number for semaphore validation */
 #define SEM_MAGIC 0x53454D00 /* "SEM\0" */
 
+static spinlock_t semaphore_lock = SPINLOCK_INITIALIZER;
+static uint32_t semaphore_flags = 0;
+
 static inline bool sem_is_valid(const sem_t *s)
 {
     return (s && s->magic == SEM_MAGIC && s->wait_q);
@@ -68,11 +72,11 @@ int32_t mo_sem_destroy(sem_t *s)
     if (!sem_is_valid(s))
         return ERR_FAIL;
 
-    NOSCHED_ENTER();
+    spin_lock_irqsave(&semaphore_lock, &semaphore_flags);
 
     /* Check if any tasks are waiting - unsafe to destroy if so */
     if (queue_count(s->wait_q) > 0) {
-        NOSCHED_LEAVE();
+        spin_unlock_irqrestore(&semaphore_lock, semaphore_flags);
         return ERR_TASK_BUSY;
     }
 
@@ -81,7 +85,7 @@ int32_t mo_sem_destroy(sem_t *s)
     queue_t *wait_q = s->wait_q;
     s->wait_q = NULL;
 
-    NOSCHED_LEAVE();
+    spin_unlock_irqrestore(&semaphore_lock, semaphore_flags);
 
     /* Clean up resources outside critical section */
     queue_destroy(wait_q);
@@ -96,19 +100,19 @@ void mo_sem_wait(sem_t *s)
         panic(ERR_SEM_OPERATION);
     }
 
-    NOSCHED_ENTER();
+    spin_lock_irqsave(&semaphore_lock, &semaphore_flags);
 
     /* Fast path: resource available and no waiters (preserves FIFO) */
     if (s->count > 0 && queue_count(s->wait_q) == 0) {
         s->count--;
-        NOSCHED_LEAVE();
+        spin_unlock_irqrestore(&semaphore_lock, semaphore_flags);
         return;
     }
 
     /* Slow path: must wait for resource */
     /* Verify wait queue has capacity (should never fail for valid semaphore) */
     if (queue_count(s->wait_q) >= s->max_waiters) {
-        NOSCHED_LEAVE();
+        spin_unlock_irqrestore(&semaphore_lock, semaphore_flags);
         panic(ERR_SEM_OPERATION); /* Queue overflow - system error */
     }
 
@@ -133,15 +137,15 @@ int32_t mo_sem_trywait(sem_t *s)
 
     int32_t result = ERR_FAIL;
 
-    NOSCHED_ENTER();
+    spin_lock_irqsave(&semaphore_lock, &semaphore_flags);
 
     /* Only succeed if resource is available AND no waiters (preserves FIFO) */
     if (s->count > 0 && queue_count(s->wait_q) == 0) {
         s->count--;
         result = ERR_OK;
     }
 
-    NOSCHED_LEAVE();
+    spin_unlock_irqrestore(&semaphore_lock, semaphore_flags);
     return result;
 }
 
@@ -155,7 +159,7 @@ void mo_sem_signal(sem_t *s)
     bool should_yield = false;
     tcb_t *awakened_task = NULL;
 
-    NOSCHED_ENTER();
+    spin_lock_irqsave(&semaphore_lock, &semaphore_flags);
 
     /* Check if any tasks are waiting */
     if (queue_count(s->wait_q) > 0) {
@@ -181,7 +185,7 @@ void mo_sem_signal(sem_t *s)
         /* Silently ignore overflow - semaphore remains at max count */
     }
 
-    NOSCHED_LEAVE();
+    spin_unlock_irqrestore(&semaphore_lock, semaphore_flags);
 
     /* Yield outside critical section to allow awakened task to run.
      * This improves responsiveness if the awakened task has higher priority.
@@ -209,9 +213,9 @@ int32_t mo_sem_waiting_count(sem_t *s)
 
     int32_t count;
 
-    NOSCHED_ENTER();
+    spin_lock_irqsave(&semaphore_lock, &semaphore_flags);
     count = queue_count(s->wait_q);
-    NOSCHED_LEAVE();
+    spin_unlock_irqrestore(&semaphore_lock, semaphore_flags);
 
     return count;
 }