139 lines
4.6 KiB
Rust
139 lines
4.6 KiB
Rust
// Copyright (c) 2025 shibedrill
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
const PAGE_SIZE: usize = 4096;
|
|
|
|
use crate::boot::modules::MODULE_RESPONSE;
|
|
use crate::boot::params::EXECUTABLE_FILE_RESPONSE;
|
|
use crate::{LOGGER, LogLevel, format};
|
|
use alloc::string::String;
|
|
|
|
use lazy_static::lazy_static;
|
|
use limine::memmap::*;
|
|
use limine::request::{ExecutableAddressRequest, HhdmRepsonse, HhdmRequest};
|
|
use limine::request::{MemmapRequest, MemmapResponse};
|
|
use talc::*;
|
|
|
|
pub extern crate alloc;
|
|
|
|
pub mod paging;
|
|
|
|
lazy_static! {
|
|
pub static ref MEMMAP_RESPONSE: &'static MemmapResponse = MEMMAP_REQUEST
|
|
.response()
|
|
.expect("Bootloader did not supply memory map");
|
|
}
|
|
|
|
pub fn log_memory() {
|
|
if !MEMMAP_RESPONSE.entries().is_empty() {
|
|
let mut log_msg: String = String::from("Memory map:");
|
|
let mut usable: u64 = 0;
|
|
let mut reclaimable: u64 = 0;
|
|
let mut hardware: u64 = 0;
|
|
let mut unusable: u64 = 0;
|
|
for entry in MEMMAP_RESPONSE.entries() {
|
|
log_msg.push_str(&format!(
|
|
"\n\t0x{:x} bytes ({} pages) @ 0x{:x}: {}",
|
|
entry.length,
|
|
entry.length as usize / PAGE_SIZE,
|
|
entry.base,
|
|
match entry.type_ {
|
|
MEMMAP_ACPI_NVS => {
|
|
hardware += entry.length;
|
|
"ACPI (reserved)"
|
|
}
|
|
MEMMAP_ACPI_RECLAIMABLE => {
|
|
reclaimable += entry.length;
|
|
"ACPI (reclaimable)"
|
|
}
|
|
MEMMAP_BAD_MEMORY => {
|
|
unusable += entry.length;
|
|
"damaged/unusable"
|
|
}
|
|
MEMMAP_BOOTLOADER_RECLAIMABLE => {
|
|
reclaimable += entry.length;
|
|
"bootloader (reclaimable)"
|
|
}
|
|
MEMMAP_EXECUTABLE_AND_MODULES => {
|
|
unusable += entry.length;
|
|
"executable & modules"
|
|
}
|
|
MEMMAP_FRAMEBUFFER => {
|
|
hardware += entry.length;
|
|
"framebuffer"
|
|
}
|
|
MEMMAP_RESERVED => {
|
|
unusable += entry.length;
|
|
"reserved"
|
|
}
|
|
MEMMAP_USABLE => {
|
|
usable += entry.length;
|
|
"usable"
|
|
}
|
|
_ => "unidentified",
|
|
}
|
|
));
|
|
}
|
|
log_trace!("{log_msg}");
|
|
let total = usable + reclaimable + hardware + unusable;
|
|
log_info!(
|
|
"Memory report: \n\tFree: 0x{usable:x}\n\tAvailable: 0x{reclaimable:x}\n\tUsable: 0x{:x}\n\tHardware: 0x{hardware:x}\n\tUnusable: 0x{unusable:x}\n\tTotal: 0x{total:x}",
|
|
usable + reclaimable,
|
|
);
|
|
} else {
|
|
panic!("Memory map contains no entries");
|
|
}
|
|
}
|
|
|
|
pub fn log_address() {
|
|
if let Some(resp) = ADDRESS_REQUEST.response() {
|
|
log_info!("Kernel physical start address: 0x{:x}", resp.physical_base);
|
|
log_info!("Kernel virtual start address: 0x{:x}", resp.virtual_base);
|
|
log_info!(
|
|
"Kernel physical start address (calculated): 0x{:x}",
|
|
0i64 - resp.virtual_base as i64 + resp.physical_base as i64
|
|
);
|
|
} else {
|
|
log_warning!("No kernel address response provided.");
|
|
}
|
|
log_info!(
|
|
"Higher Half direct map offset: 0x{:x}",
|
|
HHDM_RESPONSE.offset
|
|
);
|
|
}
|
|
|
|
// Have to initialize all of these before reclaiming bootloader memory
|
|
pub fn init_statics() {
|
|
let _ = EXECUTABLE_FILE_RESPONSE;
|
|
let _ = HHDM_RESPONSE;
|
|
let _ = MODULE_RESPONSE;
|
|
let _ = MEMMAP_RESPONSE;
|
|
}
|
|
|
|
#[used]
|
|
#[unsafe(link_section = ".requests")]
|
|
pub static ADDRESS_REQUEST: ExecutableAddressRequest =
|
|
limine::request::ExecutableAddressRequest::new();
|
|
|
|
#[used]
|
|
#[unsafe(link_section = ".requests")]
|
|
pub static MEMMAP_REQUEST: MemmapRequest = limine::request::MemmapRequest::new();
|
|
|
|
#[used]
|
|
#[unsafe(link_section = ".requests")]
|
|
pub static HHDM_REQUEST: HhdmRequest = limine::request::HhdmRequest::new();
|
|
|
|
lazy_static! {
|
|
pub static ref HHDM_RESPONSE: &'static HhdmRepsonse = HHDM_REQUEST
|
|
.response()
|
|
.expect("Did not get HHDM response from bootloader");
|
|
}
|
|
|
|
// TODO: 1mb kernel heap. Need to figure out how to make this less stupid...
|
|
static mut ARENA: [u8; 100000] = [0; 100000];
|
|
|
|
#[global_allocator]
|
|
static ALLOCATOR: Talck<spin::Mutex<()>, ClaimOnOom> =
|
|
Talc::new(unsafe { ClaimOnOom::new(Span::from_array(core::ptr::addr_of!(ARENA).cast_mut())) })
|
|
.lock();
|