[WasmFS] Begin JS API integration (#16068)

This adds a few initial JS API functions. These will be enough to enable a test
in 2-3 PRs, and so no new test is added here.

The policy for this API is the same as the old FS: By default WasmFS includes
the JS API parts that it itself needs, and nothing more. If the user provides
FORCE_FILESYSTEM then the entire JS API is included. (As WasmFS uses
less JS, this flag may end up used more in practice, I'm not sure. But I thought
it best not to add a new flag here and keep the existing convention.)

Also rename the existing read_file JS API support function for consistency,
and move it to the new location. No changes to the function's contents.

Author: kripken

emcc.py

@@ -1875,7 +1875,17 @@ def default_setting(name, new_default):
     settings.FILESYSTEM = 0
     settings.SYSCALLS_REQUIRE_FILESYSTEM = 0
     settings.JS_LIBRARIES.append((0, 'library_wasmfs.js'))
-    settings.REQUIRED_EXPORTS += ['emscripten_wasmfs_read_file']
+    settings.REQUIRED_EXPORTS += ['_wasmfs_read_file']
+    if settings.FORCE_FILESYSTEM:
+      # Add exports for the JS API. Like the old JS FS, WasmFS by default
+      # includes just what JS parts it actually needs, and FORCE_FILESYSTEM is
+      # required to force all of it to be included if the user wants to use the
+      # JS API directly.
+      settings.REQUIRED_EXPORTS += [
+        '_wasmfs_write_file',
+        '_wasmfs_mkdir',
+        '_wasmfs_chdir',
+      ]
 
   # Explicitly drop linking in a malloc implementation if program is not using any dynamic allocation calls.
   if not settings.USES_DYNAMIC_ALLOC:

src/library_wasmfs.js

@@ -66,7 +66,7 @@ var WasmfsLibrary = {
       var pathName = allocateUTF8(path);
 
       // Copy the file into a JS buffer on the heap.
-      var buf = _emscripten_wasmfs_read_file(pathName);
+      var buf = __wasmfs_read_file(pathName);
       // The integer length is returned in the first 8 bytes of the buffer.
       var length = {{{ makeGetValue('buf', '0', 'i64') }}};
 
@@ -86,7 +86,25 @@ var WasmfsLibrary = {
       // User code should not be using FS.cwd().
       // For file preloading, cwd should be '/' to begin with.
       return '/';
-    }
+    },
+
+#if FORCE_FILESYSTEM
+    // Full JS API support
+    mkdir: function(path) {
+      var buffer = allocateUTF8OnStack(path);
+      __wasmfs_mkdir(buffer);
+    },
+    chdir: function(path) {
+      var buffer = allocateUTF8OnStack(path);
+      return __wasmfs_chdir(buffer);
+    },
+    writeFile: function(path, data) {
+      var pathBuffer = allocateUTF8OnStack(path);
+      var dataBuffer = allocate(data);
+      __wasmfs_write_file(pathBuffer, dataBuffer, data.length);
+      _free(dataBuffer);
+    },
+#endif
   },
   _wasmfs_get_num_preloaded_files__deps: ['$wasmFS$preloadedFiles'],
   _wasmfs_get_num_preloaded_files: function() {

system/lib/wasmfs/js_api.cpp

@@ -0,0 +1,91 @@
+// 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.
+
+#include <syscall_arch.h>
+#include <unistd.h>
+
+#include "file.h"
+
+using namespace wasmfs;
+
+extern "C" {
+
+__wasi_fd_t wasmfs_create_file(char* pathname, mode_t mode, backend_t backend);
+
+// Copy the file specified by the pathname into JS.
+// Return a pointer to the JS buffer in HEAPU8.
+// The buffer will also contain the file length.
+// Caller must free the returned pointer.
+void* _wasmfs_read_file(char* path) {
+  struct stat file;
+  int err = 0;
+  err = stat(path, &file);
+  if (err < 0) {
+    emscripten_console_error("Fatal error in FS.readFile");
+    abort();
+  }
+
+  // The function will return a pointer to a buffer with the file length in the
+  // first 8 bytes. The remaining bytes will contain the buffer contents. This
+  // allows the caller to use HEAPU8.subarray(buf + 8, buf + 8 + length).
+  off_t size = file.st_size;
+  uint8_t* result = (uint8_t*)malloc((size + sizeof(size)));
+  *(uint32_t*)result = size;
+
+  int fd = open(path, O_RDONLY);
+  if (fd < 0) {
+    emscripten_console_error("Fatal error in FS.readFile");
+    abort();
+  }
+  int numRead = pread(fd, result + sizeof(size), size, 0);
+  // TODO: Generalize this so that it is thread-proof.
+  // Must guarantee that the file size has not changed by the time it is read.
+  assert(numRead == size);
+  err = close(fd);
+  if (err < 0) {
+    emscripten_console_error("Fatal error in FS.readFile");
+    abort();
+  }
+
+  return result;
+}
+
+// Writes to a file, possibly creating it, and returns the number of bytes
+// written successfully.
+long _wasmfs_write_file(char* pathname, char* data, size_t data_size) {
+  auto pathParts = splitPath(pathname);
+
+  long err;
+  auto parsedPath = getParsedPath(pathParts, err);
+  if (!parsedPath.parent) {
+    return 0;
+  }
+
+  if (!parsedPath.child) {
+    // Create a file here.
+    wasmfs_create_file(
+      pathname, O_WRONLY, parsedPath.parent->getParent()->getBackend());
+  } else if (!parsedPath.child->is<DataFile>()) {
+    // There is something here but it isn't a data file.
+    return 0;
+  }
+
+  auto child = parsedPath.parent->getEntry(pathParts.back());
+  auto dataFile = child->dynCast<DataFile>();
+
+  auto result = dataFile->locked().write((uint8_t*)data, data_size, 0);
+  if (result != __WASI_ERRNO_SUCCESS) {
+    return 0;
+  }
+  return data_size;
+}
+
+long _wasmfs_mkdir(char* path, long mode) {
+  return __syscall_mkdir((long)path, mode);
+}
+
+long _wasmfs_chdir(char* path) { return __syscall_chdir((long)path); }
+
+}

system/lib/wasmfs/syscalls.cpp

@@ -34,44 +34,6 @@ extern "C" {
 
 using namespace wasmfs;
 
-// Copy the file specified by the pathname into JS.
-// Return a pointer to the JS buffer in HEAPU8.
-// The buffer will also contain the file length.
-// Caller must free the returned pointer.
-void* emscripten_wasmfs_read_file(char* path) {
-  struct stat file;
-  int err = 0;
-  err = stat(path, &file);
-  if (err < 0) {
-    emscripten_console_error("Fatal error in FS.readFile");
-    abort();
-  }
-
-  // The function will return a pointer to a buffer with the file length in the
-  // first 8 bytes. The remaining bytes will contain the buffer contents. This
-  // allows the caller to use HEAPU8.subarray(buf + 8, buf + 8 + length).
-  off_t size = file.st_size;
-  uint8_t* result = (uint8_t*)malloc((size + sizeof(size)));
-  *(uint32_t*)result = size;
-
-  int fd = open(path, O_RDONLY);
-  if (fd < 0) {
-    emscripten_console_error("Fatal error in FS.readFile");
-    abort();
-  }
-  int numRead = pread(fd, result + sizeof(size), size, 0);
-  // TODO: Generalize this so that it is thread-proof.
-  // Must guarantee that the file size has not changed by the time it is read.
-  assert(numRead == size);
-  err = close(fd);
-  if (err < 0) {
-    emscripten_console_error("Fatal error in FS.readFile");
-    abort();
-  }
-
-  return result;
-}
-
 long __syscall_dup3(long oldfd, long newfd, long flags) {
   auto fileTable = wasmFS.getLockedFileTable();
 
@@ -926,4 +888,5 @@ long __syscall_rename(long old_path, long new_path) {
 
   return 0;
 }
+
 }

tools/system_libs.py

@@ -1428,7 +1428,10 @@ class libwasmfs(MTLibrary, DebugLibrary, AsanInstrumentedLibrary):
   def get_files(self):
     return files_in_path(
         path='system/lib/wasmfs',
-        filenames=['syscalls.cpp', 'file_table.cpp', 'file.cpp', 'wasmfs.cpp', 'streams.cpp', 'memory_file.cpp', 'memory_file_backend.cpp', 'js_file_backend.cpp', 'proxied_file_backend.cpp'])
+        filenames=['syscalls.cpp', 'file_table.cpp', 'file.cpp', 'wasmfs.cpp',
+                   'streams.cpp', 'memory_file.cpp', 'memory_file_backend.cpp',
+                   'js_file_backend.cpp', 'proxied_file_backend.cpp',
+                   'js_api.cpp'])
 
   def can_use(self):
     return settings.WASMFS