zoeissleeping/dusk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: frame allocation

Browse Source
This commit is contained in:
Zoe
2026-08-19 09:58:43 -05:00
parent 2a1bf17d8b
commit 35d18495ec
7 changed files with 498 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/arch/x86_64/gdt.rs
+1
View File
@@ -50,6 +50,7 @@ pub(super) const KERNEL_DATA_SELECTOR: u16 = 2 * 8;
pub(super) const TSS_SELECTOR: u16 = 3 * 8;
#[repr(align(16))]
#[allow(dead_code)] // field 0 is read, rust just cant tell
struct ExceptionStack([u8; DOUBLE_FAULT_STACK_SIZE]);
static mut GDT: Gdt = Gdt::new();
src/arch/x86_64/interrupts/exceptions.rs
+5 -14
View File
@@ -19,22 +19,10 @@ macro_rules! fatal_with_error_code {
};
}
extern "x86-interrupt" fn debug_handler(frame: InterruptStackFrame) {
fatal_exception("DEBUG EXCEPTION", &frame, None);
}
extern "x86-interrupt" fn non_maskable_interrupt_handler(frame: InterruptStackFrame) {
fatal_exception("NON-MASKABLE INTERRUPT", &frame, None);
}
extern "x86-interrupt" fn breakpoint_handler(frame: InterruptStackFrame) {
report_exception("BREAKPOINT", &frame, None);
}
extern "x86-interrupt" fn double_fault_handler(frame: InterruptStackFrame, error_code: u64) {
fatal_exception("DOUBLE FAULT", &frame, Some(error_code));
}
extern "x86-interrupt" fn page_fault_handler(frame: InterruptStackFrame, error_code: u64) {
report_exception("PAGE FAULT", &frame, Some(error_code));
println!("Faulting address: {:#X}", read_cr2());
@@ -43,12 +31,15 @@ extern "x86-interrupt" fn page_fault_handler(frame: InterruptStackFrame, error_c
}
fatal_without_error_code!(divide_error_handler, "DIVIDE ERROR");
fatal_without_error_code!(debug_handler, "DEBUG EXCEPTION");
fatal_without_error_code!(non_maskable_interrupt_handler, "NON-MASKABLE INTERRUPT");
fatal_without_error_code!(invalid_opcode_handler, "INVALID OPCODE");
fatal_without_error_code!(device_not_available_handler, "DEVICE NOT AVAILABLE");
fatal_without_error_code!(x87_floating_point_handler, "X87 FLOATING-POINT EXCEPTION");
fatal_without_error_code!(machine_check_handler, "MACHINE CHECK");
fatal_without_error_code!(simd_floating_point_handler, "SIMD FLOATING-POINT EXCEPTION");
fatal_with_error_code!(double_fault_handler, "DOUBLE FAULT");
fatal_with_error_code!(invalid_tss_handler, "INVALID TSS");
fatal_with_error_code!(segment_not_present_handler, "SEGMENT NOT PRESENT");
fatal_with_error_code!(stack_segment_fault_handler, "STACK-SEGMENT FAULT");
@@ -134,10 +125,10 @@ fn report_exception(name: &'static str, frame: &InterruptStackFrame, error_code:
"kernel"
}
);
println!("RIP: {:#X}", frame.instruction_pointer.as_u64());
println!("RIP: {:#X}", frame.instruction_pointer.as_usize());
println!("CS: {:#X}", frame.code_segment);
println!("FLAGS: {:#X}", frame.cpu_flags);
println!("RSP: {:#X}", frame.stack_pointer.as_u64());
println!("RSP: {:#X}", frame.stack_pointer.as_usize());
println!("SS: {:#X}", frame.stack_segment);
if let Some(error_code) = error_code {
src/arch/x86_64/port.rs
+72 -72
View File
@@ -14,46 +14,46 @@ pub unsafe fn read_u8(port: u16) -> u8 {
value
}
#[inline(always)]
pub unsafe fn read_u8_slice(port: u16, slice: &mut [u8]) {
unsafe {
asm!(
"rep insb",
in("dx") port,
inout("rdi") slice.as_mut_ptr() => _,
inout("rcx") slice.len() => _,
options(nostack, preserves_flags),
);
}
}
// #[inline(always)]
// pub unsafe fn read_u8_slice(port: u16, slice: &mut [u8]) {
// unsafe {
// asm!(
// "rep insb",
// in("dx") port,
// inout("rdi") slice.as_mut_ptr() => _,
// inout("rcx") slice.len() => _,
// options(nostack, preserves_flags),
// );
// }
// }
#[inline(always)]
pub unsafe fn read_u16(port: u16) -> u16 {
let value: u16;
unsafe {
asm!(
"in ax, dx",
in("dx") port,
out("ax") value,
options(nomem, nostack, preserves_flags),
);
}
value
}
// #[inline(always)]
// pub unsafe fn read_u16(port: u16) -> u16 {
// let value: u16;
// unsafe {
// asm!(
// "in ax, dx",
// in("dx") port,
// out("ax") value,
// options(nomem, nostack, preserves_flags),
// );
// }
// value
// }
#[inline(always)]
pub unsafe fn read_u32(port: u16) -> u32 {
let value: u32;
unsafe {
asm!(
"in eax, dx",
in("dx") port,
out("eax") value,
options(nomem, nostack, preserves_flags),
);
}
value
}
// #[inline(always)]
// pub unsafe fn read_u32(port: u16) -> u32 {
// let value: u32;
// unsafe {
// asm!(
// "in eax, dx",
// in("dx") port,
// out("eax") value,
// options(nomem, nostack, preserves_flags),
// );
// }
// value
// }
#[inline(always)]
pub unsafe fn write_u8(port: u16, value: u8) {
@@ -67,39 +67,39 @@ pub unsafe fn write_u8(port: u16, value: u8) {
}
}
#[inline(always)]
pub unsafe fn write_u8_slice(port: u16, slice: &[u8]) {
unsafe {
asm!(
"rep outsb",
in("dx") port,
inout("rsi") slice.as_ptr() => _,
inout("rcx") slice.len() => _,
options(nostack, preserves_flags),
);
}
}
// #[inline(always)]
// pub unsafe fn write_u8_slice(port: u16, slice: &[u8]) {
// unsafe {
// asm!(
// "rep outsb",
// in("dx") port,
// inout("rsi") slice.as_ptr() => _,
// inout("rcx") slice.len() => _,
// options(nostack, preserves_flags),
// );
// }
// }
#[inline(always)]
pub unsafe fn write_u16(port: u16, value: u16) {
unsafe {
asm!(
"out dx, ax",
in("dx") port,
in("ax") value,
options(nomem, nostack, preserves_flags),
);
}
}
// #[inline(always)]
// pub unsafe fn write_u16(port: u16, value: u16) {
// unsafe {
// asm!(
// "out dx, ax",
// in("dx") port,
// in("ax") value,
// options(nomem, nostack, preserves_flags),
// );
// }
// }
#[inline(always)]
pub unsafe fn write_u32(port: u16, value: u32) {
unsafe {
asm!(
"out dx, eax",
in("dx") port,
in("eax") value,
options(nomem, nostack, preserves_flags),
);
}
}
// #[inline(always)]
// pub unsafe fn write_u32(port: u16, value: u32) {
// unsafe {
// asm!(
// "out dx, eax",
// in("dx") port,
// in("eax") value,
// options(nomem, nostack, preserves_flags),
// );
// }
// }
src/boot/limine.rs
+6 -6
View File
@@ -33,16 +33,16 @@ static _END_MARKER: RequestsEndMarker = RequestsEndMarker::new();
pub struct BootInfo {
pub kernel_address: crate::memory::PhysicalAddr,
pub hhdm_offset: u64,
pub hhdm_offset: usize,
entries: &'static [&'static limine_api::memmap::Entry],
}
impl BootInfo {
pub fn memory_regions(&self) -> impl Iterator<Item = crate::memory::MemoryRegion> + '_ {
pub fn memory_regions(&self) -> impl Iterator<Item = crate::memory::MemoryRegion> + Clone + '_ {
use crate::memory::{MemoryRegion, MemoryRegionKind};
self.entries.iter().map(|&entry| MemoryRegion {
start: crate::memory::PhysicalAddr::new(entry.base),
length: entry.length,
start: crate::memory::PhysicalAddr::new(entry.base as usize),
length: entry.length as usize,
kind: match entry.type_ {
limine_api::memmap::MEMMAP_USABLE => MemoryRegionKind::Usable,
limine_api::memmap::MEMMAP_RESERVED => MemoryRegionKind::Reserved,
@@ -91,8 +91,8 @@ pub fn load_boot_info() -> Result<BootInfo, BootError> {
.entries();
Ok(BootInfo {
kernel_address: crate::memory::PhysicalAddr::new(kernel_address),
hhdm_offset,
kernel_address: crate::memory::PhysicalAddr::new(kernel_address as usize),
hhdm_offset: hhdm_offset as usize,
entries: memmap,
})
}
src/main.rs
+30 -3
View File
@@ -15,13 +15,40 @@ pub extern "C" fn _start() -> ! {
serial::init().unwrap();
arch::init();
let _boot_info = boot::load_boot_info().unwrap();
let boot_info = boot::load_boot_info().unwrap();
let mut allocator = memory::FrameAllocator::new(
boot_info.memory_regions(),
memory::DirectMap::new(boot_info.hhdm_offset),
)
.expect("failed to create frame allocator");
let initial = allocator.free_frames();
let first = allocator.alloc().unwrap();
let second = allocator.alloc().unwrap();
let third = allocator.alloc().unwrap();
assert_ne!(first, second);
assert_ne!(second, third);
assert_eq!(allocator.free_frames(), initial - 3);
let addr = 0xDEADBEEF as *mut u32;
unsafe {
*addr = 0xDEADBEEF;
allocator.dealloc(second);
allocator.dealloc(first);
allocator.dealloc(third);
}
assert_eq!(allocator.free_frames(), initial);
let a = allocator.alloc().unwrap();
let b = allocator.alloc().unwrap();
let c = allocator.alloc().unwrap();
assert_ne!(a, b);
assert_ne!(b, c);
assert_ne!(a, c);
hcf();
}
src/memory/frame.rs
+354
View File
@@ -0,0 +1,354 @@
use core::ops::Range;
use crate::memory::{DirectMap, MemoryRegion, MemoryRegionKind, PhysicalAddr, VirtualAddr};
pub const FRAME_SIZE: usize = 4096;
pub fn align_up_to_frame(addr: usize) -> Option<usize> {
addr.checked_add(FRAME_SIZE as usize - 1)
.map(|addr| addr & !(FRAME_SIZE - 1))
}
pub fn align_down_to_frame(addr: usize) -> usize {
addr & !(FRAME_SIZE - 1)
}
#[derive(Debug)]
struct Bitmap {
start: VirtualAddr,
bit_count: usize,
}
// 1 = available, 0 = unavailable
impl Bitmap {
fn new(start: VirtualAddr, bit_count: usize) -> Self {
Self { start, bit_count }
}
fn is_available(&self, idx: usize) -> bool {
assert!(idx < self.bit_count, "index out of bounds");
let byte = idx / 8;
let bit = idx % 8;
unsafe { self.start.as_mut_ptr::<u8>().add(byte).read() & (1 << bit) != 0 }
}
fn set_available(&mut self, idx: usize, available: bool) {
assert!(idx < self.bit_count, "index out of bounds");
let byte = idx / 8;
let bit = idx % 8;
let val = unsafe { self.start.as_mut_ptr::<u8>().add(byte).read() };
unsafe {
self.start.as_mut_ptr::<u8>().add(byte).write(if available {
val | (1 << bit)
} else {
val & !(1 << bit)
});
}
}
// fn fill_available(&mut self, range: Range<usize>, available: bool) -> bool {
// if range.start > range.end {
// return false;
// }
// if range.end > self.bit_count {
// return false;
// }
// if range.is_empty() {
// return true;
// }
// let ptr = unsafe { self.start.as_mut_ptr::<u8>() };
// let first_byte = range.start / 8;
// let last_byte = (range.end - 1) / 8;
// let start_bit = range.start % 8;
// let end_bit = range.end % 8;
// unsafe {
// if first_byte == last_byte {
// let width = range.end - range.start;
// let mask = (((1u16 << width) - 1) << start_bit) as u8;
// let byte = ptr.add(first_byte).read();
// ptr.add(first_byte)
// .write(if available { byte | mask } else { byte & !mask });
// return true;
// }
// let mut full_start = first_byte;
// if start_bit != 0 {
// let mask = u8::MAX << start_bit;
// let byte = ptr.add(first_byte).read();
// ptr.add(first_byte)
// .write(if available { byte | mask } else { byte & !mask });
// full_start += 1;
// }
// let full_end = range.end / 8;
// ptr.add(full_start)
// .write_bytes(if available { u8::MAX } else { 0 }, full_end - full_start);
// if end_bit != 0 {
// let mask = (1u8 << end_bit) - 1;
// let byte = ptr.add(full_end).read();
// ptr.add(full_end)
// .write(if available { byte | mask } else { byte & !mask });
// }
// }
// true
// }
}
#[derive(Debug)]
pub enum FrameAllocatorInitError {
AddressOverflow,
NoUsableFrames,
NoBitmapStorage,
BitmapOutsideDirectMap,
}
// very very simple linked list frame/page allocator
#[derive(Debug)]
pub struct FrameAllocator {
bitmap: Bitmap,
bitmap_start_frame: usize,
bitmap_frame_count: usize,
next_search: usize,
allocatable_frames: usize,
free_frames: usize,
direct_map: DirectMap,
}
impl FrameAllocator {
pub fn new<I>(regions: I, direct_map: DirectMap) -> Result<Self, FrameAllocatorInitError>
where
I: Iterator<Item = MemoryRegion> + Clone,
{
let mut highest_frame: Option<usize> = None;
for region in regions.clone() {
if region.kind != MemoryRegionKind::Usable {
continue;
}
let range = Self::usable_frame_range(region)?;
if range.is_empty() {
continue;
}
highest_frame = Some(highest_frame.map_or(range.end, |current| current.max(range.end)));
}
let highest_frame = highest_frame.ok_or(FrameAllocatorInitError::NoUsableFrames)?;
let bitmap_bytes = highest_frame.div_ceil(8);
let bitmap_frame_count = bitmap_bytes.div_ceil(FRAME_SIZE);
let bitmap_storage_bytes = bitmap_frame_count
.checked_mul(FRAME_SIZE)
.ok_or(FrameAllocatorInitError::AddressOverflow)?;
let mut bitmap_start_frame: Option<usize> = None;
for region in regions.clone() {
if region.kind != MemoryRegionKind::Usable {
continue;
}
let range = Self::usable_frame_range(region)?;
if range.is_empty() {
continue;
}
if range.len() < bitmap_frame_count {
continue;
}
bitmap_start_frame = Some(range.start);
break;
}
if bitmap_start_frame.is_none() {
return Err(FrameAllocatorInitError::NoBitmapStorage);
}
let bitmap_start_frame = bitmap_start_frame.unwrap();
let bitmap_physical_addr = PhysicalAddr::new(bitmap_start_frame * FRAME_SIZE);
let bitmap_virtual = direct_map
.translate(bitmap_physical_addr)
.ok_or(FrameAllocatorInitError::BitmapOutsideDirectMap)?;
unsafe {
// set everyting to unavailable
core::ptr::write_bytes(bitmap_virtual.as_mut_ptr::<u8>(), 0, bitmap_storage_bytes);
}
let mut allocatable_frames = 0;
let mut free_frames = 0;
let mut bitmap = Bitmap::new(bitmap_virtual, highest_frame);
let bitmap_end_frame = bitmap_start_frame
.checked_add(bitmap_frame_count)
.ok_or(FrameAllocatorInitError::AddressOverflow)?;
for region in regions {
if region.kind != MemoryRegionKind::Usable {
continue;
}
for frame_idx in Self::usable_frame_range(region)? {
let is_bitmap_storage =
frame_idx >= bitmap_start_frame && frame_idx < bitmap_end_frame;
if is_bitmap_storage {
continue;
}
bitmap.set_available(frame_idx, true);
allocatable_frames += 1;
free_frames += 1;
}
}
Ok(Self {
bitmap,
bitmap_start_frame: bitmap_start_frame,
bitmap_frame_count,
next_search: bitmap_start_frame + bitmap_frame_count,
allocatable_frames,
free_frames,
direct_map,
})
}
fn find_free_in(&self, start: usize, end: usize) -> Option<usize> {
(start..end).find(|&index| self.bitmap.is_available(index))
}
fn find_free_frame(&self) -> Option<usize> {
self.find_free_in(self.next_search, self.bitmap.bit_count)
.or_else(|| self.find_free_in(0, self.next_search))
}
pub fn alloc_nozero(&mut self) -> Option<PhysicalFrame> {
if self.free_frames == 0 {
return None;
}
let frame_idx = self.find_free_frame()?;
self.bitmap.set_available(frame_idx, false);
self.free_frames -= 1;
self.next_search = frame_idx.saturating_add(1);
Some(PhysicalFrame::from_index(frame_idx))
}
pub fn alloc(&mut self) -> Option<PhysicalFrame> {
let frame = self.alloc_nozero()?;
let start = self
.direct_map
.translate(frame.start_address())
.expect("frame is outside the direct map");
unsafe {
core::ptr::write_bytes(start.as_mut_ptr::<u8>(), 0, FRAME_SIZE);
}
Some(frame)
}
/// # Safety
///
/// The caller must ensure:
/// - The frame is currently owned by the caller
/// - it is not currently in use
/// - it has not been freed
pub unsafe fn dealloc(&mut self, frame: PhysicalFrame) {
let frame_idx = frame.index();
assert!(
frame_idx < self.bitmap.bit_count,
"frame index out of bounds"
);
assert!(
!self.is_bitmap_storage(frame_idx),
"attempted to free frame allocator bitmap"
);
assert!(
!self.bitmap.is_available(frame_idx),
"frame is already free"
);
self.bitmap.set_available(frame_idx, true);
self.free_frames += 1;
self.next_search = self.next_search.min(frame_idx);
}
pub const fn free_frames(&self) -> usize {
self.free_frames
}
pub const fn allocatable_frames(&self) -> usize {
self.allocatable_frames
}
fn is_bitmap_storage(&self, index: usize) -> bool {
index >= self.bitmap_start_frame
&& index < (self.bitmap_start_frame + self.bitmap_frame_count)
}
fn usable_frame_range(
region: MemoryRegion,
) -> Result<core::ops::Range<usize>, FrameAllocatorInitError> {
let region_end = region
.start
.as_usize()
.checked_add(region.length)
.ok_or(FrameAllocatorInitError::AddressOverflow)?;
let start = align_up_to_frame(region.start.as_usize())
.ok_or(FrameAllocatorInitError::AddressOverflow)?;
let end = align_down_to_frame(region_end);
Ok((start / FRAME_SIZE)..(end / FRAME_SIZE))
}
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct PhysicalFrame(PhysicalAddr);
impl PhysicalFrame {
pub fn from_start_address(address: PhysicalAddr) -> Option<Self> {
if address.as_usize() % FRAME_SIZE != 0 {
return None;
}
Some(Self(address))
}
pub fn start_address(&self) -> PhysicalAddr {
self.0
}
fn from_index(index: usize) -> Self {
Self(PhysicalAddr::new(index * FRAME_SIZE))
}
fn index(&self) -> usize {
self.0.as_usize() / FRAME_SIZE
}
}
src/memory/mod.rs
+30 -9
View File
@@ -1,32 +1,36 @@
mod frame;
pub use frame::{FRAME_SIZE, FrameAllocator, PhysicalFrame};
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct PhysicalAddr(u64);
pub struct PhysicalAddr(usize);
impl PhysicalAddr {
pub fn new(addr: u64) -> Self {
pub fn new(addr: usize) -> Self {
Self(addr)
}
pub const fn as_u64(self) -> u64 {
pub const fn as_usize(self) -> usize {
self.0
}
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct VirtualAddr(u64);
pub struct VirtualAddr(usize);
impl VirtualAddr {
pub fn new(addr: u64) -> Self {
pub fn new(addr: usize) -> Self {
Self(addr)
}
pub const fn as_u64(self) -> u64 {
self.0
pub const fn as_usize(self) -> usize {
self.0 as usize
}
pub unsafe fn as_mut_ptr<T>(self) -> *mut T {
self.as_u64() as *mut T
self.as_usize() as *mut T
}
}
@@ -46,6 +50,23 @@ pub enum MemoryRegionKind {
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct MemoryRegion {
pub start: PhysicalAddr,
pub length: u64,
pub length: usize,
pub kind: MemoryRegionKind,
}
#[derive(Debug, Clone, Copy)]
pub struct DirectMap {
offset: usize,
}
impl DirectMap {
pub fn new(offset: usize) -> Self {
Self { offset }
}
pub fn translate(self, addr: PhysicalAddr) -> Option<VirtualAddr> {
addr.as_usize()
.checked_add(self.offset)
.map(VirtualAddr::new)
}
}