feat(mapper): add MappedPageTable::range_iter

Author: mkroening

src/structures/paging/mapper/mapped_page_table_iter.rs

@@ -0,0 +1,399 @@
+use core::convert::TryFrom;
+use core::fmt;
+use core::ops::{Add, AddAssign, Sub, SubAssign};
+
+use crate::structures::paging::frame::PhysFrameRangeInclusive;
+use crate::structures::paging::mapper::{
+    PageTableFrameMapping, PageTableWalkError, PageTableWalker,
+};
+use crate::structures::paging::page::{AddressNotAligned, PageRangeInclusive};
+use crate::structures::paging::{
+    MappedPageTable, Page, PageSize, PageTable, PageTableFlags, PageTableIndex, PhysFrame,
+    Size1GiB, Size2MiB, Size4KiB,
+};
+
+#[derive(Debug)]
+pub struct MappedPageRangeInclusive<S: PageSize> {
+    pub page_range: PageRangeInclusive<S>,
+    pub frame_range: PhysFrameRangeInclusive<S>,
+    pub flags: PageTableFlags,
+}
+
+impl<S: PageSize> TryFrom<(MappedPage<S>, MappedPage<S>)> for MappedPageRangeInclusive<S> {
+    type Error = TryFromMappedPageError;
+
+    fn try_from((start, end): (MappedPage<S>, MappedPage<S>)) -> Result<Self, Self::Error> {
+        if start.flags != end.flags {
+            return Err(TryFromMappedPageError);
+        }
+
+        Ok(Self {
+            page_range: PageRangeInclusive {
+                start: start.page,
+                end: end.page,
+            },
+            frame_range: PhysFrameRangeInclusive {
+                start: start.frame,
+                end: end.frame,
+            },
+            flags: start.flags,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub enum MappedPageRangeInclusiveItem {
+    Size4KiB(MappedPageRangeInclusive<Size4KiB>),
+    Size2MiB(MappedPageRangeInclusive<Size2MiB>),
+    Size1GiB(MappedPageRangeInclusive<Size1GiB>),
+}
+
+impl TryFrom<(MappedPageItem, MappedPageItem)> for MappedPageRangeInclusiveItem {
+    type Error = TryFromMappedPageError;
+
+    fn try_from((start, end): (MappedPageItem, MappedPageItem)) -> Result<Self, Self::Error> {
+        match (start, end) {
+            (MappedPageItem::Size4KiB(start), MappedPageItem::Size4KiB(end)) => {
+                let range = MappedPageRangeInclusive::try_from((start, end))?;
+                Ok(Self::Size4KiB(range))
+            }
+            (MappedPageItem::Size2MiB(start), MappedPageItem::Size2MiB(end)) => {
+                let range = MappedPageRangeInclusive::try_from((start, end))?;
+                Ok(Self::Size2MiB(range))
+            }
+            (MappedPageItem::Size1GiB(start), MappedPageItem::Size1GiB(end)) => {
+                let range = MappedPageRangeInclusive::try_from((start, end))?;
+                Ok(Self::Size1GiB(range))
+            }
+            (_, _) => Err(TryFromMappedPageError),
+        }
+    }
+}
+
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct TryFromMappedPageError;
+
+impl fmt::Display for TryFromMappedPageError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("provided mapped pages were not compatible")
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct MappedPageTableRangeInclusiveIter<'a, P: PageTableFrameMapping> {
+    inner: MappedPageTableIter<'a, P>,
+    start: Option<MappedPageItem>,
+    end: Option<MappedPageItem>,
+}
+
+impl<'a, P: PageTableFrameMapping> MappedPageTable<'a, P> {
+    pub fn range_iter(&'a self) -> MappedPageTableRangeInclusiveIter<'a, &'a P> {
+        MappedPageTableRangeInclusiveIter {
+            inner: self.iter(),
+            start: None,
+            end: None,
+        }
+    }
+}
+
+impl<'a, P: PageTableFrameMapping> Iterator for MappedPageTableRangeInclusiveIter<'a, P> {
+    type Item = MappedPageRangeInclusiveItem;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.start.is_none() {
+            self.start = self.inner.next();
+            self.end = self.start;
+        }
+
+        let Some(start) = &mut self.start else {
+            return None;
+        };
+        let end = self.end.as_mut().unwrap();
+
+        for mapped_page in self.inner.by_ref() {
+            if mapped_page == *end + 1 {
+                *end = mapped_page;
+                continue;
+            }
+
+            let range = MappedPageRangeInclusiveItem::try_from((*start, *end)).unwrap();
+            *start = mapped_page;
+            *end = mapped_page;
+            return Some(range);
+        }
+
+        let range = MappedPageRangeInclusiveItem::try_from((*start, *end)).unwrap();
+        self.start = None;
+        self.end = None;
+        Some(range)
+    }
+}
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug)]
+pub struct MappedPage<S: PageSize> {
+    pub page: Page<S>,
+    pub frame: PhysFrame<S>,
+    pub flags: PageTableFlags,
+}
+
+impl<S: PageSize> Add<u64> for MappedPage<S> {
+    type Output = Self;
+
+    fn add(self, rhs: u64) -> Self::Output {
+        Self {
+            page: self.page + rhs,
+            frame: self.frame + rhs,
+            flags: self.flags,
+        }
+    }
+}
+
+impl<S: PageSize> Sub<u64> for MappedPage<S> {
+    type Output = Self;
+
+    fn sub(self, rhs: u64) -> Self::Output {
+        Self {
+            page: self.page - rhs,
+            frame: self.frame - rhs,
+            flags: self.flags,
+        }
+    }
+}
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug)]
+pub enum MappedPageItem {
+    Size4KiB(MappedPage<Size4KiB>),
+    Size2MiB(MappedPage<Size2MiB>),
+    Size1GiB(MappedPage<Size1GiB>),
+}
+
+impl Add<u64> for MappedPageItem {
+    type Output = Self;
+
+    fn add(self, rhs: u64) -> Self::Output {
+        match self {
+            Self::Size4KiB(mapped_page) => Self::Size4KiB(mapped_page + rhs),
+            Self::Size2MiB(mapped_page) => Self::Size2MiB(mapped_page + rhs),
+            Self::Size1GiB(mapped_page) => Self::Size1GiB(mapped_page + rhs),
+        }
+    }
+}
+
+impl AddAssign<u64> for MappedPageItem {
+    fn add_assign(&mut self, rhs: u64) {
+        *self = *self + rhs;
+    }
+}
+
+impl Sub<u64> for MappedPageItem {
+    type Output = Self;
+
+    fn sub(self, rhs: u64) -> Self::Output {
+        match self {
+            Self::Size4KiB(mapped_page) => Self::Size4KiB(mapped_page - rhs),
+            Self::Size2MiB(mapped_page) => Self::Size2MiB(mapped_page - rhs),
+            Self::Size1GiB(mapped_page) => Self::Size1GiB(mapped_page - rhs),
+        }
+    }
+}
+
+impl SubAssign<u64> for MappedPageItem {
+    fn sub_assign(&mut self, rhs: u64) {
+        *self = *self - rhs;
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct MappedPageTableIter<'a, P: PageTableFrameMapping> {
+    page_table_walker: PageTableWalker<P>,
+    level_4_table: &'a PageTable,
+    p4_index: u16,
+    p3_index: u16,
+    p2_index: u16,
+    p1_index: u16,
+}
+
+impl<'a, P: PageTableFrameMapping> MappedPageTable<'a, P> {
+    pub fn iter(&'a self) -> MappedPageTableIter<'a, &'a P> {
+        let page_table_walker = unsafe { PageTableWalker::new(self.page_table_frame_mapping()) };
+        MappedPageTableIter {
+            page_table_walker,
+            level_4_table: self.level_4_table(),
+            p4_index: 0,
+            p3_index: 0,
+            p2_index: 0,
+            p1_index: 0,
+        }
+    }
+}
+
+impl<'a, P: PageTableFrameMapping> MappedPageTableIter<'a, P> {
+    fn p4_index(&self) -> Option<PageTableIndex> {
+        if self.p4_index >= 512 {
+            return None;
+        }
+
+        Some(PageTableIndex::new(self.p4_index))
+    }
+
+    fn p3_index(&self) -> Option<PageTableIndex> {
+        if self.p3_index >= 512 {
+            return None;
+        }
+
+        Some(PageTableIndex::new(self.p3_index))
+    }
+
+    fn p2_index(&self) -> Option<PageTableIndex> {
+        if self.p2_index >= 512 {
+            return None;
+        }
+
+        Some(PageTableIndex::new(self.p2_index))
+    }
+
+    fn p1_index(&self) -> Option<PageTableIndex> {
+        if self.p1_index >= 512 {
+            return None;
+        }
+
+        Some(PageTableIndex::new(self.p1_index))
+    }
+
+    fn increment_p4_index(&mut self) -> Option<()> {
+        if self.p4_index >= 511 {
+            self.p4_index += 1;
+            return None;
+        }
+
+        self.p4_index += 1;
+        self.p3_index = 0;
+        self.p2_index = 0;
+        self.p1_index = 0;
+        Some(())
+    }
+
+    fn increment_p3_index(&mut self) -> Option<()> {
+        if self.p3_index == 511 {
+            self.increment_p4_index()?;
+            return None;
+        }
+
+        self.p3_index += 1;
+        self.p2_index = 0;
+        self.p1_index = 0;
+        Some(())
+    }
+
+    fn increment_p2_index(&mut self) -> Option<()> {
+        if self.p2_index == 511 {
+            self.increment_p3_index()?;
+            return None;
+        }
+
+        self.p2_index += 1;
+        self.p1_index = 0;
+        Some(())
+    }
+
+    fn increment_p1_index(&mut self) -> Option<()> {
+        if self.p1_index == 511 {
+            self.increment_p2_index()?;
+            return None;
+        }
+
+        self.p1_index += 1;
+        Some(())
+    }
+
+    fn next_forward(&mut self) -> Option<MappedPageItem> {
+        let p4 = self.level_4_table;
+
+        let p3 = loop {
+            match self.page_table_walker.next_table(&p4[self.p4_index()?]) {
+                Ok(page_table) => break page_table,
+                Err(PageTableWalkError::NotMapped) => self.increment_p4_index()?,
+                Err(PageTableWalkError::MappedToHugePage) => {
+                    panic!("level 4 entry has huge page bit set")
+                }
+            }
+        };
+
+        let p2 = loop {
+            match self.page_table_walker.next_table(&p3[self.p3_index()?]) {
+                Ok(page_table) => break page_table,
+                Err(PageTableWalkError::NotMapped) => self.increment_p3_index()?,
+                Err(PageTableWalkError::MappedToHugePage) => {
+                    let page =
+                        Page::from_page_table_indices_1gib(self.p4_index()?, self.p3_index()?);
+                    let entry = &p3[self.p3_index()?];
+                    let frame = PhysFrame::containing_address(entry.addr());
+                    let flags = entry.flags();
+                    let mapped_page = MappedPageItem::Size1GiB(MappedPage { page, frame, flags });
+
+                    self.increment_p3_index();
+                    return Some(mapped_page);
+                }
+            }
+        };
+
+        let p1 = loop {
+            match self.page_table_walker.next_table(&p2[self.p2_index()?]) {
+                Ok(page_table) => break page_table,
+                Err(PageTableWalkError::NotMapped) => self.increment_p2_index()?,
+                Err(PageTableWalkError::MappedToHugePage) => {
+                    let page = Page::from_page_table_indices_2mib(
+                        self.p4_index()?,
+                        self.p3_index()?,
+                        self.p2_index()?,
+                    );
+                    let entry = &p2[self.p2_index()?];
+                    let frame = PhysFrame::containing_address(entry.addr());
+                    let flags = entry.flags();
+                    let mapped_page = MappedPageItem::Size2MiB(MappedPage { page, frame, flags });
+
+                    self.increment_p2_index();
+                    return Some(mapped_page);
+                }
+            }
+        };
+
+        loop {
+            let p1_entry = &p1[self.p1_index()?];
+
+            if p1_entry.is_unused() {
+                self.increment_p1_index()?;
+                continue;
+            }
+
+            let frame = match PhysFrame::from_start_address(p1_entry.addr()) {
+                Ok(frame) => frame,
+                Err(AddressNotAligned) => {
+                    // Invalid frame address
+                    self.increment_p1_index()?;
+                    continue;
+                }
+            };
+
+            let page = Page::from_page_table_indices(
+                self.p4_index()?,
+                self.p3_index()?,
+                self.p2_index()?,
+                self.p1_index()?,
+            );
+            let flags = p1_entry.flags();
+            let mapped_page = MappedPageItem::Size4KiB(MappedPage { page, frame, flags });
+
+            self.increment_p1_index();
+            return Some(mapped_page);
+        }
+    }
+}
+
+impl<'a, P: PageTableFrameMapping> Iterator for MappedPageTableIter<'a, P> {
+    type Item = MappedPageItem;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.next_forward().or_else(|| self.next_forward())
+    }
+}