propagate timestamps to virtual file handles

lib/virtual-fs/src/lib.rs

@@ -336,6 +336,12 @@ pub trait VirtualFile:
     /// the time at which the file was created in nanoseconds as a UNIX timestamp
     fn created_time(&self) -> u64;
 
+    /// sets accessed time
+    fn set_accessed(&mut self, _atime: u64) {}
+
+    /// sets modification time
+    fn set_modified(&mut self, _mtime: u64) {}
+
     /// the size of the file in bytes
     fn size(&self) -> u64;
 

lib/virtual-fs/src/mem_fs/file.rs

@@ -144,6 +144,30 @@ impl VirtualFile for FileHandle {
         node.metadata().created
     }
 
+    fn set_accessed(&mut self, atime: u64) {
+        let mut fs = match self.filesystem.inner.write() {
+            Ok(fs) => fs,
+            _ => return,
+        };
+
+        let inode = fs.storage.get_mut(self.inode);
+        if let Some(node) = inode {
+            node.metadata_mut().accessed = atime;
+        }
+    }
+
+    fn set_modified(&mut self, mtime: u64) {
+        let mut fs = match self.filesystem.inner.write() {
+            Ok(fs) => fs,
+            _ => return,
+        };
+
+        let inode = fs.storage.get_mut(self.inode);
+        if let Some(node) = inode {
+            node.metadata_mut().modified = mtime;
+        }
+    }
+
     fn size(&self) -> u64 {
         let fs = match self.filesystem.inner.read() {
             Ok(fs) => fs,

lib/wasix/src/syscalls/wasi/fd_filestat_set_times.rs

@@ -1,3 +1,5 @@
+use std::borrow::BorrowMut;
+
 use super::*;
 use crate::syscalls::*;
 
@@ -59,13 +61,17 @@ pub(crate) fn fd_filestat_set_times_internal(
 
     let inode = fd_entry.inode;
 
+    let mut atime = None;
+    let mut mtime = None;
+
     if fst_flags.contains(Fstflags::SET_ATIM) || fst_flags.contains(Fstflags::SET_ATIM_NOW) {
         let time_to_set = if fst_flags.contains(Fstflags::SET_ATIM) {
             st_atim
         } else {
             get_current_time_in_nanos()?
         };
         inode.stat.write().unwrap().st_atim = time_to_set;
+        atime = Some(time_to_set);
     }
 
     if fst_flags.contains(Fstflags::SET_MTIM) || fst_flags.contains(Fstflags::SET_MTIM_NOW) {
@@ -75,6 +81,23 @@ pub(crate) fn fd_filestat_set_times_internal(
             get_current_time_in_nanos()?
         };
         inode.stat.write().unwrap().st_mtim = time_to_set;
+        mtime = Some(time_to_set);
+    }
+
+    if let Kind::File {
+        handle: Some(handle),
+        ..
+    } = inode.kind.write().unwrap().deref()
+    {
+        let mut handle = handle.write().unwrap();
+
+        if let Some(time) = atime {
+            handle.set_accessed(time);
+        }
+
+        if let Some(time) = mtime {
+            handle.set_modified(time);
+        }
     }
 
     Ok(())