ch6: mmap file with demand-paging

Author: lythesia

easy-fs/src/efs.rs

@@ -125,6 +125,7 @@ impl EasyFileSystem {
         drop(guard);
 
         Inode::new(
+            0,
             root_inode_block_id,
             root_inode_offset,
             efs.clone(),

easy-fs/src/vfs.rs

@@ -10,6 +10,8 @@ use crate::{
 
 /// Virtual filesystem layer over easy-fs
 pub struct Inode {
+    inode_id: u32,
+
     // indicate which `DiskInode` is mapping
     block_id: usize,
     block_offset: usize,
@@ -21,12 +23,14 @@ pub struct Inode {
 impl Inode {
     /// Create a vfs inode
     pub fn new(
+        inode_id: u32,
         block_id: u32,
         block_offset: usize,
         fs: Arc<Mutex<EasyFileSystem>>,
         block_device: Arc<dyn BlockDevice>,
     ) -> Self {
         Self {
+            inode_id,
             block_id: block_id as usize,
             block_offset,
             fs,
@@ -73,6 +77,7 @@ impl Inode {
             self.find_inode_id(name, disk_inode).map(|inode_id| {
                 let (block_id, block_offset) = fs.get_disk_inode_pos(inode_id);
                 Arc::new(Inode::new(
+                    inode_id,
                     block_id,
                     block_offset,
                     self.fs.clone(),
@@ -108,7 +113,7 @@ impl Inode {
         disk_inode: &mut DiskInode,
         fs: &mut MutexGuard<EasyFileSystem>,
     ) {
-        if new_size < disk_inode.size {
+        if new_size <= disk_inode.size {
             return;
         }
 
@@ -160,6 +165,7 @@ impl Inode {
         // 4. return inode
         block_cache_sync_all();
         Some(Arc::new(Self::new(
+            new_inode_id,
             new_inode_block_id,
             new_inode_block_offset,
             self.fs.clone(),
@@ -199,4 +205,14 @@ impl Inode {
             disk_inode.write_at(offset, buf, &self.block_device)
         })
     }
+
+    /// Get inode id
+    pub fn inode_id(&self) -> u32 {
+        self.inode_id
+    }
+
+    /// Get data size of inode
+    pub fn get_size(&self) -> usize {
+        self.read_disk_inode(|disk_inode| disk_inode.size as usize)
+    }
 }

os/src/cast.rs

@@ -0,0 +1,20 @@
+use core::any::Any;
+
+use alloc::sync::Arc;
+
+pub trait DowncastArc: Any {
+    /// must be implemented: cast `Arc<Self>` into `Arc<dyn Any>`
+    fn as_any_arc(self: Arc<Self>) -> Arc<dyn Any>;
+
+    /// cast `Arc<dyn impl Trait>` into `Arc<T>`
+    fn downcast_arc<T: Any>(self: Arc<Self>) -> Option<Arc<T>> {
+        let arc_any: Arc<dyn Any> = self.as_any_arc();
+        if arc_any.is::<T>() {
+            // will not change ref-count
+            let ptr = Arc::into_raw(arc_any);
+            Some(unsafe { Arc::from_raw(ptr as *const T) })
+        } else {
+            None
+        }
+    }
+}

os/src/config.rs

@@ -10,3 +10,5 @@ pub const PAGE_SIZE: usize = 0x1000;
 pub const PAGE_SIZE_BITS: usize = 12;
 pub const TRAMPOLINE: usize = usize::MAX - PAGE_SIZE + 1;
 pub const TRAP_CONTEXT: usize = TRAMPOLINE - PAGE_SIZE;
+
+pub const MMAP_AREA_BASE: usize = 0x0000_0001_0000_0000; // base addr in user_space that nobody use

os/src/fs/inode.rs

@@ -41,6 +41,29 @@ impl OSInode {
         }
         v
     }
+
+    #[allow(unused)]
+    pub fn is_dir(&self) -> bool {
+        self.inner
+            .exclusive_access()
+            .inode
+            .read_disk_inode(|disk_inode| disk_inode.is_dir())
+    }
+
+    pub fn is_file(&self) -> bool {
+        self.inner
+            .exclusive_access()
+            .inode
+            .read_disk_inode(|disk_inode| disk_inode.is_file())
+    }
+
+    pub fn clone_inner_inode(&self) -> Arc<Inode> {
+        self.inner.exclusive_access().inode.clone()
+    }
+
+    pub fn copy(&self) -> Self {
+        Self::new(self.readable, self.writable, self.clone_inner_inode())
+    }
 }
 
 lazy_static! {

os/src/fs/mod.rs

@@ -1,11 +1,13 @@
-use crate::mm::UserBuffer;
+use core::any::Any;
+
+use crate::{cast::DowncastArc, mm::UserBuffer};
 
 mod inode;
 mod stdio;
-pub use inode::{list_apps, open_file, OpenFlags};
+pub use inode::{list_apps, open_file, OSInode, OpenFlags};
 pub use stdio::{Stdin, Stdout};
 
-pub trait File: Send + Sync {
+pub trait File: Any + Send + Sync {
     /// If readable
     fn readable(&self) -> bool;
     /// If writable
@@ -15,3 +17,10 @@ pub trait File: Send + Sync {
     /// Write `UserBuffer` to file
     fn write(&self, buf: UserBuffer) -> usize;
 }
+
+impl DowncastArc for dyn File {
+    fn as_any_arc(self: alloc::sync::Arc<Self>) -> alloc::sync::Arc<dyn Any> {
+        // need #![feature(trait_upcasting)]
+        self
+    }
+}

os/src/main.rs

@@ -3,12 +3,14 @@
 #![feature(array_windows)]
 #![feature(alloc_error_handler)]
 #![feature(slice_split_once)]
+#![feature(trait_upcasting)]
 
 extern crate alloc;
 extern crate bitflags;
 
 #[path = "boards/qemu.rs"]
 mod board;
+mod cast;
 mod config;
 #[macro_use]
 mod console;

os/src/mm/address.rs

@@ -220,14 +220,22 @@ impl StepByOne for VirtPageNum {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq)]
 pub struct SimpleRange<T>
 where
     T: StepByOne + Copy + Debug + PartialEq + PartialOrd,
 {
     l: T,
     r: T,
 }
+impl<T> Debug for SimpleRange<T>
+where
+    T: StepByOne + Copy + Debug + PartialEq + PartialOrd,
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "[{:?}, {:?})", self.l, self.r)
+    }
+}
 
 impl<T> SimpleRange<T>
 where
@@ -245,6 +253,21 @@ where
     pub fn get_end(&self) -> T {
         self.r
     }
+
+    pub fn contains(&self, v: impl Into<T>) -> bool {
+        let vpn: T = v.into();
+        self.l <= vpn && vpn < self.r // r excluded
+    }
+
+    pub fn overlap_with(&self, other: &Self) -> bool {
+        // coz rhs is excluded, we must make lhs+1 when comparing
+        let mut other_l = other.get_start();
+        other_l.step();
+        let mut self_l = self.l.clone();
+        self_l.step();
+
+        self.r >= other_l && other.get_end() >= self_l
+    }
 }
 
 impl<T> IntoIterator for SimpleRange<T>

os/src/mm/memory_set.rs

@@ -410,15 +410,11 @@ impl MemorySet {
         );
     }
 
-    /// Delegate to page_table
+    /// Delegate `token()` to page_table
     pub fn token(&self) -> usize {
         self.page_table.token()
     }
 
-    pub fn page_table_mut(&mut self) -> &mut PageTable {
-        &mut self.page_table
-    }
-
     pub fn remove_area_with_start_vpn(&mut self, start_vpn: VirtPageNum) {
         if let Some((idx, area)) = self
             .areas
@@ -434,6 +430,17 @@ impl MemorySet {
     pub fn recycle_data_pages(&mut self) {
         self.areas.clear();
     }
+
+    /// Delegate `map()` to page_table
+    pub fn map(&mut self, vpn: VirtPageNum, ppn: PhysPageNum, map_perm: MapPermission) {
+        let pte_flags = PTEFlags::from_bits_truncate(map_perm.bits);
+        self.page_table.map(vpn, ppn, pte_flags);
+    }
+
+    /// Delegate `unmap()` to page_table
+    pub fn unmap(&mut self, vpn: VirtPageNum) {
+        self.page_table.unmap(vpn);
+    }
 }
 
 #[allow(unused)]

os/src/mm/page_table.rs

@@ -73,6 +73,10 @@ impl PageTableEntry {
     pub fn executable(&self) -> bool {
         self.flags().contains(PTEFlags::X)
     }
+
+    pub fn is_dirty(&self) -> bool {
+        self.flags().contains(PTEFlags::D)
+    }
 }
 
 pub struct PageTable {