upd sector count and add alloc_irq_test functionality

Author: tas0dev

src/boot/config.inc

@@ -1,5 +1,5 @@
 KERNEL_OFFSET EQU 0x10000       ; カーネルをロードするアドレス
-SECTOR_COUNT  EQU 31            ; 読み込むセクタの数
+SECTOR_COUNT  EQU 33            ; 読み込むセクタの数
 START_SECTOR  EQU 2             ; 開始するセクタ番号
 CYLINDER_NUM  EQU 0             ; シリンダ番号
 HEAD_NUM      EQU 0             ; ヘッド番号

src/include/tests/define.h

@@ -11,6 +11,8 @@
 #define INTERRUPT_TEST
 // 割り込みベクタのテスト
 #define INTERRUPT_VECTOR_TEST
+// 割り込みハンドラでメモリのテスト
+#define ALLOC_IRQ_TEST
 
 /* -------- 宣言 -------- */
 #ifdef MEM_TEST
@@ -25,6 +27,10 @@ void interrupt_test();
 void interrupt_vector_test();
 #endif /* INTERRUPT_VECTOR_TEST */
 
+#ifdef ALLOC_IRQ_TEST
+void alloc_irq_test();
+#endif /* ALLOC_IRQ_TEST */
+
 #endif /* TEST_TRUE */
 
 #endif /* _TESTS_CONFIG_H */

src/kernel/mem/map.c

@@ -14,6 +14,11 @@
 
 static uint32_t bitmap[(MAX_FRAMES + 31) / 32];
 
+/* protect bitmap operations */
+static volatile uint32_t memmap_lock_storage = 0;
+// reuse existing spinlock type via pointer cast to avoid header include cycles
+// we'll wrap with helper functions below
+
 // 管理情報をまとめた構造体
 static memmap_t memmap = {0};
 
@@ -60,8 +65,15 @@ void memmap_init(uint32_t start, uint32_t end) {
         memmap.bitmap = bitmap;
 
         // ビットマップをクリア（0 = free）
-        for (uint32_t i = 0; i < (memmap.frames + 31) / 32; ++i) {
-                memmap.bitmap[i] = 0;
+        {
+                uint32_t flags = 0;
+                extern void spin_lock_irqsave(volatile uint32_t *lock, uint32_t *flagsptr);
+                extern void spin_unlock_irqrestore(volatile uint32_t *lock, uint32_t flags);
+                spin_lock_irqsave(&memmap_lock_storage, &flags);
+                for (uint32_t i = 0; i < (memmap.frames + 31) / 32; ++i) {
+                        memmap.bitmap[i] = 0;
+                }
+                spin_unlock_irqrestore(&memmap_lock_storage, flags);
         }
 
         printk("MemoryMap initialized: frames=%u start_frame=%u\n", (unsigned int)memmap.frames, (unsigned int)memmap.start_frame);
@@ -77,14 +89,20 @@ void* alloc_frame(void) {
                 return NULL;
         }
 
+        uint32_t flags = 0;
+        extern void spin_lock_irqsave(volatile uint32_t *lock, uint32_t *flagsptr);
+        extern void spin_unlock_irqrestore(volatile uint32_t *lock, uint32_t flags);
+        spin_lock_irqsave(&memmap_lock_storage, &flags);
         for (uint32_t i = 0; i < memmap.frames; ++i) {
                 if (!bitmap_test(i)) {
                         bitmap_set(i);
                         uint32_t frame_no = memmap.start_frame + i;
                         void* addr = (void*)(frame_no * FRAME_SIZE);
+                        spin_unlock_irqrestore(&memmap_lock_storage, flags);
                         return addr;
                 }
         }
+        spin_unlock_irqrestore(&memmap_lock_storage, flags);
 
         return NULL; // 空き無し
 }
@@ -116,7 +134,14 @@ void free_frame(void* addr) {
                 return;
         }
 
-        bitmap_clear(idx);
+        {
+                uint32_t flags = 0;
+                extern void spin_lock_irqsave(volatile uint32_t *lock, uint32_t *flagsptr);
+                extern void spin_unlock_irqrestore(volatile uint32_t *lock, uint32_t flags);
+                spin_lock_irqsave(&memmap_lock_storage, &flags);
+                bitmap_clear(idx);
+                spin_unlock_irqrestore(&memmap_lock_storage, flags);
+        }
 }
 
 /**
@@ -125,7 +150,14 @@ void free_frame(void* addr) {
  * @return 管理しているフレーム数
  */
 uint32_t frame_count(void) {
-        return memmap.frames;
+        uint32_t f = 0;
+        uint32_t flags = 0;
+        extern void spin_lock_irqsave(volatile uint32_t *lock, uint32_t *flagsptr);
+        extern void spin_unlock_irqrestore(volatile uint32_t *lock, uint32_t flags);
+        spin_lock_irqsave(&memmap_lock_storage, &flags);
+        f = memmap.frames;
+        spin_unlock_irqrestore(&memmap_lock_storage, flags);
+        return f;
 }
 
 
