mem: map_to dont take the frame allocator as an argument anymore :^)

your welcome @czapek1337

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

src/aero_kernel/src/drivers/block/ahci.rs

@@ -582,7 +582,6 @@ impl HbaPort {
                             | PageTableFlags::WRITABLE
                             | PageTableFlags::WRITE_THROUGH
                             | PageTableFlags::NO_CACHE,
-                        &mut FRAME_ALLOCATOR,
                     )?
                     .flush();
             }
@@ -923,7 +922,6 @@ impl AhciProtected {
                     | PageTableFlags::NO_CACHE
                     | PageTableFlags::WRITABLE
                     | PageTableFlags::WRITE_THROUGH,
-                &mut FRAME_ALLOCATOR,
             )
         }?
         .flush();

src/aero_kernel/src/mem/alloc.rs

@@ -204,7 +204,6 @@ impl Allocator {
                                 page,
                                 frame,
                                 PageTableFlags::PRESENT | PageTableFlags::WRITABLE,
-                                &mut FRAME_ALLOCATOR,
                             )
                         }
                         .expect("Failed to map frame to extend the heap")
@@ -410,7 +409,6 @@ pub fn init_heap() {
                 Page::containing_address(VirtAddr::new(HEAP_START as _)),
                 frame,
                 PageTableFlags::PRESENT | PageTableFlags::WRITABLE,
-                &mut FRAME_ALLOCATOR,
             )
             .expect("init_heap: failed to initialize the heap")
             .flush();

src/aero_kernel/src/mem/paging/frame.rs

@@ -594,7 +594,7 @@ mod tests {
                 .is_free(frame.start_address(), 0));
         }
 
-        unsafe { offset_table.map_to(page, frame, PageTableFlags::PRESENT, &mut FRAME_ALLOCATOR) }
+        unsafe { offset_table.map_to(page, frame, PageTableFlags::PRESENT) }
             .unwrap()
             .flush();
 

src/aero_kernel/src/mem/paging/mapper.rs

