ableOS_v1Change/kernel/src/arch/x86_64/mod.rs

use {
    crate::{arch::x86_64::graphics::DISPLAY, bootmodules::BootModule},
    core::arch::asm,
    embedded_graphics::pixelcolor::Rgb888,
    log::warn,
    rdrand::RdSeed,
};
pub mod memory;

mod cpuid;
mod device_info_collector;
mod gdt;
pub mod graphics;
pub(crate) mod interrupts;
pub mod logging;
pub mod pci;
pub mod virtio;

pub use {logging::log, memory::PAGE_SIZE};

use {
    crate::allocator,
    limine::{HhdmRequest, KernelFileRequest, MemmapRequest, ModuleRequest},
    x86_64::VirtAddr,
};

extern "C" {
    fn _initial_kernel_heap_start();
    fn _initial_kernel_heap_size();
}

const INITIAL_KERNEL_HEAP_START: *mut u8 = _initial_kernel_heap_start as _;
const INITIAL_KERNEL_HEAP_SIZE: *const () = _initial_kernel_heap_size as _;

#[no_mangle]
#[naked]
unsafe extern "C" fn _kernel_start() -> ! {
    // Initialise SSE and jump to kernel entrypoint
    core::arch::asm!(
        "mov rax, cr0",
        "and ax, 0xfffb",
        "or ax, 0x2",
        "mov cr0, rax",
        "mov rax, cr4",
        "or ax, 3 << 9",
        "mov cr4, rax",
        "jmp {}",
        sym start,
        options(noreturn),
    )
}

unsafe extern "C" fn start() -> ! {
    logging::init();
    crate::logger::init().expect("failed to set logger");
    log::info!("Initialising AKern {}", crate::VERSION);

    static HDHM_REQ: HhdmRequest = HhdmRequest::new(0);
    memory::init_pt(VirtAddr::new(
        HDHM_REQ
            .get_response()
            .get()
            .expect("tried to get physical memory mapping offset from Limine")
            .offset,
    ));
    allocator::init(INITIAL_KERNEL_HEAP_START, INITIAL_KERNEL_HEAP_SIZE as _);

    static MMAP_REQ: MemmapRequest = MemmapRequest::new(0);
    memory::initialize(
        MMAP_REQ
            .get_response()
            .get()
            .expect("tried to get memory map from Limine")
            .memmap(),
    );

    gdt::init();
    interrupts::init();

    static KFILE_REQ: KernelFileRequest = KernelFileRequest::new(0);
    static MOD_REQ: ModuleRequest = ModuleRequest::new(0);

    device_info_collector::collect_device_info();

    // Graphics test
    {
        graphics::init();
        let mut dis = DISPLAY.lock();
        use embedded_graphics::prelude::RgbColor;

        let _ = dis.set_color(Rgb888::YELLOW);
        let thick = 6;
        let p1 = (400, 30);
        let p2 = (200, 150);
        let p3 = (600, 150);
        let p4 = (200, 350);
        let p5 = (600, 350);
        let p6 = (400, 470);

        {
            //HEXAGON

            let _ = dis.line(p1.0, p1.1, p2.0, p2.1, thick);
            let _ = dis.line(p1.0, p1.1, p3.0, p3.1, thick);
            let _ = dis.line(p2.0, p2.1, p4.0, p4.1, thick);
            let _ = dis.line(p3.0, p3.1, p5.0, p5.1, thick);
            let _ = dis.line(p6.0, p6.1, p4.0, p4.1, thick);
            let _ = dis.line(p6.0, p6.1, p5.0, p5.1, thick);
        }
        {
            let _ = dis.line(600, 150, 200, 350, thick);
            let _ = dis.line(600, 350, 400, 250, thick);
        }

        {
            let _ = dis.set_color(Rgb888::WHITE);
            let hp1 = (350, 150);
            let hp2 = (350, 350);
            let hp3 = (450, 250);
            let hp4 = (350, 250);
            let hp5 = (450, 150);
            let hp6 = (450, 350);

            let _ = dis.line(hp1.0, hp1.1, hp2.0, hp2.1, thick);
            let _ = dis.line(hp3.0, hp3.1, hp4.0, hp4.1, thick);
            let _ = dis.line(hp5.0, hp5.1, hp6.0, hp6.1, thick);
        }

        dis.swap_buffers();
    };

    // TODO: Add in rdseed and rdrand as sources for randomness
    let _rand = xml::XMLElement::new("Random");

    log::trace!("Getting boot modules");
    let bm = MOD_REQ.get_response().get();

    let mut bootmodules = alloc::vec::Vec::new();

    if bm.is_some() {
        let bm = bm.unwrap();
        for x in 0..bm.module_count {
            let file = bm.modules().get(x as usize);
            if file.is_some() {
                let file = file.unwrap();
                let raw_bytes = core::slice::from_raw_parts(
                    file.base.as_ptr().expect("invalid initrd"),
                    file.length as usize,
                )
                .to_vec();

                let file_path = alloc::string::String::from_utf8(
                    file.path.to_str().unwrap().to_bytes().to_vec(),
                );
                if file_path.is_err() {
                    panic!("invalid file path: {:?}", file_path);
                }
                let file_cmd = alloc::string::String::from_utf8(
                    file.cmdline.to_str().unwrap().to_bytes().to_vec(),
                );
                if file_cmd.is_err() {
                    panic!("invalid module cmd: {:?}", file_cmd);
                }

                log::trace!("module path: {:?}", file_path);
                log::trace!("module cmd: {:?}", file_cmd);

                bootmodules.push(BootModule::new(
                    file_path.unwrap(),
                    raw_bytes,
                    file_cmd.unwrap(),
                ));
            } else {
                log::error!("You should not be here");
                break;
            }
        }
        log::info!("Boot module count: {:?}", bootmodules.len());
        assert_eq!(bm.module_count, bootmodules.len() as u64);
    }

    crate::kmain::kmain(
        KFILE_REQ
            .get_response()
            .get()
            .and_then(|r| r.kernel_file.get())
            .expect("failed to get kernel file from Limine")
            .cmdline
            .to_str()
            .map(core::ffi::CStr::to_str)
            .transpose()
            .expect("expected valid cmdline string")
            .unwrap_or_default(),
        bootmodules,
    )
}

