Merge pull request #1996 from hermit-os/reserve-memory

feat(physicalmem): respect memory reservations

Author: mkroening

src/arch/x86_64/mm/paging.rs

@@ -367,12 +367,12 @@ pub unsafe fn log_page_tables() {
 
 	use self::mapped_page_range_display::OffsetPageTableExt;
 
-	if !log_enabled!(Level::Debug) {
+	if !log_enabled!(Level::Trace) {
 		return;
 	}
 
 	let page_table = unsafe { identity_mapped_page_table() };
-	debug!("Page tables:\n{}", page_table.display());
+	trace!("Page tables:\n{}", page_table.display());
 }
 
 pub mod mapped_page_range_display {

src/mm/physicalmem.rs

@@ -1,7 +1,7 @@
 use core::sync::atomic::{AtomicUsize, Ordering};
 
 use align_address::Align;
-use free_list::{FreeList, PageRange};
+use free_list::{FreeList, PageRange, PageRangeError};
 use hermit_sync::InterruptTicketMutex;
 use memory_addresses::{PhysAddr, VirtAddr};
 
@@ -19,7 +19,7 @@ pub fn total_memory_size() -> usize {
 	TOTAL_MEMORY.load(Ordering::Relaxed)
 }
 
-pub unsafe fn init_frame_range(frame_range: PageRange) {
+pub unsafe fn map_frame_range(frame_range: PageRange) {
 	cfg_if::cfg_if! {
 		if #[cfg(target_arch = "aarch64")] {
 			type IdentityPageSize = crate::arch::mm::paging::BasePageSize;
@@ -37,10 +37,6 @@ pub unsafe fn init_frame_range(frame_range: PageRange) {
 		.end()
 		.align_up(IdentityPageSize::SIZE.try_into().unwrap());
 
-	unsafe {
-		PHYSICAL_FREE_LIST.lock().deallocate(frame_range).unwrap();
-	}
-
 	(start..end)
 		.step_by(IdentityPageSize::SIZE.try_into().unwrap())
 		.map(|addr| PhysAddr::new(addr.try_into().unwrap()))
@@ -61,58 +57,104 @@ pub unsafe fn init_frame_range(frame_range: PageRange) {
 				paging::map::<IdentityPageSize>(virt_addr, phys_addr, 1, flags);
 			});
 	}
-
-	TOTAL_MEMORY.fetch_add(frame_range.len().get(), Ordering::Relaxed);
 }
 
 fn detect_from_fdt() -> Result<(), ()> {
 	let fdt = env::fdt().ok_or(())?;
 
+	let all_regions = fdt
+		.find_all_nodes("/memory")
+		.map(|m| m.reg().unwrap().next().unwrap());
+	if all_regions.count() == 0 {
+		return Err(());
+	}
 	let all_regions = fdt
 		.find_all_nodes("/memory")
 		.map(|m| m.reg().unwrap().next().unwrap());
 
-	let mut found_ram = false;
+	for m in all_regions {
+		let start_address = m.starting_address as u64;
+		let size = m.size.unwrap() as u64;
+		let end_address = start_address + size;
 
-	if env::is_uefi() {
-		let biggest_region = all_regions.max_by_key(|m| m.size.unwrap()).unwrap();
-		found_ram = true;
+		if end_address <= super::kernel_end_address().as_u64() && !env::is_uefi() {
+			continue;
+		}
 
-		let range = PageRange::from_start_len(
-			biggest_region.starting_address.addr(),
-			biggest_region.size.unwrap(),
-		)
-		.unwrap();
+		let start_address =
+			if start_address <= super::kernel_start_address().as_u64() && !env::is_uefi() {
+				super::kernel_end_address()
+			} else {
+				VirtAddr::new(start_address)
+			};
 
+		let range = PageRange::new(start_address.as_usize(), end_address as usize).unwrap();
 		unsafe {
-			init_frame_range(range);
+			PHYSICAL_FREE_LIST.lock().deallocate(range).unwrap();
+			map_frame_range(range);
 		}
+		TOTAL_MEMORY.fetch_add(range.len().get(), Ordering::Relaxed);
+		debug!("Claimed physical memory: {range:#x?}");
+	}
+
+	let reserve = |reservation: PageRange| {
+		debug!("Memory reservation: {reservation:#x?}");
+		// While there are still overlaps between this reservation and any available ranges,
+		// allocate that overlap to mark it as not available.
+		while let Ok(reserved) = PHYSICAL_FREE_LIST
+			.lock()
+			.allocate_with(|range| reservation.and(range))
+		{
+			debug!("Reserved {reserved:#x?}");
+		}
+	};
+
+	for reservation in fdt.memory_reservations() {
+		let start = reservation.address().addr();
+		let end = start + reservation.size();
+		let reservation = PageRange::new(start, end).unwrap();
+		reserve(reservation);
+	}
+
+	let kernel_start = if env::is_uefi() {
+		super::kernel_start_address().as_usize()
 	} else {
-		for m in all_regions {
-			let start_address = m.starting_address as u64;
-			let size = m.size.unwrap() as u64;
-			let end_address = start_address + size;
+		// FIXME: Memory before the kernel causes trouble on non-uefi systems.
+		// It is unclear, which exact regions cause problems.
+		0
+	};
+	let kernel_end = super::kernel_end_address().as_usize();
+	let kernel_region = PageRange::new(kernel_start, kernel_end).unwrap();
+	reserve(kernel_region);
+
+	let fdt_start = env::boot_info().hardware_info.device_tree.unwrap().get();
+	let fdt_start = usize::try_from(fdt_start).unwrap();
+	let fdt_end = fdt_start + fdt.total_size();
+	let fdt_region = PageRange::containing(fdt_start, fdt_end).unwrap();
+	reserve(fdt_region);
 
-			if end_address <= super::kernel_end_address().as_u64() {
-				continue;
-			}
+	Ok(())
+}
 
-			found_ram = true;
+// FIXME: upstream these
+trait PageRangeExt: Sized {
+	fn containing(start: usize, end: usize) -> Result<Self, PageRangeError>;
 
-			let start_address = if start_address <= super::kernel_start_address().as_u64() {
-				super::kernel_end_address()
-			} else {
-				VirtAddr::new(start_address)
-			};
+	fn and(self, rhs: Self) -> Option<Self>;
+}
 
-			let range = PageRange::new(start_address.as_usize(), end_address as usize).unwrap();
-			unsafe {
-				init_frame_range(range);
-			}
-		}
+impl PageRangeExt for PageRange {
+	fn containing(start: usize, end: usize) -> Result<Self, PageRangeError> {
+		let start = start.align_down(free_list::PAGE_SIZE);
+		let end = end.align_up(free_list::PAGE_SIZE);
+		Self::new(start, end)
 	}
 
-	if found_ram { Ok(()) } else { Err(()) }
+	fn and(self, rhs: Self) -> Option<Self> {
+		let start = self.start().max(rhs.start());
+		let end = self.end().min(rhs.end());
+		Self::new(start, end).ok()
+	}
 }
 
 #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
@@ -130,8 +172,10 @@ fn detect_from_limits() -> Result<(), ()> {
 	let range =
 		PageRange::new(super::kernel_end_address().as_usize(), ram_address + limit).unwrap();
 	unsafe {
-		init_frame_range(range);
+		PHYSICAL_FREE_LIST.lock().deallocate(range).unwrap();
+		map_frame_range(range);
 	}
+	TOTAL_MEMORY.fetch_add(range.len().get(), Ordering::Relaxed);
 
 	Ok(())
 }