[WasmFS] /dev/null and directory mtime updates (#17241)

Implement all the functionality needed to pass wasmfs.test_stat except for the
ability to follow symlinks. In particular, implement /dev/null and update
directory mtimes when their contents are changed.

Update WasmFS to unconditionally return 0 as the st_rdev to bring it in line
with the legacy file system on normal files, although the legacy file system
reports other values for special files.

Author: tlively

.circleci/config.yml

@@ -419,7 +419,8 @@ jobs:
             wasmfs.test_exit_status
             wasmfs.test_minimal_runtime_memorygrowth
             wasmfs.test_mmap_anon*
-            wasmfs.test_getcwd_with_non_ascii_name"
+            wasmfs.test_getcwd_with_non_ascii_name
+            wasmfs.test_stat"
   test-wasm2js1:
     executor: bionic
     steps:

system/lib/wasmfs/file.cpp

@@ -99,6 +99,7 @@ Directory::Handle::insertDataFile(const std::string& name, mode_t mode) {
     return nullptr;
   }
   cacheChild(name, child, DCacheKind::Normal);
+  setMTime(time(NULL));
   return child;
 }
 
@@ -113,6 +114,7 @@ Directory::Handle::insertDirectory(const std::string& name, mode_t mode) {
     return nullptr;
   }
   cacheChild(name, child, DCacheKind::Normal);
+  setMTime(time(NULL));
   return child;
 }
 
@@ -128,6 +130,7 @@ Directory::Handle::insertSymlink(const std::string& name,
     return nullptr;
   }
   cacheChild(name, child, DCacheKind::Normal);
+  setMTime(time(NULL));
   return child;
 }
 
@@ -141,7 +144,8 @@ bool Directory::Handle::insertMove(const std::string& name,
     return false;
   }
   // Look up the file in its old parent's cache.
-  auto& oldCache = file->locked().getParent()->dcache;
+  auto oldParent = file->locked().getParent();
+  auto& oldCache = oldParent->dcache;
   auto oldIt = std::find_if(oldCache.begin(), oldCache.end(), [&](auto& kv) {
     return kv.second.file == file;
   });
@@ -162,6 +166,11 @@ bool Directory::Handle::insertMove(const std::string& name,
     it->second = entry;
   }
   file->locked().setParent(getDir());
+
+  auto now = time(NULL);
+  oldParent->locked().setMTime(now);
+  setMTime(now);
+
   return true;
 }
 
@@ -180,6 +189,7 @@ bool Directory::Handle::removeChild(const std::string& name) {
     entry->second.file->locked().setParent(nullptr);
     dcache.erase(entry);
   }
+  setMTime(time(NULL));
   return true;
 }
 

system/lib/wasmfs/file.h

