[WasmFS][NFC] Refactor special files (#16892)

Move the standard stream implementations from the streams.h header to a new
special_files.cpp file in preparation for adding addition special files like
/dev/random. Add a new special_files.h header that exposes only the functions to
get the singleton instances for each special file rather than the class
structure of their implementations. Simplify the implementation of StdoutFile
and StderrFile by moving their duplicated flush implementations into their
shared WritingStdFile parent.

Author: tlively

system/lib/wasmfs/file.h

@@ -122,6 +122,7 @@ class File : public std::enable_shared_from_this<File> {
 };
 
 class DataFile : public File {
+protected:
   // Notify the backend when this file is opened or closed. The backend is
   // responsible for keeping files accessible as long as they are open, even if
   // they are unlinked.
@@ -176,6 +177,7 @@ class Directory : public File {
   // TODO: Use a cache data structure with smaller code size.
   std::map<std::string, DCacheEntry> dcache;
 
+protected:
   // Return the `File` object corresponding to the file with the given name or
   // null if there is none.
   virtual std::shared_ptr<File> getChild(const std::string& name) = 0;

system/lib/wasmfs/file_table.cpp

@@ -7,17 +7,17 @@
 // See https://github.com/emscripten-core/emscripten/issues/15041.
 
 #include "file_table.h"
-#include "streams.h"
+#include "special_files.h"
 
 namespace wasmfs {
 
 FileTable::FileTable() {
   entries.push_back(
-    std::make_shared<OpenFileState>(0, O_RDONLY, StdinFile::getSingleton()));
+    std::make_shared<OpenFileState>(0, O_RDONLY, SpecialFiles::getStdin()));
   entries.push_back(
-    std::make_shared<OpenFileState>(0, O_WRONLY, StdoutFile::getSingleton()));
+    std::make_shared<OpenFileState>(0, O_WRONLY, SpecialFiles::getStdout()));
   entries.push_back(
-    std::make_shared<OpenFileState>(0, O_WRONLY, StderrFile::getSingleton()));
+    std::make_shared<OpenFileState>(0, O_WRONLY, SpecialFiles::getStderr()));
 }
 
 std::shared_ptr<OpenFileState> FileTable::Handle::getEntry(__wasi_fd_t fd) {

system/lib/wasmfs/special_files.cpp

@@ -0,0 +1,133 @@
+// Copyright 2021 The Emscripten Authors.  All rights reserved.
+// Emscripten is available under two separate licenses, the MIT license and the
+// University of Illinois/NCSA Open Source License.  Both these licenses can be
+// found in the LICENSE file.
+// This file defines the standard streams of the new file system.
+// Current Status: Work in Progress.
+// See https://github.com/emscripten-core/emscripten/issues/15041.
+
+#include <emscripten/html5.h>
+#include <vector>
+#include <wasi/api.h>
+
+#include "special_files.h"
+
+namespace wasmfs::SpecialFiles {
+
+namespace {
+
+class StdinFile : public DataFile {
+  void open(oflags_t) override {}
+  void close() override {}
+
+  __wasi_errno_t write(const uint8_t* buf, size_t len, off_t offset) override {
+    return __WASI_ERRNO_INVAL;
+  }
+
+  __wasi_errno_t read(uint8_t* buf, size_t len, off_t offset) override {
+    // TODO: Implement reading from stdin.
+    abort();
+  };
+
+  void flush() override {}
+  size_t getSize() override { return 0; }
+  void setSize(size_t size) override {}
+
+public:
+  StdinFile() : DataFile(S_IRUGO, NullBackend, S_IFCHR) { seekable = false; }
+};
+
+// A standard stream that writes: stdout or stderr.
+class WritingStdFile : public DataFile {
+protected:
+  std::vector<char> writeBuffer;
+
+  void open(oflags_t) override {}
+  void close() override {}
+
+  __wasi_errno_t read(uint8_t* buf, size_t len, off_t offset) override {
+    return __WASI_ERRNO_INVAL;
+  };
+
+  void flush() override {
+    // Write a null to flush the output if we have content.
+    if (!writeBuffer.empty()) {
+      const uint8_t nothing = '\0';
+      write(&nothing, 1, 0);
+    }
+  }
+
+  size_t getSize() override { return 0; }
+  void setSize(size_t size) override {}
+
+  __wasi_errno_t writeToJS(const uint8_t* buf,
+                           size_t len,
+                           void (*console_write)(const char*),
+                           std::vector<char>& fd_write_buffer) {
+    for (size_t j = 0; j < len; j++) {
+      uint8_t current = buf[j];
+      // Flush on either a null or a newline.
+      if (current == '\0' || current == '\n') {
+        fd_write_buffer.push_back('\0'); // for null-terminated C strings
+        console_write(fd_write_buffer.data());
+        fd_write_buffer.clear();
+      } else {
+        fd_write_buffer.push_back(current);
+      }
+    }
+    return __WASI_ERRNO_SUCCESS;
+  }
+
+public:
+  WritingStdFile() : DataFile(S_IWUGO, NullBackend, S_IFCHR) {
+    seekable = false;
+  }
+};
+
+class StdoutFile : public WritingStdFile {
+  __wasi_errno_t write(const uint8_t* buf, size_t len, off_t offset) override {
+    // Node and worker threads issue in Emscripten:
+    // https://github.com/emscripten-core/emscripten/issues/14804.
+    // Issue filed in Node: https://github.com/nodejs/node/issues/40961
+    // This is confirmed to occur when running with EXIT_RUNTIME and
+    // PROXY_TO_PTHREAD. This results in only a single console.log statement
+    // being outputted. The solution for now is to use out() and err() instead.
+    return writeToJS(buf, len, &_emscripten_out, writeBuffer);
+  }
+
+public:
+  StdoutFile() {}
+};
+
+class StderrFile : public WritingStdFile {
+  __wasi_errno_t write(const uint8_t* buf, size_t len, off_t offset) override {
+    // Similar issue with Node and worker threads as emscripten_out.
+    // TODO: May not want to proxy stderr (fd == 2) to the main thread, as
+    //       emscripten_err does.
+    //       This will not show in HTML - a console.warn in a worker is
+    //       sufficient. This would be a change from the current FS.
+    return writeToJS(buf, len, &_emscripten_err, writeBuffer);
+  }
+
+public:
+  StderrFile() {}
+};
+
+} // anonymous namespace
+
+std::shared_ptr<DataFile> getStdin() {
+  static auto stdin = std::make_shared<StdinFile>();
+  return stdin;
+}
+
+std::shared_ptr<DataFile> getStdout() {
+  static auto stdout = std::make_shared<StdoutFile>();
+  return stdout;
+}
+
+std::shared_ptr<DataFile> getStderr() {
+  static auto stderr = std::make_shared<StderrFile>();
+  return stderr;
+}
+
+} // namespace wasmfs::SpecialFiles

system/lib/wasmfs/special_files.h

@@ -0,0 +1,21 @@
+// Copyright 2022 The Emscripten Authors.  All rights reserved.
+// Emscripten is available under two separate licenses, the MIT license and the
+// University of Illinois/NCSA Open Source License.  Both these licenses can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include "file.h"
+
+namespace wasmfs::SpecialFiles {
+
+// /dev/stdin/
+std::shared_ptr<DataFile> getStdin();
+
+// /dev/stdout
+std::shared_ptr<DataFile> getStdout();
+
+// /dev/stderr
+std::shared_ptr<DataFile> getStderr();
+
+} // namespace wasmfs::SpecialFiles

system/lib/wasmfs/streams.cpp

@@ -27,7 +27,7 @@
 #include "file_table.h"
 #include "paths.h"
 #include "pipe_backend.h"
-#include "streams.h"
+#include "special_files.h"
 #include "wasmfs.h"
 
 // File permission macros for wasmfs.
@@ -1150,9 +1150,8 @@ int __syscall_ftruncate64(int fd, uint64_t size) {
 static bool isTTY(std::shared_ptr<File>& file) {
   // TODO: Full TTY support. For now, just see stdin/out/err as terminals and
   //       nothing else.
-  return file == StdinFile::getSingleton() ||
-         file == StdoutFile::getSingleton() ||
-         file == StderrFile::getSingleton();
+  return file == SpecialFiles::getStdin() ||
+         file == SpecialFiles::getStdout() || file == SpecialFiles::getStderr();
 }
 
 int __syscall_ioctl(int fd, int request, ...) {