/// Spin loop
pub fn spin_loop() -> ! {
    loop {
        x86_64::instructions::hlt();
    }
}

pub fn hardware_random_u64() -> u64 {
    use {log::trace, rdrand::RdRand};
    let gen = RdRand::new();
    match gen {
        Ok(gen) => {
            let ret = gen.try_next_u64().unwrap();
            trace!("Random {}", ret);
            return ret;
        }
        Err(err) => {
            warn!("RDRand not supported.");
            // Try rdseed
            let gen = RdSeed::new();
            match gen {
                Ok(gen) => {
                    let ret = gen.try_next_u64().unwrap();
                    trace!("Random {}", ret);
                    return ret;
                }
                Err(err) => {
                    panic!("Neither RDRand or RDSeed are supported")
                }
            }
        }
    }
}

pub fn get_edid() {}

pub fn register_dump() {
    let rax: u64;
    let rbx: u64 = 0;
    let rcx: u64;
    let rdx: u64;
    let si: u64;
    let di: u64;

    let r8: u64; // TODO: r8-r15
    let r9: u64;
    let r10: u64;
    let r11: u64;
    let r12: u64;
    let r13: u64;
    let r14: u64;
    let r15: u64;

    unsafe {
        asm!("",
        out("rax") rax,
        out("rcx") rcx,
        out("rdx") rdx,
        out("si") si,
        out("di") di,
        out("r8") r8,
        out("r9") r9,
        out("r10") r10,
        out("r11") r11,
        out("r12") r12,
        out("r13") r13,
        out("r14") r14,
        out("r15") r15,
        )
    };

    log::error!(
        "Kernel Panic!\r
Register Dump\r
    rax: {:#x}\r
    rbx: {:#x}\r
    rcx: {:#x}\r
    rdx: {:#x}\r
    si : {:#x}\r
    di : {:#x}\r
    r8 : {:#x}\r
    r9 : {:#x}\r
    r11: {:#x}\r
    r12: {:#x}\r
    r13: {:#x}\r
    r14: {:#x}\r
    r15: {:#x}\r
",
        rax,
        rbx,
        rcx,
        rdx,
        si,
        di,
        r8,
        r9,
        r11,
        r12,
        r13,
        r14,
        r15,
    );
}