Merge pull request #1609 from hermit-os/identity-mem

feat: use identity-mapped page tables instead of recursive ones

Author: mkroening

Cargo.lock

@@ -160,7 +160,6 @@ features = [
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
 free-list = { version = "0.3", features = ["x86_64"] }
-multiboot = "0.8"
 raw-cpuid = "11"
 uart_16550 = "0.3"
 x86_64 = "0.15"

Cargo.toml

@@ -1,6 +1,5 @@
 #[cfg(feature = "common-os")]
 use core::arch::asm;
-use core::num::NonZeroU64;
 use core::ptr;
 use core::sync::atomic::{AtomicPtr, AtomicU32, Ordering};
 use core::task::Waker;
@@ -101,20 +100,6 @@ pub fn get_image_size() -> usize {
 	(range.end - range.start) as usize
 }
 
-pub fn get_limit() -> usize {
-	env::boot_info().hardware_info.phys_addr_range.end as usize
-}
-
-pub fn get_mbinfo() -> Option<NonZeroU64> {
-	match env::boot_info().platform_info {
-		PlatformInfo::Multiboot {
-			multiboot_info_addr,
-			..
-		} => Some(multiboot_info_addr),
-		_ => None,
-	}
-}
-
 #[cfg(feature = "smp")]
 pub fn get_possible_cpus() -> u32 {
 	use core::cmp;

src/arch/x86_64/kernel/mod.rs

@@ -115,32 +115,29 @@ impl TaskStacks {
 		let mut flags = PageTableEntryFlags::empty();
 		flags.normal().writable().execute_disable();
 
-		// For UEFI systems, the entire memory is already mapped, just clear the stack for safety
-		if !env::is_uefi() {
-			// map IST1 into the address space
-			crate::arch::mm::paging::map::<BasePageSize>(
-				virt_addr + BasePageSize::SIZE,
-				phys_addr,
-				IST_SIZE / BasePageSize::SIZE as usize,
-				flags,
-			);
+		// map IST1 into the address space
+		crate::arch::mm::paging::map::<BasePageSize>(
+			virt_addr + BasePageSize::SIZE,
+			phys_addr,
+			IST_SIZE / BasePageSize::SIZE as usize,
+			flags,
+		);
 
-			// map kernel stack into the address space
-			crate::arch::mm::paging::map::<BasePageSize>(
-				virt_addr + IST_SIZE + 2 * BasePageSize::SIZE,
-				phys_addr + IST_SIZE,
-				DEFAULT_STACK_SIZE / BasePageSize::SIZE as usize,
-				flags,
-			);
+		// map kernel stack into the address space
+		crate::arch::mm::paging::map::<BasePageSize>(
+			virt_addr + IST_SIZE + 2 * BasePageSize::SIZE,
+			phys_addr + IST_SIZE,
+			DEFAULT_STACK_SIZE / BasePageSize::SIZE as usize,
+			flags,
+		);
 
-			// map user stack into the address space
-			crate::arch::mm::paging::map::<BasePageSize>(
-				virt_addr + IST_SIZE + DEFAULT_STACK_SIZE + 3 * BasePageSize::SIZE,
-				phys_addr + IST_SIZE + DEFAULT_STACK_SIZE,
-				user_stack_size / BasePageSize::SIZE as usize,
-				flags,
-			);
-		}
+		// map user stack into the address space
+		crate::arch::mm::paging::map::<BasePageSize>(
+			virt_addr + IST_SIZE + DEFAULT_STACK_SIZE + 3 * BasePageSize::SIZE,
+			phys_addr + IST_SIZE + DEFAULT_STACK_SIZE,
+			user_stack_size / BasePageSize::SIZE as usize,
+			flags,
+		);
 
 		// clear user stack
 		unsafe {

src/arch/x86_64/kernel/scheduler.rs

@@ -2,8 +2,6 @@ pub(crate) mod paging;
 pub(crate) mod physicalmem;
 pub(crate) mod virtualmem;
 
-use core::slice;
-
 use memory_addresses::arch::x86_64::{PhysAddr, VirtAddr};
 #[cfg(feature = "common-os")]
 use x86_64::structures::paging::{PageSize, Size4KiB as BasePageSize};
@@ -12,32 +10,6 @@ pub use self::paging::init_page_tables;
 #[cfg(feature = "common-os")]
 use crate::arch::mm::paging::{PageTableEntryFlags, PageTableEntryFlagsExt};
 
-/// Memory translation, allocation and deallocation for MultibootInformation
-struct MultibootMemory;
-
-impl multiboot::information::MemoryManagement for MultibootMemory {
-	unsafe fn paddr_to_slice(
-		&self,
-		p: multiboot::information::PAddr,
-		size: usize,
-	) -> Option<&'static [u8]> {
-		unsafe { Some(slice::from_raw_parts(p as _, size)) }
-	}
-
-	unsafe fn allocate(
-		&mut self,
-		_length: usize,
-	) -> Option<(multiboot::information::PAddr, &mut [u8])> {
-		None
-	}
-
-	unsafe fn deallocate(&mut self, addr: multiboot::information::PAddr) {
-		if addr != 0 {
-			unimplemented!()
-		}
-	}
-}
-
 #[cfg(feature = "common-os")]
 pub fn create_new_root_page_table() -> usize {
 	use x86_64::registers::control::Cr3;

src/arch/x86_64/mm/mod.rs

@@ -1,7 +1,6 @@
 use core::fmt::Debug;
 use core::ptr;
 
-use x86_64::instructions::tlb;
 use x86_64::registers::control::{Cr0, Cr0Flags, Cr2, Cr3};
 #[cfg(feature = "common-os")]
 use x86_64::registers::segmentation::SegmentSelector;
@@ -13,12 +12,12 @@ use x86_64::structures::paging::mapper::{MappedFrame, TranslateResult, UnmapErro
 use x86_64::structures::paging::page::PageRange;
 use x86_64::structures::paging::{
 	Mapper, OffsetPageTable, Page, PageTable, PageTableIndex, PhysFrame, RecursivePageTable,
-	Size2MiB, Size4KiB, Translate,
+	Size4KiB, Translate,
 };
 
 use crate::arch::x86_64::kernel::processor;
 use crate::arch::x86_64::mm::{PhysAddr, VirtAddr, physicalmem};
-use crate::{env, mm, scheduler};
+use crate::{env, scheduler};
 
 pub trait PageTableEntryFlagsExt {
 	fn device(&mut self) -> &mut Self;
@@ -93,16 +92,6 @@ pub use x86_64::structures::paging::{
 	PageSize, Size1GiB as HugePageSize, Size2MiB as LargePageSize, Size4KiB as BasePageSize,
 };
 
-/// Returns a recursive page table mapping, its last entry is mapped to the table itself
-unsafe fn recursive_page_table() -> RecursivePageTable<'static> {
-	let level_4_table_addr = 0xffff_ffff_ffff_f000;
-	let level_4_table_ptr = ptr::with_exposed_provenance_mut(level_4_table_addr);
-	unsafe {
-		let level_4_table = &mut *(level_4_table_ptr);
-		RecursivePageTable::new(level_4_table).unwrap()
-	}
-}
-
 /// Returns a mapping of the physical memory where physical address is equal to the virtual address (no offset)
 pub unsafe fn identity_mapped_page_table() -> OffsetPageTable<'static> {
 	let level_4_table_addr = Cr3::read().0.start_address().as_u64();
@@ -118,11 +107,7 @@ pub unsafe fn identity_mapped_page_table() -> OffsetPageTable<'static> {
 pub fn virtual_to_physical(virtual_address: VirtAddr) -> Option<PhysAddr> {
 	let addr = x86_64::VirtAddr::from(virtual_address);
 
-	let translate_result = if env::is_uefi() {
-		unsafe { identity_mapped_page_table() }.translate(addr)
-	} else {
-		unsafe { recursive_page_table() }.translate(addr)
-	};
+	let translate_result = unsafe { identity_mapped_page_table() }.translate(addr);
 
 	match translate_result {
 		TranslateResult::NotMapped | TranslateResult::InvalidFrameAddress(_) => {
@@ -202,11 +187,7 @@ pub fn map<S>(
 		unmapped
 	}
 
-	let unmapped = if env::is_uefi() {
-		unsafe { map_pages(&mut identity_mapped_page_table(), pages, frames, flags) }
-	} else {
-		unsafe { map_pages(&mut recursive_page_table(), pages, frames, flags) }
-	};
+	let unmapped = unsafe { map_pages(&mut identity_mapped_page_table(), pages, frames, flags) };
 
 	if unmapped {
 		#[cfg(feature = "smp")]
@@ -247,18 +228,15 @@ where
 	for<'a> OffsetPageTable<'a>: Mapper<S>,
 {
 	assert!(
-		frame.start_address().as_u64() < mm::kernel_start_address().as_u64(),
+		frame.start_address().as_u64() < crate::mm::kernel_start_address().as_u64(),
 		"Address {:p} to be identity-mapped is not below Kernel start address",
 		frame.start_address()
 	);
 
 	let flags = PageTableEntryFlags::PRESENT | PageTableEntryFlags::NO_EXECUTE;
 	let mut frame_allocator = physicalmem::PHYSICAL_FREE_LIST.lock();
-	let mapper_result = if env::is_uefi() {
-		unsafe { identity_mapped_page_table().identity_map(frame, flags, &mut *frame_allocator) }
-	} else {
-		unsafe { recursive_page_table().identity_map(frame, flags, &mut *frame_allocator) }
-	};
+	let mapper_result =
+		unsafe { identity_mapped_page_table().identity_map(frame, flags, &mut *frame_allocator) };
 	mapper_result.unwrap().flush();
 }
 
@@ -278,11 +256,7 @@ where
 	let range = Page::range(first_page, last_page);
 
 	for page in range {
-		let unmap_result = if env::is_uefi() {
-			unsafe { identity_mapped_page_table() }.unmap(page)
-		} else {
-			unsafe { recursive_page_table() }.unmap(page)
-		};
+		let unmap_result = unsafe { identity_mapped_page_table() }.unmap(page);
 		match unmap_result {
 			Ok((_frame, flush)) => flush.flush(),
 			// FIXME: Some sentinel pages around stacks are supposed to be unmapped.
@@ -378,33 +352,7 @@ fn make_p4_writable() {
 	unsafe { without_protect(make_writable) }
 }
 
-pub fn init_page_tables() {
-	if env::is_uhyve() {
-		// Uhyve identity-maps the first Gibibyte of memory (512 page table entries * 2MiB pages)
-		// We now unmap all memory after the kernel image, so that we can remap it ourselves later for the heap.
-		// Ideally, uhyve would only map as much memory as necessary, but this requires a hermit-entry ABI jump.
-		// See https://github.com/hermit-os/uhyve/issues/426
-		let kernel_end_addr = x86_64::VirtAddr::new(mm::kernel_end_address().as_u64());
-		let start_page = Page::<Size2MiB>::from_start_address(kernel_end_addr).unwrap();
-		let end_page = Page::from_page_table_indices_2mib(
-			start_page.p4_index(),
-			start_page.p3_index(),
-			PageTableIndex::new(511),
-		);
-		let page_range = Page::range_inclusive(start_page, end_page);
-
-		let mut page_table = unsafe { recursive_page_table() };
-		for page in page_range {
-			match page_table.unmap(page) {
-				Ok((_frame, flush)) => flush.ignore(),
-				Err(UnmapError::PageNotMapped) => {} // If it wasn't mapped, that's not an issue
-				Err(e) => panic!("Couldn't unmap page {page:?}: {e:?}"),
-			}
-		}
-
-		tlb::flush_all();
-	}
-}
+pub fn init_page_tables() {}
 
 #[allow(dead_code)]
 unsafe fn disect<PT: Translate>(pt: PT, virt_addr: x86_64::VirtAddr) {
@@ -448,13 +396,8 @@ unsafe fn disect<PT: Translate>(pt: PT, virt_addr: x86_64::VirtAddr) {
 unsafe fn print_page_table_entries(page_table_indices: &[PageTableIndex]) {
 	assert!(page_table_indices.len() <= 4);
 
-	// Recursive
-	let recursive_page_table = unsafe { recursive_page_table() };
-	let mut pt = recursive_page_table.level_4_table();
-
-	// Identity mapped
-	// let identity_mapped_page_table = unsafe { identity_mapped_page_table() };
-	// let pt = identity_mapped_page_table.level_4_table();
+	let identity_mapped_page_table = unsafe { identity_mapped_page_table() };
+	let mut pt = identity_mapped_page_table.level_4_table();
 
 	for (i, page_table_index) in page_table_indices.iter().copied().enumerate() {
 		let level = 4 - i;
@@ -500,13 +443,8 @@ pub(crate) unsafe fn print_page_tables(levels: usize) {
 		}
 	}
 
-	// Recursive
-	let recursive_page_table = unsafe { recursive_page_table() };
-	let pt = recursive_page_table.level_4_table();
-
-	// Identity mapped
-	// let identity_mapped_page_table = unsafe { identity_mapped_page_table() };
-	// let pt = identity_mapped_page_table.level_4_table();
+	let identity_mapped_page_table = unsafe { identity_mapped_page_table() };
+	let pt = identity_mapped_page_table.level_4_table();
 
 	print(pt, 4, 5 - levels);
 }