@@ -173,30 +173,25 @@ pub trait Mapper<S: PageSize> {
     /// because of TLB races. It's worth noting that all the above requirements
     /// also apply to shared mappings, including the aliasing requirements.
     #[inline]
-    unsafe fn map_to<A>(
+    unsafe fn map_to(
         &mut self,
         page: Page<S>,
         frame: PhysFrame<S>,
         flags: PageTableFlags,
-        frame_allocator: &mut A,
     ) -> Result<MapperFlush<S>, MapToError<S>>
     where
         Self: Sized,
-        A: FrameAllocator<Size4KiB> + ?Sized,
     {
         let parent_table_flags = flags
             & (PageTableFlags::PRESENT
                 | PageTableFlags::WRITABLE
                 | PageTableFlags::USER_ACCESSIBLE);
 
-        self.map_to_with_table_flags(page, frame, flags, parent_table_flags, frame_allocator)
+        self.map_to_with_table_flags(page, frame, flags, parent_table_flags)
     }
 
     /// Creates a new mapping in the page table.
     ///
-    /// This function might need additional physical frames to create new page tables. These
-    /// frames are allocated from the `allocator` argument. At most three frames are required.
-    ///
     /// The flags of the parent table(s) can be explicitly specified. Those flags are used for
     /// newly created table entries, and for existing entries the flags are added.
     ///
@@ -231,17 +226,15 @@ pub trait Mapper<S: PageSize> {
     /// the same in all address spaces, otherwise undefined behavior can occur
     /// because of TLB races. It's worth noting that all the above requirements
     /// also apply to shared mappings, including the aliasing requirements.
-    unsafe fn map_to_with_table_flags<A>(
+    unsafe fn map_to_with_table_flags(
         &mut self,
         page: Page<S>,
         frame: PhysFrame<S>,
         flags: PageTableFlags,
         parent_table_flags: PageTableFlags,
-        frame_allocator: &mut A,
     ) -> Result<MapperFlush<S>, MapToError<S>>
     where
-        Self: Sized,
-        A: FrameAllocator<Size4KiB> + ?Sized;
+        Self: Sized;
 
     /// Removes a mapping from the page table and returns the frame that used to be mapped.
     ///
@@ -276,20 +269,18 @@ pub trait Mapper<S: PageSize> {
     /// This is a convencience function that invokes [`Mapper::map_to`] internally, so
     /// all safety requirements of it also apply for this function.
     #[inline]
-    unsafe fn identity_map<A>(
+    unsafe fn identity_map(
         &mut self,
         frame: PhysFrame<S>,
         flags: PageTableFlags,
-        frame_allocator: &mut A,
     ) -> Result<MapperFlush<S>, MapToError<S>>
     where
         Self: Sized,
-        A: FrameAllocator<Size4KiB> + ?Sized,
         S: PageSize,
         Self: Mapper<S>,
     {
         let page = Page::containing_address(VirtAddr::new(frame.start_address().as_u64()));
-        self.map_to(page, frame, flags, frame_allocator)
+        self.map_to(page, frame, flags)
     }
 }
 
@@ -412,46 +403,36 @@ impl<'a, P: PageTableFrameMapping> MappedPageTable<'a, P> {
         }
     }
 
-    fn map_to_2mib<A>(
+    fn map_to_2mib(
         &mut self,
         page: Page<Size2MiB>,
         frame: PhysFrame<Size2MiB>,
         flags: PageTableFlags,
         parent_table_flags: PageTableFlags,
-        allocator: &mut A,
-    ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>
-    where
-        A: FrameAllocator<Size4KiB> + ?Sized,
-    {
+    ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>> {
         let mut is_alloc_4 = false;
 
         let p4;
 
         if self.level_5_paging_enabled {
             let p5 = &mut self.page_table;
-            let (alloc, yes) = self.page_table_walker.create_next_table(
-                &mut p5[page.p5_index()],
-                parent_table_flags,
-                allocator,
-            )?;
+            let (alloc, yes) = self
+                .page_table_walker
+                .create_next_table(&mut p5[page.p5_index()], parent_table_flags)?;
 
             p4 = yes;
             is_alloc_4 = alloc;
         } else {
             p4 = &mut self.page_table;
         }
 
-        let (is_alloc_3, p3) = self.page_table_walker.create_next_table(
-            &mut p4[page.p4_index()],
-            parent_table_flags,
-            allocator,
-        )?;
+        let (is_alloc_3, p3) = self
+            .page_table_walker
+            .create_next_table(&mut p4[page.p4_index()], parent_table_flags)?;
 
-        let (is_alloc_2, p2) = self.page_table_walker.create_next_table(
-            &mut p3[page.p3_index()],
-            parent_table_flags,
-            allocator,
-        )?;
+        let (is_alloc_2, p2) = self
+            .page_table_walker
+            .create_next_table(&mut p3[page.p3_index()], parent_table_flags)?;
 
         if !p2[page.p2_index()].is_unused() {
             return Err(MapToError::PageAlreadyMapped(frame));
@@ -475,52 +456,40 @@ impl<'a, P: PageTableFrameMapping> MappedPageTable<'a, P> {
         Ok(MapperFlush::new(page))
     }
 
-    fn map_to_4kib<A>(
+    fn map_to_4kib(
         &mut self,
         page: Page<Size4KiB>,
         frame: PhysFrame<Size4KiB>,
         flags: PageTableFlags,
         parent_table_flags: PageTableFlags,
-        allocator: &mut A,
-    ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>
-    where
-        A: FrameAllocator<Size4KiB> + ?Sized,
-    {
+    ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>> {
         let p4;
 
         let mut is_alloc_4 = false;
 
         if self.level_5_paging_enabled {
             let p5 = &mut self.page_table;
-            let (alloc, yes) = self.page_table_walker.create_next_table(
-                &mut p5[page.p5_index()],
-                parent_table_flags,
-                allocator,
-            )?;
+            let (alloc, yes) = self
+                .page_table_walker
+                .create_next_table(&mut p5[page.p5_index()], parent_table_flags)?;
 
             p4 = yes;
             is_alloc_4 = alloc;
         } else {
             p4 = &mut self.page_table;
         }
 
-        let (is_alloc_3, p3) = self.page_table_walker.create_next_table(
-            &mut p4[page.p4_index()],
-            parent_table_flags,
-            allocator,
-        )?;
+        let (is_alloc_3, p3) = self
+            .page_table_walker
+            .create_next_table(&mut p4[page.p4_index()], parent_table_flags)?;
 
-        let (is_alloc_2, p2) = self.page_table_walker.create_next_table(
-            &mut p3[page.p3_index()],
-            parent_table_flags,
-            allocator,
-        )?;
+        let (is_alloc_2, p2) = self
+            .page_table_walker
+            .create_next_table(&mut p3[page.p3_index()], parent_table_flags)?;
 
-        let (is_alloc_1, p1) = self.page_table_walker.create_next_table(
-            &mut p2[page.p2_index()],
-            parent_table_flags,
-            allocator,
-        )?;
+        let (is_alloc_1, p1) = self
+            .page_table_walker
+            .create_next_table(&mut p2[page.p2_index()], parent_table_flags)?;
 
         if !p1[page.p1_index()].is_unused() {
             return Err(MapToError::PageAlreadyMapped(frame));
@@ -551,18 +520,14 @@ impl<'a, P: PageTableFrameMapping> MappedPageTable<'a, P> {
 
 impl<'a, P: PageTableFrameMapping> Mapper<Size2MiB> for MappedPageTable<'a, P> {
     #[inline]
-    unsafe fn map_to_with_table_flags<A>(
+    unsafe fn map_to_with_table_flags(
         &mut self,
         page: Page<Size2MiB>,
         frame: PhysFrame<Size2MiB>,
         flags: PageTableFlags,
         parent_table_flags: PageTableFlags,
-        allocator: &mut A,
-    ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>
-    where
-        A: FrameAllocator<Size4KiB> + ?Sized,
-    {
-        self.map_to_2mib(page, frame, flags, parent_table_flags, allocator)
+    ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>> {
+        self.map_to_2mib(page, frame, flags, parent_table_flags)
     }
 
     fn unmap(
@@ -675,18 +640,14 @@ impl<'a, P: PageTableFrameMapping> Mapper<Size2MiB> for MappedPageTable<'a, P> {
 
 impl<'a, P: PageTableFrameMapping> Mapper<Size4KiB> for MappedPageTable<'a, P> {
     #[inline]
-    unsafe fn map_to_with_table_flags<A>(
+    unsafe fn map_to_with_table_flags(
         &mut self,
         page: Page<Size4KiB>,
         frame: PhysFrame<Size4KiB>,
         flags: PageTableFlags,
         parent_table_flags: PageTableFlags,
-        allocator: &mut A,
-    ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>
-    where
-        A: FrameAllocator<Size4KiB> + ?Sized,
-    {
-        self.map_to_4kib(page, frame, flags, parent_table_flags, allocator)
+    ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>> {
+        self.map_to_4kib(page, frame, flags, parent_table_flags)
     }
 
     fn unmap(
@@ -933,19 +894,15 @@ impl<P: PageTableFrameMapping> PageTableWalker<P> {
     /// Returns `MapToError::FrameAllocationFailed` if the entry is unused and the allocator
     /// returned `None`. Returns `MapToError::ParentEntryHugePage` if the `HUGE_PAGE` flag is set
     /// in the passed entry.
-    fn create_next_table<'b, A>(
+    fn create_next_table<'b>(
         &self,
         entry: &'b mut PageTableEntry,
         insert_flags: PageTableFlags,
-        allocator: &mut A,
-    ) -> Result<(bool, &'b mut PageTable), PageTableCreateError>
-    where
-        A: FrameAllocator<Size4KiB> + ?Sized,
-    {
+    ) -> Result<(bool, &'b mut PageTable), PageTableCreateError> {
         let created;
 
         if entry.is_unused() {
-            if let Some(frame) = allocator.allocate_frame() {
+            if let Some(frame) = unsafe { FRAME_ALLOCATOR.allocate_frame() } {
                 entry.set_frame(frame, insert_flags);
                 created = true;
             } else {
@@ -1120,19 +1077,15 @@ unsafe impl PageTableFrameMapping for PhysOffset {
 
 impl<'a> Mapper<Size2MiB> for OffsetPageTable<'a> {
     #[inline]
-    unsafe fn map_to_with_table_flags<A>(
+    unsafe fn map_to_with_table_flags(
         &mut self,
         page: Page<Size2MiB>,
         frame: PhysFrame<Size2MiB>,
         flags: PageTableFlags,
         parent_table_flags: PageTableFlags,
-        allocator: &mut A,
-    ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>>
-    where
-        A: FrameAllocator<Size4KiB> + ?Sized,
-    {
+    ) -> Result<MapperFlush<Size2MiB>, MapToError<Size2MiB>> {
         self.inner
-            .map_to_with_table_flags(page, frame, flags, parent_table_flags, allocator)
+            .map_to_with_table_flags(page, frame, flags, parent_table_flags)
     }
 
     #[inline]
@@ -1160,19 +1113,15 @@ impl<'a> Mapper<Size2MiB> for OffsetPageTable<'a> {
 
 impl<'a> Mapper<Size4KiB> for OffsetPageTable<'a> {
     #[inline]
-    unsafe fn map_to_with_table_flags<A>(
+    unsafe fn map_to_with_table_flags(
         &mut self,
         page: Page<Size4KiB>,
         frame: PhysFrame<Size4KiB>,
         flags: PageTableFlags,
         parent_table_flags: PageTableFlags,
-        allocator: &mut A,
-    ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>>
-    where
-        A: FrameAllocator<Size4KiB> + ?Sized,
-    {
+    ) -> Result<MapperFlush<Size4KiB>, MapToError<Size4KiB>> {
         self.inner
-            .map_to_with_table_flags(page, frame, flags, parent_table_flags, allocator)
+            .map_to_with_table_flags(page, frame, flags, parent_table_flags)
     }
 
     #[inline]

src/aero_kernel/src/userland/vm.rs

@@ -286,7 +286,6 @@ impl Mapping {
                     PageTableFlags::USER_ACCESSIBLE
                         | PageTableFlags::PRESENT
                         | self.protection.into(),
-                    &mut FRAME_ALLOCATOR,
                 )
             }
             .expect("Failed to identity map userspace private mapping")
@@ -350,7 +349,6 @@ impl Mapping {
                         PageTableFlags::PRESENT
                             | PageTableFlags::USER_ACCESSIBLE
                             | self.protection.into(),
-                        &mut FRAME_ALLOCATOR,
                     )
                 }
                 .expect("failed to map allocated frame for private file read")
@@ -406,7 +404,6 @@ impl Mapping {
                     page,
                     new_frame,
                     PageTableFlags::PRESENT | PageTableFlags::USER_ACCESSIBLE | protection.into(),
-                    &mut FRAME_ALLOCATOR,
                 )?
                 .flush();
         }