feat(mapper): add MappedPageTable::display

Author: mkroening

src/structures/paging/mapper/mapped_page_table_display.rs

@@ -0,0 +1,91 @@
+use core::fmt::{self, Write};
+
+use crate::structures::paging::mapper::{
+    MappedPageRangeInclusive, MappedPageRangeInclusiveItem, MappedPageTableRangeInclusiveIter,
+    PageTableFrameMapping,
+};
+use crate::structures::paging::{MappedPageTable, PageSize};
+
+impl<P: PageTableFrameMapping + Clone> MappedPageTable<'_, P> {
+    pub fn display(&self) -> MappedPageTableDisplay<'_, &P> {
+        MappedPageTableDisplay {
+            inner: self.range_iter(),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct MappedPageTableDisplay<'a, P: PageTableFrameMapping + Clone> {
+    inner: MappedPageTableRangeInclusiveIter<'a, P>,
+}
+
+impl<P: PageTableFrameMapping + Clone> fmt::Display for MappedPageTableDisplay<'_, P> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut has_fields = false;
+
+        for mapped_page_range in self.inner.clone() {
+            if has_fields {
+                f.write_char('\n')?;
+            }
+            write!(f, "{}", mapped_page_range.display())?;
+
+            has_fields = true;
+        }
+
+        Ok(())
+    }
+}
+
+impl MappedPageRangeInclusiveItem {
+    pub fn display(&self) -> MappedPageRangeInclusiveItemDisplay<'_> {
+        MappedPageRangeInclusiveItemDisplay { inner: self }
+    }
+}
+
+#[derive(Debug)]
+pub struct MappedPageRangeInclusiveItemDisplay<'a> {
+    inner: &'a MappedPageRangeInclusiveItem,
+}
+
+impl fmt::Display for MappedPageRangeInclusiveItemDisplay<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.inner {
+            MappedPageRangeInclusiveItem::Size4KiB(range) => range.display().fmt(f),
+            MappedPageRangeInclusiveItem::Size2MiB(range) => range.display().fmt(f),
+            MappedPageRangeInclusiveItem::Size1GiB(range) => range.display().fmt(f),
+        }
+    }
+}
+
+impl<S: PageSize> MappedPageRangeInclusive<S> {
+    pub fn display(&self) -> MappedPageRangeInclusiveDisplay<'_, S> {
+        MappedPageRangeInclusiveDisplay { inner: self }
+    }
+}
+
+#[derive(Debug)]
+pub struct MappedPageRangeInclusiveDisplay<'a, S: PageSize> {
+    inner: &'a MappedPageRangeInclusive<S>,
+}
+
+impl<S: PageSize> fmt::Display for MappedPageRangeInclusiveDisplay<'_, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let size = S::DEBUG_STR;
+        let len = self.inner.page_range.len();
+        let page_start = self.inner.page_range.start.start_address();
+        let page_end = self.inner.page_range.end.start_address();
+        let frame_start = self.inner.frame_range.start.start_address();
+        let frame_end = self.inner.frame_range.end.start_address();
+        let flags = self.inner.flags;
+        let format_phys = if page_start.as_u64() == frame_start.as_u64() {
+            assert_eq!(page_end.as_u64(), frame_end.as_u64());
+            format_args!("{:>39}", "identity mapped")
+        } else {
+            format_args!("{frame_start:18p}..={frame_end:18p}")
+        };
+        write!(
+				f,
+				"size: {size}, len: {len:5}, virt: {page_start:18p}..={page_end:18p}, phys: {format_phys}, flags: {flags:?}"
+			)
+    }
+}

src/structures/paging/mapper/mod.rs

@@ -3,6 +3,9 @@
 pub use self::mapped_page_table::{
     MappedPageTable, PageTableFrameMapping, PageTableWalkError, PageTableWalker,
 };
+pub use self::mapped_page_table_display::{
+    MappedPageRangeInclusiveDisplay, MappedPageRangeInclusiveItemDisplay, MappedPageTableDisplay,
+};
 pub use self::mapped_page_table_iter::{
     MappedPageItem, MappedPageRangeInclusive, MappedPageRangeInclusiveItem, MappedPageTableIter,
     MappedPageTableRangeInclusiveIter,
@@ -21,6 +24,7 @@ use crate::structures::paging::{
 use crate::{PhysAddr, VirtAddr};
 
 mod mapped_page_table;
+mod mapped_page_table_display;
 mod mapped_page_table_iter;
 mod offset_page_table;
 #[cfg(all(feature = "instructions", target_arch = "x86_64"))]