@@ -148,8 +180,15 @@ void memmap_reserve(uint32_t start, uint32_t end) {
         uint32_t s = (start_frame < memmap.start_frame) ? 0 : (start_frame - memmap.start_frame);
         uint32_t e = (end_frame > memmap.start_frame + memmap.frames) ? memmap.frames : (end_frame - memmap.start_frame);
 
-        for (uint32_t i = s; i < e; ++i) {
-                bitmap_set(i);
+        {
+                uint32_t flags = 0;
+                extern void spin_lock_irqsave(volatile uint32_t *lock, uint32_t *flagsptr);
+                extern void spin_unlock_irqrestore(volatile uint32_t *lock, uint32_t flags);
+                spin_lock_irqsave(&memmap_lock_storage, &flags);
+                for (uint32_t i = s; i < e; ++i) {
+                        bitmap_set(i);
+                }
+                spin_unlock_irqrestore(&memmap_lock_storage, flags);
         }
 }
 

src/kernel/tests/alloc_irq_test.c

@@ -0,0 +1,35 @@
+#include <tests/define.h>
+
+#ifdef ALLOC_IRQ_TEST
+
+#include <config.h>
+#include <console.h>
+#include <interrupt/irq.h>
+#include <mem/map.h>
+
+static void irq_alloc_handler(uint32_t payload, void* ctx) {
+        (void)ctx; (void)payload;
+        void* a = alloc_frame();
+        if (a) {
+                printk("alloc_irq: alloc_frame -> %x\n", (unsigned)a);
+                free_frame(a);
+                printk("alloc_irq: free_frame done\n");
+        } else {
+                printk("alloc_irq: alloc_frame failed\n");
+        }
+}
+
+void alloc_irq_test() {
+        /* register handler to IRQ 2 (arbitrary) */
+        interrupt_register(2, irq_alloc_handler, NULL);
+
+        /* simulate IRQ 2 events */
+        for (int i = 0; i < 4; ++i) {
+                interrupt_raise((2u << 16) | (uint32_t)i);
+        }
+
+        /* dispatch queued events synchronously */
+        interrupt_dispatch_all();
+}
+
+#endif /* ALLOC_IRQ_TEST */

src/kernel/tests/run.c

@@ -7,13 +7,25 @@ void run_test() {
         printk("> MEMORY TEST\n");
         mem_test();
         #endif
+
         new_line();
+
         #ifdef INTERRUPT_TEST
         printk("> INTERRUPT TEST\n");
         interrupt_test();
         #endif
+
+        new_line();
+
         #ifdef INTERRUPT_VECTOR_TEST
         printk("> INTERRUPT VECTOR TEST\n");
         interrupt_vector_test();
         #endif
+
+        new_line();
+
+        #ifdef ALLOC_IRQ_TEST
+        printk("> ALOOC IRQ TEST\n");
+        alloc_irq_test();
+        #endif
 }