@@ -93,17 +93,20 @@ class File : public std::enable_shared_from_this<File> {
 
 protected:
   File(FileKind kind, mode_t mode, backend_t backend)
-    : kind(kind), mode(mode), backend(backend) {}
+    : kind(kind), mode(mode), backend(backend) {
+    atime = mtime = ctime = time(NULL);
+  }
+
   // A mutex is needed for multiple accesses to the same file.
   std::recursive_mutex mutex;
 
   virtual size_t getSize() = 0;
 
   mode_t mode = 0; // User and group mode bits for access permission.
 
-  time_t ctime = 0; // Time when the file node was last modified.
-  time_t mtime = 0; // Time when the file content was last modified.
   time_t atime = 0; // Time when the content was last accessed.
+  time_t mtime = 0; // Time when the file content was last modified.
+  time_t ctime = 0; // Time when the file node was last modified.
 
   // Reference to parent of current file node. This can be used to
   // traverse up the directory tree. A weak_ptr ensures that the ref
@@ -233,7 +236,7 @@ class Symlink : public File {
   // Note that symlinks provide a mode of 0 to File. The mode of a symlink does
   // not matter, so that value will never be read (what matters is the mode of
   // the target).
-  Symlink(backend_t backend) : File(File::SymlinkKind, 0, backend) {}
+  Symlink(backend_t backend) : File(File::SymlinkKind, S_IFLNK, backend) {}
   virtual ~Symlink() = default;
 
   // Constant, and therefore thread-safe, and can be done without locking.

system/lib/wasmfs/special_files.cpp

@@ -17,6 +17,25 @@ namespace wasmfs::SpecialFiles {
 
 namespace {
 
+// No-op reads and writes: /dev/null
+class NullFile : public DataFile {
+  void open(oflags_t) override {}
+  void close() override {}
+
+  ssize_t write(const uint8_t* buf, size_t len, off_t offset) override {
+    return len;
+  }
+
+  ssize_t read(uint8_t* buf, size_t len, off_t offset) override { return 0; }
+
+  void flush() override {}
+  size_t getSize() override { return 0; }
+  void setSize(size_t size) override {}
+
+public:
+  NullFile() : DataFile(S_IRUGO | S_IWUGO, NullBackend, S_IFCHR) {}
+};
+
 class StdinFile : public DataFile {
   void open(oflags_t) override {}
   void close() override {}
@@ -141,6 +160,11 @@ class RandomFile : public DataFile {
 
 } // anonymous namespace
 
+std::shared_ptr<DataFile> getNull() {
+  static auto null = std::make_shared<NullFile>();
+  return null;
+}
+
 std::shared_ptr<DataFile> getStdin() {
   static auto stdin = std::make_shared<StdinFile>();
   return stdin;

system/lib/wasmfs/special_files.h

@@ -9,7 +9,10 @@
 
 namespace wasmfs::SpecialFiles {
 
-// /dev/stdin/
+// /dev/null
+std::shared_ptr<DataFile> getNull();
+
+// /dev/stdin
 std::shared_ptr<DataFile> getStdin();
 
 // /dev/stdout

system/lib/wasmfs/syscalls.cpp

@@ -347,7 +347,7 @@ int __syscall_fstatat64(int dirfd, intptr_t path, intptr_t buf, int flags) {
   buffer->st_uid = 0;
   buffer->st_gid = 0;
   // Device ID (if special file) No meaning right now for Emscripten.
-  buffer->st_rdev = 1;
+  buffer->st_rdev = 0;
   // The syscall docs state this is hardcoded to # of 512 byte blocks.
   buffer->st_blocks = (buffer->st_size + 511) / 512;
   // Specifies the preferred blocksize for efficient disk I/O.
@@ -438,6 +438,7 @@ static __wasi_fd_t doOpen(path::ParsedParent parsed,
       if (returnMode == OpenReturnMode::Nothing) {
         return 0;
       }
+
       auto openFile = std::make_shared<OpenFileState>(0, flags, created);
       return wasmFS.getFileTable().locked().addEntry(openFile);
     }
@@ -562,13 +563,6 @@ doMkdir(path::ParsedParent parsed, int mode, backend_t backend = NullBackend) {
 
   // TODO: Check that the insertion is successful.
 
-  // Update the times.
-  auto lockedFile = created->locked();
-  time_t now = time(NULL);
-  lockedFile.setATime(now);
-  lockedFile.setMTime(now);
-  lockedFile.setCTime(now);
-
   return 0;
 }
 

system/lib/wasmfs/wasmfs.cpp

@@ -79,6 +79,7 @@ std::shared_ptr<Directory> WasmFS::initRootDirectory() {
   assert(devDir);
   {
     auto lockedDev = devDir->locked();
+    lockedDev.mountChild("null", SpecialFiles::getNull());
     lockedDev.mountChild("stdin", SpecialFiles::getStdin());
     lockedDev.mountChild("stdout", SpecialFiles::getStdout());
     lockedDev.mountChild("stderr", SpecialFiles::getStderr());

tests/stat/test_stat.c

@@ -66,14 +66,20 @@ void test() {
   assert(s.st_ino);
   assert(S_ISDIR(s.st_mode));
   assert(s.st_nlink);
+#ifndef WASMFS
   assert(s.st_rdev == 0);
+#endif
   assert(s.st_size);
   assert(s.st_atime == 1200000000);
   assert(s.st_mtime == 1200000000);
   assert(s.st_ctime);
 #ifdef __EMSCRIPTEN__
   assert(s.st_blksize == 4096);
+#ifdef WASMFS
+  assert(s.st_blocks == 8);
+#else
   assert(s.st_blocks == 1);
+#endif
 #endif
 
   // stat a file
@@ -121,8 +127,11 @@ void test() {
   assert(S_ISCHR(s.st_mode));
   assert(s.st_nlink);
 #ifndef __APPLE__
+#ifndef WASMFS
   // mac uses makedev(3, 2) for /dev/null
+  // WasmFS doesn't report a meaningful st_rdev.
   assert(s.st_rdev == makedev(1, 3));
+#endif
 #endif
   assert(!s.st_size);
   assert(s.st_atime);
@@ -133,6 +142,8 @@ void test() {
   assert(s.st_blocks == 0);
 #endif
 
+  // WasmFS does not follow symlinks yet.
+#ifndef WASMFS
   // stat a link (should match the file stat from above)
   memset(&s, 0, sizeof(s));
   err = stat("folder/file-link", &s);
@@ -149,6 +160,7 @@ void test() {
 #ifdef __EMSCRIPTEN__
   assert(s.st_blksize == 4096);
   assert(s.st_blocks == 1);
+#endif
 #endif
 
   // lstat a link (should NOT match the file stat from above)

tests/wasmfs/wasmfs_getdents.out

@@ -24,6 +24,10 @@ d.d_name = ..
 d.d_reclen = 280
 d.d_type = directory
 
+d.d_name = null
+d.d_reclen = 280
+d.d_type = regular
+
 d.d_name = random
 d.d_reclen = 280
 d.d_type = regular

tests/wasmfs/wasmfs_stat.c

@@ -38,7 +38,9 @@ int main() {
   assert(file.st_nlink);
   assert(file.st_uid == 0);
   assert(file.st_gid == 0);
-  assert(file.st_rdev);
+#ifdef WASMFS
+  assert(file.st_rdev == 0);
+#endif
   assert(file.st_blocks == 0);
   assert(file.st_blksize == 4096);
 
@@ -67,12 +69,12 @@ int main() {
   assert(directory.st_nlink);
   assert(directory.st_uid == 0);
   assert(directory.st_gid == 0);
+  assert(directory.st_rdev == 0);
 #ifdef WASMFS
-  assert(directory.st_rdev);
   // blkcnt_t  st_blocks;      /* Number of 512B blocks allocated */
   assert(directory.st_blocks == 8);
 #else
-  assert(!directory.st_rdev);
+  assert(directory.st_rdev == 0);
   // The JS file system calculates st_blocks using Math.ceil(attr.size /
   // attr.blksize);
   assert(directory.st_blocks == 1);
@@ -100,7 +102,9 @@ int main() {
   assert(statFile.st_nlink);
   assert(statFile.st_uid == 0);
   assert(statFile.st_gid == 0);
-  assert(statFile.st_rdev);
+#ifdef WASMFS
+  assert(statFile.st_rdev == 0);
+#endif
   assert(statFile.st_blocks == 0);
   assert(statFile.st_blksize == 4096);
 
@@ -114,12 +118,11 @@ int main() {
   assert(statDirectory.st_nlink);
   assert(statDirectory.st_uid == 0);
   assert(statDirectory.st_gid == 0);
+  assert(statDirectory.st_rdev == 0);
 #ifdef WASMFS
-  assert(statDirectory.st_rdev);
   // blkcnt_t  st_blocks;      /* Number of 512B blocks allocated */
   assert(statDirectory.st_blocks == 8);
 #else
-  assert(!statDirectory.st_rdev);
   assert(statDirectory.st_blocks == 1);
 #endif
   assert(statDirectory.st_blksize == 4096);
@@ -150,16 +153,15 @@ int main() {
   assert(lstatFile.st_uid == 0);
   assert(lstatFile.st_gid == 0);
   assert(lstatFile.st_blksize == 4096);
+  assert(lstatFile.st_rdev == 0);
 #ifdef WASMFS
   assert(lstatFile.st_size == 0);
   assert(lstatFile.st_blocks == 0);
-  assert(lstatFile.st_rdev);
 #else
   // dev/stdout is a symlink to dev/tty.
   // TODO: When symlinks are added, one should return stat info on the symlink.
   assert(lstatFile.st_size == 8);
   assert(lstatFile.st_blocks == 1);
-  assert(!lstatFile.st_rdev);
 #endif
 
   // Test calling lstat without opening a directory.
@@ -172,12 +174,11 @@ int main() {
   assert(lstatDirectory.st_nlink);
   assert(lstatDirectory.st_uid == 0);
   assert(lstatDirectory.st_gid == 0);
+  assert(lstatDirectory.st_rdev == 0);
 #ifdef WASMFS
-  assert(lstatDirectory.st_rdev);
   // blkcnt_t  st_blocks;      /* Number of 512B blocks allocated */
   assert(lstatDirectory.st_blocks == 8);
 #else
-  assert(!lstatDirectory.st_rdev);
   assert(lstatDirectory.st_blocks == 1);
 #endif
   assert(lstatDirectory.st_blksize == 4096);