vm: refactor handle_pf_file

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

Author: Andy-Python-Programmer

src/Cargo.lock

@@ -29,10 +29,8 @@ bit_field = "0.10.1"
 log = "0.4.14"
 raw-cpuid = "10.0.0"
 xmas-elf = "0.8.0"
-paste = "1.0.5"
 hashbrown = "0.11.2"
 rustc-demangle = "0.1.20"
-lru = "0.6.5"
 stivale-boot = "0.2.6"
 intrusive-collections = "0.9.2"
 aml = "0.15.0"

src/aero_kernel/Cargo.toml

@@ -95,7 +95,9 @@ pub(super) fn page_fault(stack: &mut InterruptErrorStack) {
         log::error!("stack: {:#x?}", stack);
     };
 
-    if accessed_address < userland_last_address && scheduler::is_initialized() {
+    if accessed_address < userland_last_address && scheduler::is_initialized()
+        || stack.stack.iret.is_user()
+    {
         let signal = scheduler::get_scheduler()
             .current_task()
             .vm
@@ -105,21 +107,19 @@ pub(super) fn page_fault(stack: &mut InterruptErrorStack) {
             log::error!("Segmentation fault");
             print_info();
 
-            if stack.stack.iret.is_user() {
-                let task = scheduler::get_scheduler().current_task();
-
-                log::error!(
-                    "process: (pid={}, pid={})",
-                    task.tid().as_usize(),
-                    task.pid().as_usize()
-                );
+            let task = scheduler::get_scheduler().current_task();
 
-                log::error!(
-                    "process: (path=`{}`)",
-                    task.path()
-                        .expect("userland application does not have a path set")
-                );
-            }
+            log::error!(
+                "process: (pid={}, pid={})",
+                task.tid().as_usize(),
+                task.pid().as_usize()
+            );
+
+            log::error!(
+                "process: (path=`{}`)",
+                task.path()
+                    .expect("userland application does not have a path set")
+            );
 
             scheduler::get_scheduler().current_task().vm.log();
             scheduler::get_scheduler().current_task().file_table.log();

src/aero_kernel/src/arch/x86_64/interrupts/exceptions.rs

@@ -69,8 +69,8 @@ static PAGING_TAG: Stivale5LevelPagingHeaderTag = Stivale5LevelPagingHeaderTag::
     .next((&UNMAP_NULL as *const StivaleUnmapNullHeaderTag).cast());
 
 /// The stivale2 specification says we need to define a "header structure".
-/// This structure needs to reside in the .stivale2hdr ELF section in order
-/// for the bootloader to find it. We use the #[linker_section] and #[used] macros to
+/// This structure needs to reside in the `.stivale2hdr` ELF section in order
+/// for the bootloader to find it. We use the `#[linker_section]` and `#[used]` macros to
 /// tell the compiler to put the following structure in said section.
 #[link_section = ".stivale2hdr"]
 #[no_mangle]

src/aero_kernel/src/arch/x86_64/mod.rs

@@ -246,6 +246,7 @@ impl ArchTask {
         envv: Option<ExecArgs>,
     ) -> Result<(), MapToError<Size4KiB>> {
         let address_space = AddressSpace::new()?;
+        let loaded_binary = vm.load_bin(executable).expect("exec: failed to load ELF");
 
         // mmap the userland stack...
         vm.mmap(
@@ -261,8 +262,6 @@ impl ArchTask {
 
         address_space.switch(); // Perform the address space switch
 
-        let loaded_binary = vm.load_bin(executable).expect("exec: failed to load ELF");
-
         self.context = Unique::dangling();
         self.address_space = address_space; // Update the address space reference
 

src/aero_kernel/src/arch/x86_64/task.rs

@@ -121,8 +121,8 @@ impl INodeInterface for DevINode {
         self.0.inode().read_at(offset, buffer)
     }
 
-    fn mmap(&self, offset: usize, flags: MMapFlags) -> Result<PhysAddr> {
-        self.0.inode().mmap(offset, flags)
+    fn mmap(&self, offset: usize, size: usize, flags: MMapFlags) -> Result<PhysFrame> {
+        self.0.inode().mmap(offset, size, flags)
     }
 
     fn ioctl(&self, command: usize, arg: usize) -> Result<usize> {
@@ -278,12 +278,12 @@ impl INodeInterface for DevFb {
             .expect("/dev/fb: terminal not initialized")
     }
 
-    fn mmap(&self, offset: usize, flags: MMapFlags) -> Result<PhysAddr> {
+    fn mmap(&self, offset: usize, size: usize, flags: MMapFlags) -> Result<PhysFrame> {
         let rinfo = crate::rendy::get_rendy_info();
 
         // Make sure we are in bounds.
         if offset > rinfo.byte_len || offset + Size4KiB::SIZE as usize > rinfo.byte_len {
-            return Ok(PhysAddr::zero());
+            return Ok(PhysFrame::containing_address(PhysAddr::zero()));
         }
 
         crate::rendy::DEBUG_RENDY
@@ -300,23 +300,17 @@ impl INodeInterface for DevFb {
 
                     let fb_phys_ptr = fb_ptr.sub(crate::PHYSICAL_MEMORY_OFFSET.as_u64() as usize);
 
-                    Ok(PhysAddr::new_unchecked(fb_phys_ptr as u64))
+                    Ok(PhysFrame::containing_address(PhysAddr::new_unchecked(
+                        fb_phys_ptr as u64,
+                    )))
                 } else {
                     let fb = lock.get_framebuffer();
 
                     // This is a private file mapping.
-                    let private_cp: PhysFrame = FRAME_ALLOCATOR
-                        .allocate_frame()
-                        .expect("/dev/fb: failed to allocate frame for private file mapping");
+                    let private_cp: PhysFrame = FRAME_ALLOCATOR.allocate_frame().unwrap();
+                    private_cp.as_slice_mut()[..size].copy_from_slice(&fb[offset..offset + size]);
 
-                    let private_phys = private_cp.start_address();
-                    let private_virt = crate::PHYSICAL_MEMORY_OFFSET + private_phys.as_u64();
-                    let private_ptr = private_virt.as_mut_ptr();
-
-                    core::slice::from_raw_parts_mut(private_ptr, Size4KiB::SIZE as usize)
-                        .copy_from_slice(&fb[offset..offset + Size4KiB::SIZE as usize]);
-
-                    Ok(private_phys)
+                    Ok(private_cp)
                 }
             })
             .expect("/dev/fb: terminal not initialized")

src/aero_kernel/src/fs/devfs.rs

@@ -29,7 +29,7 @@ use alloc::sync::Weak;
 use alloc::vec::Vec;
 use spin::Once;
 
-use crate::mem::paging::PhysAddr;
+use crate::mem::paging::PhysFrame;
 use crate::utils::sync::Mutex;
 use crate::utils::Downcastable;
 
@@ -137,7 +137,7 @@ pub trait INodeInterface: Send + Sync + Downcastable {
         Err(FileSystemError::NotSupported)
     }
 
-    fn mmap(&self, _offset: usize, _flags: MMapFlags) -> Result<PhysAddr> {
+    fn mmap(&self, _offset: usize, _size: usize, _flags: MMapFlags) -> Result<PhysFrame> {
         Err(FileSystemError::NotSupported)
     }
 

src/aero_kernel/src/fs/inode.rs

@@ -31,7 +31,7 @@ use alloc::sync::{Arc, Weak};
 use alloc::vec::Vec;
 use spin::RwLock;
 
-use crate::mem::paging::PhysAddr;
+use crate::mem::paging::*;
 use crate::utils::downcast;
 use crate::utils::sync::Mutex;
 
@@ -311,18 +311,28 @@ impl INodeInterface for LockedRamINode {
         }
     }
 
-    fn mmap(&self, offset: usize, flags: MMapFlags) -> Result<PhysAddr> {
+    fn mmap(&self, offset: usize, size: usize, flags: MMapFlags) -> Result<PhysFrame> {
         let this = self.0.read();
 
         match &this.contents {
             FileContents::Device(dev) => {
                 let device = dev.clone();
                 drop(this);
 
-                device.mmap(offset, flags)
+                device.mmap(offset, size, flags)
             }
 
-            // TODO: Support memory mapping ramfs files:
+            FileContents::StaticContent(contents) => {
+                // TODO: Support shared static content ramfs file mappings.
+                assert!(!flags.contains(MMapFlags::MAP_SHARED));
+
+                let private_cp: PhysFrame = unsafe { FRAME_ALLOCATOR.allocate_frame().unwrap() };
+                private_cp.as_slice_mut()[..size].copy_from_slice(&contents[offset..offset + size]);
+
+                Ok(private_cp)
+            }
+
+            // TODO: Support other memory mapping ramfs files:
             _ => Err(FileSystemError::NotSupported),
         }
     }

src/aero_kernel/src/fs/ramfs.rs

@@ -552,9 +552,8 @@ impl VmFrame {
     pub fn dec_ref_count(&self) {
         let mut this = self.lock.lock();
 
-        if this.use_count > 0 {
-            this.use_count -= 1;
-        }
+        assert!(this.use_count > 0);
+        this.use_count -= 1;
     }
 
     pub fn inc_ref_count(&self) {

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

@@ -296,6 +296,20 @@ impl<S: PageSize> PhysFrame<S> {
     pub fn start_address(self) -> PhysAddr {
         self.start_address
     }
+
+    pub fn as_slice_mut<T>(&self) -> &mut [T] {
+        assert!(core::mem::size_of::<T>() < S::SIZE as usize);
+
+        // TODO: Move the physical to virtual address translation to the `PhysAddr` structure.
+        let virt = unsafe { crate::PHYSICAL_MEMORY_OFFSET + self.start_address.as_u64() };
+        let ptr = virt.as_mut_ptr::<T>();
+
+        // SAFETY: The size of the slice is equal to the size of the frame and the
+        // pointer is valid.
+        unsafe {
+            core::slice::from_raw_parts_mut(ptr, S::SIZE as usize / core::mem::size_of::<T>())
+        }
+    }
 }
 
 impl<S: PageSize> fmt::Debug for PhysFrame<S> {