paging: make ALL levels writable, not just P4

Author: zyuiop

src/arch/x86_64/mm/paging.rs

@@ -1,6 +1,5 @@
 use core::fmt::Debug;
 use core::ptr;
-
 use free_list::PageLayout;
 use x86_64::registers::control::{Cr0, Cr0Flags, Cr2, Cr3};
 #[cfg(feature = "common-os")]
@@ -11,9 +10,7 @@ pub use x86_64::structures::paging::PageTableFlags as PageTableEntryFlags;
 use x86_64::structures::paging::frame::PhysFrameRange;
 use x86_64::structures::paging::mapper::{MapToError, MappedFrame, TranslateResult, UnmapError};
 use x86_64::structures::paging::page::PageRange;
-use x86_64::structures::paging::{
-	FrameAllocator, Mapper, OffsetPageTable, Page, PageTable, PhysFrame, Size4KiB, Translate,
-};
+use x86_64::structures::paging::{FrameAllocator, Mapper, OffsetPageTable, Page, PageTable, PhysFrame, Size4KiB, Translate};
 
 use crate::arch::x86_64::kernel::processor;
 use crate::arch::x86_64::mm::{PhysAddr, VirtAddr};
@@ -325,24 +322,6 @@ fn make_p4_writable() {
 
 	let mut pt = unsafe { identity_mapped_page_table() };
 
-	let p4_page = {
-		let (p4_frame, _) = Cr3::read_raw();
-		let p4_addr = x86_64::VirtAddr::new(p4_frame.start_address().as_u64());
-		Page::<Size4KiB>::from_start_address(p4_addr).unwrap()
-	};
-
-	let TranslateResult::Mapped { frame, flags, .. } = pt.translate(p4_page.start_address()) else {
-		unreachable!()
-	};
-
-	let make_writable = || unsafe {
-		let flags = flags | PageTableEntryFlags::WRITABLE;
-		match frame {
-			MappedFrame::Size1GiB(_) => pt.set_flags_p3_entry(p4_page, flags).unwrap().ignore(),
-			MappedFrame::Size2MiB(_) => pt.set_flags_p2_entry(p4_page, flags).unwrap().ignore(),
-			MappedFrame::Size4KiB(_) => pt.update_flags(p4_page, flags).unwrap().ignore(),
-		}
-	};
 
 	unsafe fn without_protect<F, R>(f: F) -> R
 	where
@@ -359,7 +338,53 @@ fn make_p4_writable() {
 		ret
 	}
 
-	unsafe { without_protect(make_writable) }
+	let (p4_frame, _) = Cr3::read_raw();
+	unsafe {
+		without_protect(||
+			make_page_table_writable(&mut pt, p4_frame, 4)
+		);
+	};
+
+}
+
+
+unsafe fn make_page_table_writable(page_table: &mut OffsetPageTable<'static>, pt_frame: PhysFrame, level: u8) {
+	let pt_address = page_table.phys_offset() + pt_frame.start_address().as_u64();
+	let pt = unsafe {
+		pt_address.as_ptr::<PageTable>().as_ref().unwrap()
+	};
+
+	// Unmap the page table
+	let TranslateResult::Mapped { frame, flags, .. } = page_table.translate(pt_address) else {
+		unreachable!()
+	};
+
+	if !flags.contains(PageTableEntryFlags::WRITABLE) {
+		let flags = flags | PageTableEntryFlags::WRITABLE;
+		let page = Page::<Size4KiB>::containing_address(pt_address);
+		unsafe {
+			match frame {
+				MappedFrame::Size1GiB(_) => page_table.set_flags_p3_entry(page, flags).unwrap().ignore(),
+				MappedFrame::Size2MiB(_) => page_table.set_flags_p2_entry(page, flags).unwrap().ignore(),
+				MappedFrame::Size4KiB(_) => page_table.update_flags(page, flags).unwrap().ignore(),
+			}
+		}
+		warn!("Page table {pt_frame:x?}, was mapped from RO memory!");
+	}
+
+	for entry in pt.iter() {
+		if entry.is_unused() {
+			continue;
+		}
+
+		let is_page_table = level > 1 && !entry.flags().contains(PageTableEntryFlags::HUGE_PAGE);
+		if is_page_table {
+			let phys = entry.frame().unwrap();
+			unsafe {
+				make_page_table_writable(page_table, phys, level - 1);
+			}
+		}
+	}
 }
 
 pub unsafe fn log_page_tables() {