Function init

kernel/src/memory.rs:46–86

Initialize a new OffsetPageTable. This function must be only called once to avoid aliasing `&mut` references (which is undefined behavior).

(boot_info: &'static BootInfo)

/// This function must be only called once to avoid aliasing `&mut`
/// references (which is undefined behavior).
pub fn init(boot_info: &'static BootInfo) {
    use x86_64::instructions::interrupts;

    interrupts::without_interrupts(|| {
        let mut memory_size = 0;
        for region in boot_info.memory_map.iter() {
            let start_addr = region.range.start_addr();
            let end_addr = region.range.end_addr();
            memory_size += end_addr - start_addr;
            println!("MEM [{:#016X}-{:#016X}] {:?}", start_addr, end_addr, region.region_type);
        }
        println!("Memory size: {} KB\n", memory_size >> 10);

        let physical_memory_offset = VirtAddr::new(boot_info.physical_memory_offset);

        println!("Physical memory offset: {:#016X}", physical_memory_offset.as_u64());

        let level_4_table = unsafe {active_level_4_table(physical_memory_offset)};

        // Initialise the memory mapper
        let mut mapper = unsafe {OffsetPageTable::new(level_4_table, physical_memory_offset)};
        let mut frame_allocator = unsafe {
            MultilevelBitmapFrameAllocator::init(&boot_info.memory_map,
                                                 physical_memory_offset)
        };

        allocator::init_heap(&mut mapper, &mut frame_allocator)
            .expect("heap initialization failed");

        kernel_info::init(&mut frame_allocator, physical_memory_offset)
            .expect("KernelInfo initialization failed");

        // Store boot_info for later calls
        unsafe { MEMORY_INFO = Some(MemoryInfo {
            boot_info,
            physical_memory_offset,
            frame_allocator,
            kernel_l4_table: level_4_table
        }) };
    });
}

/// This should only be called from the init function
/// because each call will result in a mutable reference