Merge branch 'master' into riscv64-support

crates/eonix_mm/src/page_table/page_table.rs

@@ -90,7 +90,31 @@ where
         Self::iter_kernel_levels(self, range, M::LEVELS)
     }
 
-    pub fn iter_kernel_levels(&self, range: VRange, levels: &'static [PageTableLevel]) -> impl Iterator<Item = &mut M::Entry> {
+    /// Iterates over the kernel space entries in the page table for the specified levels.
+    ///
+    /// # Parameters
+    /// - `range`: The virtual address range to iterate over.
+    /// - `levels`: A slice of `PageTableLevel` that specifies which levels of the page table
+    ///   should be included in the iteration. Each level corresponds to a level in the page
+    ///   table hierarchy, and the iterator will traverse entries at these levels.
+    ///
+    /// # Returns
+    /// An iterator over mutable references to the page table entries (`M::Entry`) within the
+    /// specified range and levels.
+    ///
+    /// # Example
+    /// ```
+    /// let range = VRange::new(0x1234000, 0x1300000);
+    /// let levels = &M::LEVELS[..2];
+    /// for pte in page_table.iter_kernel_levels(range, levels) {
+    ///     // Process each entry
+    /// }
+    /// ```
+    pub fn iter_kernel_levels(
+        &self,
+        range: VRange,
+        levels: &'static [PageTableLevel],
+    ) -> impl Iterator<Item = &mut M::Entry> {
         let alloc = self.root_table_page.allocator();
         let page_table_ptr = X::get_ptr_for_page(&self.root_table_page);
         let root_page_table = unsafe {
@@ -98,7 +122,12 @@ where
             M::RawTable::from_ptr(page_table_ptr)
         };
 
-        PageTableIterator::<M, A, X, KernelIterator>::new_levels(root_page_table, range, alloc.clone(), levels)
+        PageTableIterator::<M, A, X, KernelIterator>::with_levels(
+            root_page_table,
+            range,
+            alloc.clone(),
+            levels,
+        )
     }
 
     fn drop_page_table_recursive(page_table: &Page<A>, levels: &[PageTableLevel]) {

crates/eonix_mm/src/page_table/paging_mode.rs

@@ -28,6 +28,10 @@ impl PageTableLevel {
         self.1
     }
 
+    pub const fn page_size(self) -> usize {
+        1 << self.nth_bit()
+    }
+
     pub const fn max_index(self) -> u16 {
         (1 << self.len()) - 1
     }

crates/eonix_mm/src/page_table/pte_iterator.rs

@@ -1,9 +1,10 @@
 use super::{
-    pte::{RawAttribute, TableAttribute}, PageTableLevel, PagingMode, RawPageTable as _, PTE
+    pte::{RawAttribute, TableAttribute},
+    PageTableLevel, PagingMode, RawPageTable as _, PTE,
 };
 use crate::{
     address::{AddrOps as _, VRange},
-    paging::{Page, PageAccess, PageAlloc, PAGE_SIZE},
+    paging::{Page, PageAccess, PageAlloc},
 };
 use core::{marker::PhantomData};
 
@@ -57,8 +58,11 @@ where
     M::Entry: 'a,
     A: PageAlloc,
     X: PageAccess,
-    K: IteratorType<M>,
 {
+    /// Specifies the hierarchy of page table levels to iterate over.
+    /// This field determines the sequence of levels in the page table
+    /// hierarchy that the iterator will traverse, starting from the
+    /// highest level and moving down to the lowest.
     levels: &'static [PageTableLevel],
     remaining: usize,
 
@@ -79,7 +83,6 @@ where
 {
 
     fn parse_tables_starting_from(&mut self, idx_level: usize) {
-
         for (idx, &pt_idx) in self
             .indicies
             .iter()
@@ -100,16 +103,23 @@ where
     }
 
     pub fn new(page_table: M::RawTable<'a>, range: VRange, alloc: A) -> Self {
-        Self::new_levels(page_table, range, alloc, M::LEVELS)
+        Self::with_levels(page_table, range, alloc, M::LEVELS)
     }
 
-    pub fn new_levels(page_table: M::RawTable<'a>, range: VRange, alloc: A, levels: &'static [PageTableLevel]) -> Self {
+    pub fn with_levels(
+        page_table: M::RawTable<'a>,
+        range: VRange,
+        alloc: A,
+        levels: &'static [PageTableLevel],
+    ) -> Self {
         let start = range.start().floor();
         let end = range.end().ceil();
 
+        let [.., last_level] = levels else { unreachable!() };
+
         let mut me = Self {
             levels,
-            remaining: (end - start) / PAGE_SIZE,
+            remaining: (end - start) / last_level.page_size(),
             indicies: [0; 8],
             tables: [const { None }; 8],
             alloc,
@@ -141,7 +151,7 @@ where
         if self.remaining == 0 {
             return None;
         } else {
-            self.remaining -= (1 << (self.levels.last()?.nth_bit())) / PAGE_SIZE;
+            self.remaining -= 1;
         }
 
         let table_level = self.levels.len() - 1;
@@ -150,7 +160,8 @@ where
             .unwrap()
             .index_mut(self.indicies[table_level]);
 
-        let idx_level_start_updating = self.levels
+        let idx_level_start_updating = self
+            .levels
             .iter()
             .zip(self.indicies.iter_mut())
             .enumerate()