assembler-0 · assembler-0 · Jul 16, 2025 · Jul 15, 2025 · coderabbitai · Jul 15, 2025
diff --git a/arch/x86_64/interrupts/Interrupts.c b/arch/x86_64/interrupts/Interrupts.c
@@ -57,11 +57,11 @@ static void FatalExceptionHandler(const char* message, uint64_t interrupt_number
 // The C-level interrupt handler
 void InterruptHandler(struct Registers* regs) {
     ASSERT(regs != NULL);
-    if (regs->interrupt_number == 32) {
+    if (regs->interrupt_number == 32 || regs->interrupt_number == 33) { // Force ignore keyboard interrupt
         tick_count++;
         // FastDisplayTicks(tick_count);
         FastSchedule(regs);
-        outb(0x20, 0x20);
+        outb(0x20, 0x20); // EOI to master PIC
         return;
     }
-    if (regs->interrupt_number == 32 || regs->interrupt_number == 33) { // Force ignore keyboard interrupt
-        tick_count++;
-        // FastDisplayTicks(tick_count);
-        FastSchedule(regs);
-        outb(0x20, 0x20);
-        outb(0x20, 0x20); // EOI to master PIC
-        return;
-    }
+    if (regs->interrupt_number == 32) { // Timer interrupt
+        tick_count++;
+        // FastDisplayTicks(tick_count);
+        FastSchedule(regs);
+        outb(0x20, 0x20); // EOI to master PIC
+        return;
+    }
+
+    if (regs->interrupt_number == 33) { // Keyboard interrupt
+        // Handle keyboard input properly
+        HandleKeyboardInterrupt(regs);
+        outb(0x20, 0x20); // EOI to master PIC
+        return;
+    }
-    if (regs->interrupt_number == 32 || regs->interrupt_number == 33) { // Force ignore keyboard interrupt
-        tick_count++;
-        // FastDisplayTicks(tick_count);
-        FastSchedule(regs);
-        outb(0x20, 0x20);
-        outb(0x20, 0x20); // EOI to master PIC
-        return;
-    }
+    if (regs->interrupt_number == 32) { // Timer interrupt
+        tick_count++;
+        // FastDisplayTicks(tick_count);
+        FastSchedule(regs);
+        outb(0x20, 0x20); // EOI to master PIC
+        return;
+    }
+
+    if (regs->interrupt_number == 33) { // Keyboard interrupt
+        // Handle keyboard input properly
+        HandleKeyboardInterrupt(regs);
+        outb(0x20, 0x20); // EOI to master PIC
+        return;
+    }
 
@@ -90,7 +90,8 @@ void InterruptHandler(struct Registers* regs) {
 
     if (regs->error_code & 0x4) {
         PrintKernelError("  Mode: User\n");
-    } else {
+    }
+    else {
         PrintKernelError("  Mode: Supervisor\n");
     }
 
@@ -105,4 +106,4 @@ void InterruptHandler(struct Registers* regs) {
     PANIC_CODE("Page Fault", regs->error_code);
 }
 
-// The C-level interrupt handler
+// The C-level interrupt handler
diff --git a/drivers/Pic.h b/drivers/Pic.h
@@ -1,7 +1,7 @@
 #ifndef PIC_H
 #define PIC_H
 
-#define PIT_FREQUENCY_HZ 1000
+#define PIT_FREQUENCY_HZ 200
 
 void PicInstall();
 void PitInstall();

diff --git a/include/Io.h b/include/Io.h
@@ -13,4 +13,25 @@ static inline uint8_t inb(uint16_t port) {
     return ret;
 }
 
+typedef uint64_t irq_flags_t;
+
+static inline irq_flags_t save_irq_flags(void) {
+    irq_flags_t flags;
+    asm volatile("pushfq\n\tpopq %0" : "=r"(flags));
+    return flags;
+}
+
+static inline void restore_irq_flags(irq_flags_t flags) {
+    asm volatile("pushq %0\n\tpopfq" : : "r"(flags));
+}
+
+static inline void cli(void) {
+    asm volatile("cli");
+}
+
+static inline void sti(void) {
+    asm volatile("sti");
+}
+
 #endif
+
diff --git a/include/stddef.h b/include/stddef.h
@@ -0,0 +1,13 @@
+#ifndef STDDEF_H
+#define STDDEF_H
+
+#include <stdint.h>
+
+#undef size_t
+#define size_t uint64_t
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#endif //STDDEF_H
diff --git a/kernel/atomic/Spinlock.h b/kernel/atomic/Spinlock.h
@@ -2,6 +2,7 @@
 #define SPINLOCK_H
 
 #include "stdint.h"
+#include "Io.h"
 
 // Locks
 static inline void SpinLock(volatile int* lock) {
@@ -14,4 +15,19 @@ static inline void SpinUnlock(volatile int* lock) {
     __sync_lock_release(lock);
 }
 
+// Spinlock with interrupt saving/restoring
+static inline irq_flags_t SpinLockIrqSave(volatile int* lock) {
+    irq_flags_t flags = save_irq_flags();
+    cli();
+    while (__sync_lock_test_and_set(lock, 1)) {
+        while (*lock) __builtin_ia32_pause();
+    }
+    return flags;
+}
+
+static inline void SpinUnlockIrqRestore(volatile int* lock, irq_flags_t flags) {
+    __sync_lock_release(lock);
+    restore_irq_flags(flags);
+}
+
 #endif // SPINLOCK_H
diff --git a/kernel/core/Kernel.c b/kernel/core/Kernel.c
@@ -14,6 +14,7 @@
 #include "stdbool.h"
 #include "Multiboot2.h"
 #include "AsmHelpers.h"
+#include "KernelHeap.h"
 #include "MemOps.h"
 #include "VMem.h"
 #include "Spinlock.h"
@@ -390,7 +391,7 @@ void KernelMain(uint32_t magic, uint32_t info) {
     ParseMultibootInfo(info);
     MemoryInit(g_multiboot_info_addr);
     VMemInit();
-
+    KernelHeapInit();
     uint64_t pml4_phys = VMemGetPML4PhysAddr();
     PrintKernelSuccess("[SYSTEM] Bootstrap: Mapping kernel...\n");
     uint64_t kernel_start = (uint64_t)_kernel_phys_start;

diff --git a/kernel/memory/KernelHeap.c b/kernel/memory/KernelHeap.c
@@ -0,0 +1,115 @@
+#include "KernelHeap.h"
+#include "VMem.h"
+#include "Kernel.h"
+#include "Spinlock.h"
+#include "MemOps.h"
+#include "Panic.h"
+
+// Simple page-based allocator for now.
+// A more sophisticated allocator (e.g., buddy system, slab allocator)
+// would be needed for finer-grained allocations.
+
+// Structure to store metadata for each allocated block
+typedef struct HeapBlockHeader {
+    size_t size; // Size of the user-requested data (not including header)
+} HeapBlockHeader;
+
+static volatile int kheap_lock = 0;
+
+void KernelHeapInit() {
+    // No specific initialization needed for this simple page-based allocator
+    // VMemInit handles the underlying virtual memory setup.
+    PrintKernelSuccess("[SYSTEM] Kernel Heap Initialized (page-based).\n");
+}
+
+void* KernelMemoryAlloc(size_t size) {
+    if (size == 0) {
+        return NULL;
+    }
+
+    irq_flags_t flags = SpinLockIrqSave(&kheap_lock);
+
+    // Calculate total size needed: user data + header
+    size_t total_alloc_size = size + sizeof(HeapBlockHeader);
+
+    // Allocate memory using VMemAlloc, which handles page alignment and mapping
+    void* allocated_ptr = VMemAlloc(total_alloc_size);
+
+    if (allocated_ptr == NULL) {
+        PrintKernelError("[ERROR] KernelMemoryAlloc: Failed to allocate ");
+        PrintKernelInt(size);
+        PrintKernel(" bytes.\n");
+        SpinUnlockIrqRestore(&kheap_lock, flags);
+        return NULL;
+    }
+
+    // Store the size in the header
+    HeapBlockHeader* header = (HeapBlockHeader*)allocated_ptr;
+    header->size = size;
+
+    // Return pointer to the user-accessible memory (after the header)
+    void* user_ptr = (void*)((uint8_t*)allocated_ptr + sizeof(HeapBlockHeader));
+
+    SpinUnlockIrqRestore(&kheap_lock, flags);
+    return user_ptr;
+}
+
+void* KernelCallLocation(size_t num, size_t size) {
+    size_t total_size = num * size;
+    void* ptr = KernelMemoryAlloc(total_size);
+    if (ptr) {
+        FastMemset(ptr, 0, total_size);
+    }
+    return ptr;
+}
-void* KernelCallLocation(size_t num, size_t size) {
-    size_t total_size = num * size;
-    void* ptr = KernelMemoryAlloc(total_size);
-    if (ptr) {
-        FastMemset(ptr, 0, total_size);
-    }
-    return ptr;
-}
+void* KernelCallLocation(size_t num, size_t size) {
+    // Check for multiplication overflow
+    if (num != 0 && size > SIZE_MAX / num) {
+        return NULL;
+    }
+    size_t total_size = num * size;
+    void* ptr = KernelMemoryAlloc(total_size);
+    if (ptr) {
+        FastMemset(ptr, 0, total_size);
+    }
+    return ptr;
+}
-void* KernelCallLocation(size_t num, size_t size) {
-    size_t total_size = num * size;
-    void* ptr = KernelMemoryAlloc(total_size);
-    if (ptr) {
-        FastMemset(ptr, 0, total_size);
-    }
-    return ptr;
-}
+void* KernelCallLocation(size_t num, size_t size) {
+    // Check for multiplication overflow
+    if (num != 0 && size > SIZE_MAX / num) {
+        return NULL;
+    }
+    size_t total_size = num * size;
+    void* ptr = KernelMemoryAlloc(total_size);
+    if (ptr) {
+        FastMemset(ptr, 0, total_size);
+    }
+    return ptr;
+}
+
+void* KernelRealLocation(void* ptr, size_t size) {
+    if (ptr == NULL) {
+        return KernelMemoryAlloc(size);
+    }
+    if (size == 0) {
+        KernelFree(ptr);
+        return NULL;
+    }
+
+    irq_flags_t flags = SpinLockIrqSave(&kheap_lock);
+
+    // Get the original header and size
+    HeapBlockHeader* old_header = (HeapBlockHeader*)((uint8_t*)ptr - sizeof(HeapBlockHeader));
+    size_t old_size = old_header->size;
+
+    // Allocate new memory
+    void* new_ptr = KernelMemoryAlloc(size);
+    if (new_ptr) {
+        // Copy data from old to new, up to the minimum of old_size and new_size
+        FastMemcpy(new_ptr, ptr, (old_size < size) ? old_size : size);
+        // Free the old memory block
+        KernelFree(ptr);
+    } else {
+        PrintKernelError("[ERROR] KernelRealLocation: Failed to reallocate ");
+        PrintKernelInt(size);
+        PrintKernel(" bytes.\n");
+    }
+
+    SpinUnlockIrqRestore(&kheap_lock, flags);
+    return new_ptr;
+}
-void* KernelRealLocation(void* ptr, size_t size) {
-    if (ptr == NULL) {
-        return KernelMemoryAlloc(size);
-    }
-    if (size == 0) {
-        KernelFree(ptr);
-        return NULL;
-    }
-
-    irq_flags_t flags = SpinLockIrqSave(&kheap_lock);
-
-    // Get the original header and size
-    HeapBlockHeader* old_header = (HeapBlockHeader*)((uint8_t*)ptr - sizeof(HeapBlockHeader));
-    size_t old_size = old_header->size;
-
-    // Allocate new memory
-    void* new_ptr = KernelMemoryAlloc(size);
-    if (new_ptr) {
-        // Copy data from old to new, up to the minimum of old_size and new_size
-        FastMemcpy(new_ptr, ptr, (old_size < size) ? old_size : size);
-        // Free the old memory block
-        KernelFree(ptr);
-    } else {
-        PrintKernelError("[ERROR] KernelRealLocation: Failed to reallocate ");
-        PrintKernelInt(size);
-        PrintKernel(" bytes.\n");
-    }
-
-    SpinUnlockIrqRestore(&kheap_lock, flags);
-    return new_ptr;
-}
+void* KernelRealLocation(void* ptr, size_t size) {
+    if (ptr == NULL) {
+        return KernelMemoryAlloc(size);
+    }
+    if (size == 0) {
+        KernelFree(ptr);
+        return NULL;
+    }
+
+    irq_flags_t flags = SpinLockIrqSave(&kheap_lock);
+
+    // Get the original header and size
+    HeapBlockHeader* old_header = (HeapBlockHeader*)((uint8_t*)ptr - sizeof(HeapBlockHeader));
+    size_t old_size = old_header->size;
+
+    // Release lock before calling alloc/free to avoid deadlock
+    SpinUnlockIrqRestore(&kheap_lock, flags);
+
+    // Allocate new memory
+    void* new_ptr = KernelMemoryAlloc(size);
+    if (new_ptr) {
+        // Copy data from old to new, up to the minimum of old_size and new_size
+        FastMemcpy(new_ptr, ptr, (old_size < size) ? old_size : size);
+        // Free the old memory block
+        KernelFree(ptr);
+    } else {
+        PrintKernelError("[ERROR] KernelRealLocation: Failed to reallocate ");
+        PrintKernelInt(size);
+        PrintKernel(" bytes.\n");
+    }
+
+    return new_ptr;
+}
-void* KernelRealLocation(void* ptr, size_t size) {
-    if (ptr == NULL) {
-        return KernelMemoryAlloc(size);
-    }
-    if (size == 0) {
-        KernelFree(ptr);
-        return NULL;
-    }
-
-    irq_flags_t flags = SpinLockIrqSave(&kheap_lock);
-
-    // Get the original header and size
-    HeapBlockHeader* old_header = (HeapBlockHeader*)((uint8_t*)ptr - sizeof(HeapBlockHeader));
-    size_t old_size = old_header->size;
-
-    // Allocate new memory
-    void* new_ptr = KernelMemoryAlloc(size);
-    if (new_ptr) {
-        // Copy data from old to new, up to the minimum of old_size and new_size
-        FastMemcpy(new_ptr, ptr, (old_size < size) ? old_size : size);
-        // Free the old memory block
-        KernelFree(ptr);
-    } else {
-        PrintKernelError("[ERROR] KernelRealLocation: Failed to reallocate ");
-        PrintKernelInt(size);
-        PrintKernel(" bytes.\n");
-    }
-
-    SpinUnlockIrqRestore(&kheap_lock, flags);
-    return new_ptr;
-}
+void* KernelRealLocation(void* ptr, size_t size) {
+    if (ptr == NULL) {
+        return KernelMemoryAlloc(size);
+    }
+    if (size == 0) {
+        KernelFree(ptr);
+        return NULL;
+    }
+
+    irq_flags_t flags = SpinLockIrqSave(&kheap_lock);
+
+    // Get the original header and size
+    HeapBlockHeader* old_header = (HeapBlockHeader*)((uint8_t*)ptr - sizeof(HeapBlockHeader));
+    size_t old_size = old_header->size;
+
+    // Release lock before calling alloc/free to avoid deadlock
+    SpinUnlockIrqRestore(&kheap_lock, flags);
+
+    // Allocate new memory
+    void* new_ptr = KernelMemoryAlloc(size);
+    if (new_ptr) {
+        // Copy data from old to new, up to the minimum of old_size and new_size
+        FastMemcpy(new_ptr, ptr, (old_size < size) ? old_size : size);
+        // Free the old memory block
+        KernelFree(ptr);
+    } else {
+        PrintKernelError("[ERROR] KernelRealLocation: Failed to reallocate ");
+        PrintKernelInt(size);
+        PrintKernel(" bytes.\n");
+    }
+
+    return new_ptr;
+}
+
+void KernelFree(void* ptr) {
+    if (ptr == NULL) {
+        return;
+    }
+
+    irq_flags_t flags = SpinLockIrqSave(&kheap_lock);
+
+    // Get the header by subtracting the header size from the user pointer
+    HeapBlockHeader* header = (HeapBlockHeader*)((uint8_t*)ptr - sizeof(HeapBlockHeader));
+
+    // Get the original allocated size (including header)
+    size_t original_alloc_size = header->size + sizeof(HeapBlockHeader);
+
+    // Free the entire allocated block (including header) using VMemFree
+    VMemFree((void*)header, original_alloc_size);
+
+    SpinUnlockIrqRestore(&kheap_lock, flags);
+}
diff --git a/kernel/memory/KernelHeap.h b/kernel/memory/KernelHeap.h
@@ -0,0 +1,13 @@
+#ifndef KHEAP_H
+#define KHEAP_H
+
+#include "stdint.h"
+#include "stddef.h"
+
+void KernelHeapInit();
+void* KernelMemoryAlloc(size_t size);
+void* KernelCallLocation(size_t num, size_t size);
+void* KernelRealLocation(void* ptr, size_t size);
+void KernelFree(void* ptr);
+
+#endif // KHEAP_H
diff --git a/kernel/memory/Memory.c b/kernel/memory/Memory.c
@@ -19,9 +19,7 @@ static uint64_t memory_start = 0x100000; // Start after 1MB
 
 // Helper to mark a page as used
 static void MarkPageUsed(uint64_t page_idx) {
-    // SpinLock(&memory_lock);
     if (page_idx >= total_pages) {
-        SpinUnlock(&memory_lock);
         return;
     }
     uint64_t byte_idx = page_idx / 8;
@@ -30,14 +28,11 @@ static void MarkPageUsed(uint64_t page_idx) {
         page_bitmap[byte_idx] |= (1 << bit_idx);
         used_pages++;
     }
-    // SpinUnlock(&memory_lock);
 }
 
 // Helper to mark a page as free
 static void MarkPageFree(uint64_t page_idx) {
-    // SpinLock(&memory_lock);
     if (page_idx >= total_pages) {
-        SpinUnlock(&memory_lock);
         return;
     }
     uint64_t byte_idx = page_idx / 8;
@@ -46,7 +41,6 @@ static void MarkPageFree(uint64_t page_idx) {
         page_bitmap[byte_idx] &= ~(1 << bit_idx);
         used_pages--;
     }
-    // SpinUnlock(&memory_lock);
 }
 
 int MemoryInit(uint32_t multiboot_info_addr) {
@@ -146,48 +140,48 @@ int MemoryInit(uint32_t multiboot_info_addr) {
     for (uint64_t i = mb_info_start_page; i < mb_info_end_page; i++) {
         MarkPageUsed(i);
     }
-    // --- END OF REPLACEMENT ---
+    PrintKernelSuccess("[SYSTEM] Physical memory manager initialized");
     return 0;
 }
 
 
 void* AllocPage(void) {
-    // SpinLock(&memory_lock);
+    irq_flags_t flags = SpinLockIrqSave(&memory_lock);
     for (uint64_t i = 0; i < total_pages; i++) {
         uint64_t byte_idx = i / 8;
         uint8_t bit_idx = i % 8;
         if (!(page_bitmap[byte_idx] & (1 << bit_idx))) {
             MarkPageUsed(i);
             void* page = (void*)(i * PAGE_SIZE);
-            // SpinUnlock(&memory_lock);
+            SpinUnlockIrqRestore(&memory_lock, flags);
             return page;
         }
     }
-    // SpinUnlock(&memory_lock);
+    SpinUnlockIrqRestore(&memory_lock, flags);
     return NULL; // Out of memory
 }
 
 void FreePage(void* page) {
-    // SpinLock(&memory_lock);
+    irq_flags_t flags = SpinLockIrqSave(&memory_lock);
     if (!page) {
-        SpinUnlock(&memory_lock);
+        SpinUnlockIrqRestore(&memory_lock, flags);
         Panic("FreePage: NULL pointer");
     }
 
     uint64_t addr = (uint64_t)page;
     if (addr % PAGE_SIZE != 0) {
-        SpinUnlock(&memory_lock);
+        SpinUnlockIrqRestore(&memory_lock, flags);
         Panic("FreePage: Address not page aligned");
     }
 
     uint64_t page_idx = addr / PAGE_SIZE;
     if (page_idx >= total_pages) {
-        SpinUnlock(&memory_lock);
+        SpinUnlockIrqRestore(&memory_lock, flags);
         Panic("FreePage: Page index out of bounds");
     }
 
     MarkPageFree(page_idx);
-    // SpinUnlock(&memory_lock);
+    SpinUnlockIrqRestore(&memory_lock, flags);
 }
 
 uint64_t GetFreeMemory(void) {