Function kernel_main

bootloader/kernel/src/main.rs:204–429

(boot_info: &'static mut BootInfo)

entry_point!(kernel_main, config = &BOOTLOADER_CONFIG);

fn kernel_main(boot_info: &'static mut BootInfo) -> ! {
    gdt::init();
    interrupts::init_idt();

    let framebuffer = boot_info.framebuffer.as_mut().unwrap();
    let fbinfo = framebuffer.info();

    let fbm = framebuffer.buffer_mut();
    let fbm2 = unsafe {
        let p = fbm.as_mut_ptr();
        slice::from_raw_parts_mut(p, fbinfo.byte_len)
    };
    init_logger(fbm, fbinfo.clone(), LevelFilter::Trace, true, true);

    // x86_64::instructions::interrupts::int3();
    let virtual_full_mapping_offset = VirtAddr::new(
        boot_info
            .physical_memory_offset
            .into_option()
            .expect("no physical_memory_offset"),
    );
    log::info!("physical_memory_offset {:x}", virtual_full_mapping_offset);
    unsafe {
        VIRTUAL_MAPPING_OFFSET = virtual_full_mapping_offset;
    }
    let mapper = unsafe { memory::init(virtual_full_mapping_offset) };
    let frame_allocator = unsafe { BootInfoFrameAllocator::init(&boot_info.memory_regions) };
    MAPPER.init_once(|| Mutex::new(mapper));
    FRAME_ALLOCATOR.init_once(|| Mutex::new(frame_allocator));
    {
        log::info!("Complete Bootloader Map physical memory");
        type VirtualMappingPageSize = Size2MiB; // Size2MiB;Size1GiB Size4KiB

        let start_frame: PhysFrame<VirtualMappingPageSize> =
            PhysFrame::containing_address(PhysAddr::new(0));
        let max_phys = PhysAddr::new(virtual_full_mapping_offset.as_u64() - 1u64);
        let max_phys = PhysAddr::new(Size1GiB::SIZE * 64 - 1);

        let end_frame: PhysFrame<VirtualMappingPageSize> = PhysFrame::containing_address(max_phys);

        use x86_64::structures::paging::PageSize;
        let mut news = 0;
        let mut olds = 0;
        for frame in PhysFrame::range_inclusive(start_frame, end_frame) {
            let page: Page<VirtualMappingPageSize> = Page::containing_address(
                virtual_full_mapping_offset + frame.start_address().as_u64(),
            );
            let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
            match unsafe {
                MAPPER.get_unchecked().lock().map_to(
                    page,
                    frame,
                    flags,
                    &mut *FRAME_ALLOCATOR.get_unchecked().lock(),
                )
            } {
                Ok(tlb) => {
                    tlb.flush();