Replace interrupt masking with spinlock in malloc for SMP support

The original malloc/free implementation used CRITICAL_ENTER() and
CRITICAL_LEAVE() to protect critical sections by simply disabling
interrupts, which is sufficient on single-core systems.

To support SMP, we replace these with a proper spinlock that uses RV32A
atomic instructions. This ensures correctness when multiple harts
access the allocator concurrently.

This change allows future task scheduling across multiple harts without
risking race conditions in the memory allocator.

Author: visitorckw

lib/malloc.c

@@ -1,6 +1,7 @@
 #include <lib/libc.h>
 #include <sys/task.h>
 #include <types.h>
+#include <spinlock.h>
 
 #include "private/utils.h"
 
@@ -24,6 +25,8 @@ typedef struct __memblock {
 static memblock_t *first_free;
 static void *heap_start, *heap_end;
 static uint32_t free_blocks_count; /* track fragmentation */
+static spinlock_t malloc_lock = SPINLOCK_INITIALIZER;
+static uint32_t malloc_flags = 0;
 
 /* Block manipulation macros */
 #define IS_USED(b) ((b)->size & 1L)
@@ -62,13 +65,13 @@ void free(void *ptr)
     if (!ptr)
         return;
 
-    CRITICAL_ENTER();
+    spin_lock_irqsave(&malloc_lock, &malloc_flags);
 
     memblock_t *p = ((memblock_t *) ptr) - 1;
 
     /* Validate the block being freed */
     if (!validate_block(p) || !IS_USED(p)) {
-        CRITICAL_LEAVE();
+        spin_unlock_irqrestore(&malloc_lock, malloc_flags);
         return; /* Invalid or double-free */
     }
 
@@ -100,7 +103,7 @@ void free(void *ptr)
         free_blocks_count--;
     }
 
-    CRITICAL_LEAVE();
+    spin_unlock_irqrestore(&malloc_lock, malloc_flags);
 }
 
 /* Selective coalescing: only when fragmentation becomes significant */
@@ -136,7 +139,7 @@ void *malloc(uint32_t size)
     if (size < MALLOC_MIN_SIZE)
         size = MALLOC_MIN_SIZE;
 
-    CRITICAL_ENTER();
+    spin_lock_irqsave(&malloc_lock, &malloc_flags);
 
     /* Trigger coalescing only when fragmentation is high */
     if (free_blocks_count > COALESCE_THRESHOLD)
@@ -145,7 +148,7 @@ void *malloc(uint32_t size)
     memblock_t *p = first_free;
     while (p) {
         if (!validate_block(p)) {
-            CRITICAL_LEAVE();
+            spin_unlock_irqrestore(&malloc_lock, malloc_flags);
             return NULL; /* Heap corruption detected */
         }
 
@@ -168,13 +171,13 @@ void *malloc(uint32_t size)
             if (free_blocks_count > 0)
                 free_blocks_count--;
 
-            CRITICAL_LEAVE();
+            spin_unlock_irqrestore(&malloc_lock, malloc_flags);
             return (void *) (p + 1);
         }
         p = p->next;
     }
 
-    CRITICAL_LEAVE();
+    spin_unlock_irqrestore(&malloc_lock, malloc_flags);
     return NULL; /* allocation failed */
 }