feat(memory): 实现动态堆内存增长和内存保护机制

Author: moyanj

.gitignore

@@ -15,4 +15,6 @@ AGENTS.md
 
 assets/initrd.cpio
 
-book/
+book/
+
+.sisyphus/

kernel/linker.ld

@@ -18,37 +18,45 @@ SECTIONS {
 
     /* Code (text) sections */
     .text : {
+        __text_start = .;
         *(.text .text.*)
+        __text_end = .;
     } :text
 
     /* Move to the next memory page */
     . = ALIGN(CONSTANT(MAXPAGESIZE));
 
     /* Read-only data (rodata) sections */
     .rodata : {
+        __rodata_start = .;
         *(.rodata .rodata.*)
+        __rodata_end = .;
     } :rodata
 
     /* Move to the next memory page */
     . = ALIGN(CONSTANT(MAXPAGESIZE));
 
     /* Data sections */
     .data : {
+        __data_start = .;
         *(.data .data.*)
 
         /* Place the sections that contains the limine request */
         KEEP(*(.requests_start_marker))
         KEEP(*(.requests))
         KEEP(*(.requests_end_marker))
+        __data_end = .;
     } :data
 
     /* Move to the next memory page */
     . = ALIGN(CONSTANT(MAXPAGESIZE));
 
     /* BSS sections */
     .bss : {
+        __bss_start = .;
         *(.bss .bss.*)
         *(COMMON)
+        __bss_end = .;
     } :bss
 
     /* Something we want to discard */

kernel/src/interrupts/handler.rs

@@ -80,10 +80,17 @@ pub extern "x86-interrupt" fn pagefault_handler(
         Err(_) => VirtAddr::zero(),
     };
 
+    {
+        let mut ms_lock = crate::memory::vmm::KERNEL_MEMORY_SET.lock();
+        if let Some(ms) = ms_lock.as_mut() {
+            if ms.handle_page_fault(fault_address).is_ok() {
+                return;
+            }
+        }
+    }
+
     serial_println!(
-        "EXCEPTION: PAGE FAULT at {:#x}\n \
-         Cause: {:?}\n \
-         Frame: {:#?}",
+        "EXCEPTION: PAGE FAULT at {:#x}\n          Cause: {:?}\n          Frame: {:#?}",
         fault_address,
         error_code,
         stack_frame

kernel/src/lib.rs

@@ -10,6 +10,9 @@
 #![feature(abi_x86_interrupt)]
 #![test_runner(crate::test::test_runner)]
 #![reexport_test_harness_main = "test_main"]
+
+extern crate alloc;
+
 pub mod drivers;
 pub mod fs;
 pub mod graphics;

kernel/src/main.rs

@@ -28,15 +28,17 @@ pub extern "C" fn kernel_main() -> ! {
     // Check is limine version supported
     assert!(BASE_REVISION.is_supported(), "Limine version not supported");
 
-    // Init
+    // Init interrupts early for Page Fault handling during memory init
+    proka_kernel::interrupts::gdt::init(); // Initialize GDT
+    proka_kernel::interrupts::idt::init_idt(); // Initialize IDT
+    proka_kernel::interrupts::pic::init(); // Initialize PIC
+
+    // Init memory management
     proka_kernel::memory::init(); // Initialize memory management
     proka_kernel::drivers::init_devices(); // Initialize devices
     proka_kernel::libs::time::init(); // Init time system
     proka_kernel::libs::logger::init_logger(); // Init log system
     proka_kernel::libs::initrd::load_initrd(); // Load initrd
-    proka_kernel::interrupts::gdt::init(); // Initialize GDT
-    proka_kernel::interrupts::idt::init_idt(); // Initialize IDT
-    proka_kernel::interrupts::pic::init(); // Initialize PIC
     x86_64::instructions::interrupts::enable(); // Enable interrupts
 
     #[allow(unused_parens)]

kernel/src/memory/allocator.rs

@@ -1,10 +1,10 @@
 //! Heap allocator module
 //!
 //! This module implements the heap allocator for the kernel.
-//! It uses the `linked_list_allocator` crate to manage heap memory.
+//! It uses the `talc` crate to manage heap memory with dynamic growth support.
 
 use crate::config::KERNEL_DEFAULT_HEAP_SIZE;
-use talc::{ClaimOnOom, Span, Talc, Talck};
+use talc::{Span, Talc, Talck};
 use x86_64::{
     structures::paging::{
         mapper::MapToError, FrameAllocator, Mapper, Page, PageTableFlags, Size4KiB,
@@ -15,31 +15,77 @@ use x86_64::{
 /// The starting virtual address of the heap
 pub const HEAP_START: usize = 0x_4444_4444_0000;
 
+/// OOM handler for the kernel heap
+pub struct KernelOomHandler;
+
+impl talc::OomHandler for KernelOomHandler {
+    fn handle_oom(talc: &mut Talc<Self>, _layout: core::alloc::Layout) -> Result<(), ()> {
+        // Expand by 1MB at least
+        let expand_size = 1024 * 1024;
+        
+        let mut ms_lock = crate::memory::vmm::KERNEL_MEMORY_SET.lock();
+        let memory_set = ms_lock.as_mut().ok_or(())?;
+        
+        // Find heap area
+        let (old_end, new_end) = {
+            let heap_area = memory_set.areas.iter_mut().find(|a| a.name == "heap").ok_or(())?;
+            let old_end = heap_area.end;
+            let new_end = old_end + expand_size;
+            heap_area.end = new_end;
+            (old_end, new_end)
+        };
+        
+        // Map the new pages MANUALLY to avoid deadlock via #PF
+        let page_range = {
+            let start_page = Page::containing_address(old_end);
+            let end_page = Page::containing_address(new_end - 1u64);
+            Page::range_inclusive(start_page, end_page)
+        };
+        
+        let memory_map_response = crate::MEMORY_MAP_REQUEST
+            .get_response()
+            .expect("Failed to get memory map response");
+        let mut frame_allocator = unsafe { crate::memory::paging::init_frame_allocator(memory_map_response) };
+        
+        for page in page_range {
+            let frame = frame_allocator.allocate_frame().ok_or(())?;
+            let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE | PageTableFlags::NO_EXECUTE;
+            unsafe {
+                memory_set.page_table.map_to(page, frame, flags, &mut frame_allocator).map_err(|_| ())?.flush();
+            }
+        }
+        
+        drop(ms_lock); 
+        
+        unsafe {
+            talc.claim(Span::new(old_end.as_mut_ptr(), new_end.as_mut_ptr())).map_err(|_| ())?;
+        }
+        
+        Ok(())
+    }
+}
+
 #[global_allocator]
-pub static ALLOCATOR: Talck<spin::Mutex<()>, ClaimOnOom> = Talc::new(unsafe {
-    // if we're in a hosted environment, the Rust runtime may allocate before
-    // main() is called, so we need to initialize the arena automatically
-    ClaimOnOom::new(Span::empty())
-})
-.lock();
+pub static ALLOCATOR: Talck<spin::Mutex<()>, KernelOomHandler> = Talc::new(KernelOomHandler).lock();
 
 /// Initialize the heap
 ///
-/// This function maps the heap memory region and initializes the global allocator.
+/// This function initializes the global allocator with a small pre-mapped area.
 ///
 /// # Arguments
 /// * `mapper` - The page table mapper
 /// * `frame_allocator` - The frame allocator
 ///
 /// # Returns
 /// * `Ok(())` on success
-/// * `Err(MapToError)` on failure
 pub fn init_heap(
     mapper: &mut impl Mapper<Size4KiB>,
     frame_allocator: &mut impl FrameAllocator<Size4KiB>,
 ) -> Result<(), MapToError<Size4KiB>> {
     let heap_start = VirtAddr::new(HEAP_START as u64);
-    let heap_end = heap_start + KERNEL_DEFAULT_HEAP_SIZE;
+    // Map initial 64KB for boot-strapping VMM
+    let initial_size = 64 * 1024;
+    let heap_end = heap_start + initial_size;
 
     let page_range = {
         let heap_start_page = Page::containing_address(heap_start);
@@ -51,7 +97,7 @@ pub fn init_heap(
         let frame = frame_allocator
             .allocate_frame()
             .ok_or(MapToError::FrameAllocationFailed)?;
-        let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
+        let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE | PageTableFlags::NO_EXECUTE;
         unsafe {
             mapper.map_to(page, frame, flags, frame_allocator)?.flush();
         }

kernel/src/memory/mod.rs

@@ -2,6 +2,7 @@ pub mod allocator;
 pub mod frame_allocator;
 pub mod paging;
 pub mod protection;
+pub mod vmm;
 
 pub fn init() {
     let memory_map_response = crate::MEMORY_MAP_REQUEST
@@ -10,8 +11,13 @@ pub fn init() {
     let hhdm_offset = paging::get_hhdm_offset();
     let mut mapper = unsafe { paging::init_offset_page_table(hhdm_offset) };
     let mut frame_allocator = unsafe { paging::init_frame_allocator(memory_map_response) };
+
+    // 1. Initialize heap with a small pre-mapped area for bootstrapping
     allocator::init_heap(&mut mapper, &mut frame_allocator).expect("Failed to init heap");
 
+    // 2. Initialize VMM (uses heap for VMAs)
+    vmm::init(mapper);
+
     // Print memory stats
     paging::print_memory_stats(&frame_allocator);
 }