Use our new RangeInclusive type for PageRange/FrameRange (theseus-os#979)

See 7be4829 for more details on this `RangeInclusive` type.

Author: kevinaboos

Cargo.lock

@@ -634,6 +634,7 @@ doc:
 		--package owned_borrowed_trait \
 		--package percent-encoding \
 		--package port_io \
+		--package range_inclusive \
 		--package stdio \
 		--package str_ref
 ## Now, build the docs for all of Theseus's main kernel crates.

Makefile

@@ -45,8 +45,8 @@ Intrinsically, `Page`s have no relation to `PhysicalAddress`es, and similarly, `
 
 
 For convenience, Theseus provides dedicated "range" types to represent a contiguous range of virtual `Page`s or physical `Frame`s. 
-They are inclusive ranges on both sides; see Rust's built-in [`RangeInclusive`] type for more information.
-These types implement the standard Rust [`Iterator`] trait, allowing for easy iteration over all pages or frames in a range.
+They are inclusive ranges on both sides; see our custom [`RangeInclusive`] type that replaces Rust's built-in `core::ops::RangeInclusive` type for more information.
+These types implement the standard Rust [`IntoIterator`] trait, allowing for easy iteration over all pages or frames in a range.
 
 Theseus employs macros to generate the implementation of the above basic types,
 as they are symmetric across the virtual memory and physical memory categories.
@@ -103,7 +103,7 @@ That is a powerful guarantee that allows us to build stronger isolation and safe
 [`page_allocator`]:  https://theseus-os.github.io/Theseus/doc/page_allocator/index.html
 [`frame_allocator`]: https://theseus-os.github.io/Theseus/doc/frame_allocator/index.html
 [`Iterator`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html
-[`RangeInclusive`]: https://doc.rust-lang.org/std/ops/struct.RangeInclusive.html
+[`RangeInclusive`]: https://theseus-os.github.io/Theseus/doc/range_inclusive/index.html
 
 [page allocator]:  https://theseus-os.github.io/Theseus/doc/page_allocator/index.html
 [frame allocator]: https://theseus-os.github.io/Theseus/doc/frame_allocator/index.html

book/src/subsystems/memory.md

@@ -3,20 +3,15 @@ authors = ["Kevin Boos <[email protected]>"]
 name = "frame_allocator"
 description = "The allocator for physical memory frames."
 version = "0.1.0"
+edition = "2021"
 
 [dependencies]
+log = "0.4.8"
 spin = "0.9.4"
 intrusive-collections = "0.9.0"
 static_assertions = "1.1.0"
 
-[dependencies.log]
-version = "0.4.8"
+range_inclusive = { path = "../../libs/range_inclusive" }
 
-[dependencies.kernel_config]
-path = "../kernel_config"
-
-[dependencies.memory_structs]
-path = "../memory_structs"
-
-[lib]
-crate-type = ["rlib"]
+kernel_config = { path = "../kernel_config" }
+memory_structs = { path = "../memory_structs" }

kernel/frame_allocator/Cargo.toml

@@ -18,17 +18,10 @@
 //! We don't need to do so until we actually run out of address space or until 
 //! a requested address is in a chunk that needs to be merged.
 
-#![allow(clippy::blocks_in_if_conditions)]
 #![no_std]
+#![allow(clippy::blocks_in_if_conditions)]
 
 extern crate alloc;
-#[macro_use] extern crate log;
-extern crate kernel_config;
-extern crate memory_structs;
-extern crate spin;
-#[macro_use] extern crate static_assertions;
-extern crate intrusive_collections;
-
 #[cfg(test)]
 mod test;
 
@@ -37,11 +30,14 @@ mod static_array_rb_tree;
 
 
 use core::{borrow::Borrow, cmp::{Ordering, min, max}, fmt, ops::{Deref, DerefMut}, marker::PhantomData};
+use intrusive_collections::Bound;
 use kernel_config::memory::*;
+use log::{error, warn, debug, trace};
 use memory_structs::{PhysicalAddress, Frame, FrameRange};
+use range_inclusive::RangeInclusiveIterator;
 use spin::Mutex;
-use intrusive_collections::Bound;
 use static_array_rb_tree::*;
+use static_assertions::assert_not_impl_any;
 
 const FRAME_SIZE: usize = PAGE_SIZE;
 const MIN_FRAME: Frame = Frame::containing_address(PhysicalAddress::zero());
@@ -494,31 +490,29 @@ impl<'f> IntoIterator for &'f AllocatedFrames {
     fn into_iter(self) -> Self::IntoIter {
         AllocatedFramesIter {
             _owner: self,
-            range: self.frames.clone(),
+            range_iter: self.frames.iter(),
         }
     }
 }
 
 /// An iterator over each [`AllocatedFrame`] in a range of [`AllocatedFrames`].
-/// 
+///
 /// We must implement our own iterator type here in order to tie the lifetime `'f`
 /// of a returned `AllocatedFrame<'f>` type to the lifetime of its containing `AllocatedFrames`.
 /// This is because the underlying type of `AllocatedFrames` is a [`FrameRange`],
-/// which itself is a [`core::ops::RangeInclusive`] of [`Frame`]s, and unfortunately the
-/// `RangeInclusive` type doesn't implement an immutable iterator.
-/// 
-/// Iterating through a `RangeInclusive` actually modifies its own internal range,
-/// so we must avoid doing that because it would break the semantics of a `FrameRange`.
-/// In fact, this is why [`FrameRange`] only implements `IntoIterator` but
-/// does not implement [`Iterator`] itself.
+/// which itself is a [`RangeInclusive`] of [`Frame`]s.
+/// Currently, the [`RangeInclusiveIterator`] type creates a clone of the original
+/// [`RangeInclusive`] instances rather than borrowing a reference to it.
+///
+/// [`RangeInclusive`]: range_inclusive::RangeInclusive
 pub struct AllocatedFramesIter<'f> {
     _owner: &'f AllocatedFrames,
-    range: FrameRange,
+    range_iter: RangeInclusiveIterator<Frame>,
 }
 impl<'f> Iterator for AllocatedFramesIter<'f> {
     type Item = AllocatedFrame<'f>;
     fn next(&mut self) -> Option<Self::Item> {
-        self.range.next().map(|frame|
+        self.range_iter.next().map(|frame|
             AllocatedFrame {
                 frame, _phantom: PhantomData,
             }

kernel/frame_allocator/src/lib.rs

@@ -100,7 +100,7 @@ impl<T: Ord + 'static> StaticArrayRBTree<T> {
 						return Ok(ValueRefMut::Array(elem));
 					}
 				}
-				error!("Out of space in StaticArrayRBTree's inner array, failed to insert value.");
+				log::error!("Out of space in StaticArrayRBTree's inner array, failed to insert value.");
 				Err(value)
 			}
 			Inner::RBTree(tree) => {

kernel/frame_allocator/src/static_array_rb_tree.rs

@@ -11,6 +11,4 @@ derive_more = "0.99.0"
 paste = "1.0.5"
 
 kernel_config = { path = "../kernel_config" }
-
-[lib]
-crate-type = ["rlib"]
+range_inclusive = { path = "../../libs/range_inclusive" }

kernel/memory_structs/Cargo.toml

@@ -12,12 +12,13 @@ use core::{
     cmp::{min, max},
     fmt,
     iter::Step,
-    ops::{Add, AddAssign, Deref, DerefMut, RangeInclusive, Sub, SubAssign}
+    ops::{Add, AddAssign, Deref, DerefMut, Sub, SubAssign}
 };
 use kernel_config::memory::{MAX_PAGE_NUMBER, PAGE_SIZE};
 use zerocopy::FromBytes;
 use paste::paste;
 use derive_more::*;
+use range_inclusive::{RangeInclusive, RangeInclusiveIterator};
 
 /// A macro for defining `VirtualAddress` and `PhysicalAddress` structs
 /// and implementing their common traits, which are generally identical.
@@ -488,9 +489,9 @@ macro_rules! implement_page_frame_range {
             }
             impl IntoIterator for $TypeName {
                 type Item = $chunk;
-                type IntoIter = RangeInclusive<$chunk>;
+                type IntoIter = RangeInclusiveIterator<$chunk>;
                 fn into_iter(self) -> Self::IntoIter {
-                    self.0
+                    self.0.iter()
                 }
             }