init jsbackend

Author: ethanalee

src/library_wasmfs.js

@@ -2,7 +2,7 @@ var WasmfsLibrary = {
   $wasmFS$JSMemoryFiles : [],
   $wasmFS$preloadedFiles: [],
   $wasmFS$preloadedDirs: [],
-  $FS__deps: ['$wasmFS$preloadedFiles', '$wasmFS$preloadedDirs'],
+  $FS__deps: ['$wasmFS$preloadedFiles', '$wasmFS$preloadedDirs', '$wasmFS$JSMemoryFiles'],
   $FS : {
     // TODO: Clean up the following functions - currently copied from library_fs.js directly.
     createPreloadedFile: function(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) {

system/include/emscripten/wasmfs.h

@@ -0,0 +1,30 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <sys/stat.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct Backend* backend_t;
+
+// Creates a JSFile Backend in the new file system.
+backend_t createJSFileBackend();
+
+// Creates a new file in the new file system under a specific backend.
+uint32_t wasmfs_create(char* pathname, mode_t mode, backend_t backend);
+
+// Creates a new directory in the new file system under a specific backend.
+long wasmfs_mkdir(char* path, long mode, backend_t backend);
+
+#ifdef __cplusplus
+}
+#endif

system/lib/wasmfs/js_file_backend.cpp

@@ -7,44 +7,46 @@
 // See https://github.com/emscripten-core/emscripten/issues/15041.
 
 #include "backend.h"
+#include "wasmfs.h"
 
 namespace wasmfs {
 
-using jsIndex_t = uint32_t;
+using js_index_t = uint32_t;
 
 // This class describes a file that lives in JS Memory
 class JSFile : public DataFile {
   // This index indicates the location of the JS File in $wasmFS$JSMemoryFiles.
-  jsIndex_t index;
+  js_index_t index;
 
   // JSFiles will write from a Wasm Memory buffer into a JS array defined in
   // $wasmFS$JSMemoryFiles.
   __wasi_errno_t write(const uint8_t* buf, size_t len, off_t offset) override {
     EM_ASM(
       {
-        var size = $wasmFS$JSMemoryFiles[$0].byteLength;
+        var size = wasmFS$JSMemoryFiles[$0].length;
         if ($2 >= size) {
           // Resize the current arraybuffer.
-          $wasmFS$JSMemoryFiles[$0] =
-            new Uint8Array(size).set($wasmFS$JSMemoryFiles[$0]);
+          var oldContents = wasmFS$JSMemoryFiles[$0];
+          wasmFS$JSMemoryFiles[$0] = new Uint8Array($2);
+          wasmFS$JSMemoryFiles[$0].set(oldContents.subarray(0, $2));
         }
-        $wasmFS$JSMemoryFiles[$0].set(HEAPU8.subarray($1, $2), $3);
+        wasmFS$JSMemoryFiles[$0].set(HEAPU8.subarray($1, $1 + $2), $3);
       },
-           index,
-           (int)buf,
-           (int)(buf + len),
-           (int)offset);
+      index,
+      buf,
+      len,
+      (size_t)offset);
 
     return __WASI_ERRNO_SUCCESS;
   }
 
   // JSFiles will read from JS Memory into a Wasm Memory buffer.
   __wasi_errno_t read(uint8_t* buf, size_t len, off_t offset) override {
     assert(offset + len - 1 < getSize());
-    EM_ASM({ HEAPU8.set($wasmFS$JSMemoryFiles[$0].subarray($1, $2), $3); },
+    EM_ASM({ HEAPU8.set(wasmFS$JSMemoryFiles[$0].subarray($1, $2), $3); },
            index,
-           (int)offset,
-           (int)offset + len,
+           (size_t)offset,
+           (size_t)offset + len,
            buf);
 
     return __WASI_ERRNO_SUCCESS;
@@ -53,18 +55,17 @@ class JSFile : public DataFile {
   // The size of the JS File is defined as the length of the JS array in
   // $wasmFS$JSMemoryFiles.
   size_t getSize() override {
-    return (size_t)EM_ASM_INT({ return $wasmFS$JSMemoryFiles[$0].length; },
+    return (size_t)EM_ASM_INT({ return wasmFS$JSMemoryFiles[$0].length; },
                               index);
   }
 
 public:
   JSFile(mode_t mode) : DataFile(mode) {
     // Add the new JS File to the $wasmFS$JSMemoryFiles array and assign the
     // array index.
-    index = (jsIndex_t)EM_ASM_INT({
-      var typedBuffer = new Uint8Array();
-      $wasmFS$JSMemoryFiles.push(typedBuffer);
-      return $wasmFS$JSMemoryFiles.length - 1;
+    index = (js_index_t)EM_ASM_INT({
+      wasmFS$JSMemoryFiles.push(new Uint8Array(0));
+      return wasmFS$JSMemoryFiles.length - 1;
     });
   }
 
@@ -86,12 +87,13 @@ class JSFileBackend : public Backend {
     return std::make_shared<JSFile>(mode);
   }
   std::shared_ptr<Directory> createDirectory(mode_t mode) override {
-    return std::make_shared<Directory>(mode, shared_from_this());
+    return std::make_shared<Directory>(mode, this);
   }
 };
 
-std::shared_ptr<Backend> createJSFileBackend() {
-  return std::make_unique<JSFileBackend>();
+extern "C" backend_t createJSFileBackend() {
+  wasmFS.backendTable.push_back(std::make_unique<JSFileBackend>());
+  return wasmFS.backendTable.back().get();
 }
 
-} // namespace wasmfs
+} // namespace wasmfs

system/lib/wasmfs/syscalls.cpp

@@ -371,7 +371,7 @@ long __syscall_fstat64(long fd, long buf) {
   return doStat(openFile.locked().getFile(), buffer);
 }
 
-__wasi_fd_t
+static __wasi_fd_t
 doOpen(char* pathname, long flags, mode_t mode, backend_t backend = nullptr) {
   int accessMode = (flags & O_ACCMODE);
   bool canWrite = false;
@@ -421,7 +421,13 @@ doOpen(char* pathname, long flags, mode_t mode, backend_t backend = nullptr) {
       // Mask all permissions sent via mode.
       mode &= S_IALLUGO;
       // Create an empty in-memory file.
-      auto backend = lockedParentDir.getBackend();
+
+      // By default, the backend that the file is created in is the same as the
+      // parent directory. However, if a backend is passed as a parameter, then
+      // that backend is used.
+      if (!backend) {
+        backend = lockedParentDir.getBackend();
+      }
       auto created = backend->createFile(mode);
 
       // TODO: When rename is implemented make sure that one can atomically
@@ -451,10 +457,10 @@ doOpen(char* pathname, long flags, mode_t mode, backend_t backend = nullptr) {
   return wasmFS.getLockedFileTable().add(openFile);
 }
 
-// This function allows users to create files associated with a specific
-// backend.
-__wasi_fd_t wasmfs_create(long pathname, mode_t mode, backend_t backend) {
-  return doOpen((char*)pathname, O_CREAT, mode, backend);
+// This function is exposed to users and allows them to specify a particular
+// backend that a file should be created within.
+__wasi_fd_t wasmfs_create(char* pathname, mode_t mode, backend_t backend) {
+  return doOpen(pathname, O_CREAT, mode, backend);
 }
 
 __wasi_fd_t __syscall_open(long pathname, long flags, ...) {
@@ -468,8 +474,8 @@ __wasi_fd_t __syscall_open(long pathname, long flags, ...) {
   return doOpen((char*)pathname, flags, mode);
 }
 
-long __syscall_mkdir(long path, long mode) {
-  auto pathParts = splitPath((char*)path);
+static long doMkdir(char* path, long mode, backend_t backend = nullptr) {
+  auto pathParts = splitPath(path);
 
   if (pathParts.empty()) {
     return -EINVAL;
@@ -502,14 +508,30 @@ long __syscall_mkdir(long path, long mode) {
     // https://www.gnu.org/software/libc/manual/html_node/Permission-Bits.html
     mode &= S_IRWXUGO | S_ISVTX;
     // Create an empty in-memory directory.
-    auto backend = lockedParentDir.getBackend();
+
+    // By default, the backend that the directory is created in is the same as
+    // the parent directory. However, if a backend is passed as a parameter,
+    // then that backend is used.
+    if (!backend) {
+      backend = lockedParentDir.getBackend();
+    }
     auto created = backend->createDirectory(mode);
 
     lockedParentDir.setEntry(base, created);
     return 0;
   }
 }
 
+// This function is exposed to users and allows users to specify a particular
+// backend that a directory should be created within.
+long wasmfs_mkdir(char* path, long mode, backend_t backend) {
+  return doMkdir(path, mode, backend);
+}
+
+long __syscall_mkdir(long path, long mode) {
+  return doMkdir((char*)path, mode);
+}
+
 __wasi_errno_t __wasi_fd_seek(__wasi_fd_t fd,
                               __wasi_filedelta_t offset,
                               __wasi_whence_t whence,

tests/wasmfs/wasmfs_jsfile.c

@@ -6,6 +6,8 @@
  */
 
 #include <assert.h>
+#include <emscripten/emscripten.h>
+#include <emscripten/wasmfs.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
@@ -17,13 +19,49 @@
 
 int main() {
 
-  // Create a JS Backend
   backend_t JSBackend = createJSFileBackend();
 
   // Create a new JS file under root.
   int fd = wasmfs_create("/testfile", 0777, JSBackend);
 
   // Try writing to and reading from the file.
+  errno = 0;
+  const char* msg = "Test with a new JS file\n";
+  write(fd, msg, strlen(msg));
+  assert(errno == 0);
+
+  EM_ASM({out(wasmFS$JSMemoryFiles[0])});
+
+  errno = 0;
+  lseek(fd, 0, SEEK_SET);
+  assert(errno == 0);
+  char buf[200] = {};
+  read(fd, buf, sizeof(buf));
+  assert(errno == 0);
+  printf("%s\n", buf);
+
+  close(fd);
+
+  //   Try creating a new JS directory under root.
+  int result = wasmfs_mkdir("/test-dir", 0777, JSBackend);
+
+  //   Try to create a new JS file under this new directory.
+  int fd2 = open("/test-dir/jsfile", O_RDWR | O_CREAT, 0777);
+
+  // Try writing to and reading from the file.
+  errno = 0;
+  const char* msg2 = "Test with a JS file created under a JS directory\n";
+  write(fd2, msg2, strlen(msg2));
+  assert(errno == 0);
+
+  EM_ASM({out(wasmFS$JSMemoryFiles[1])});
+
+  errno = 0;
+  lseek(fd2, 0, SEEK_SET);
+  assert(errno == 0);
+  read(fd2, buf, sizeof(buf));
+  assert(errno == 0);
+  printf("%s\n", buf);
 
   return 0;
-}
+}

tests/wasmfs/wasmfs_jsfile.out

@@ -1 +1,17 @@
-s
+Uint8Array(24) [
+   84, 101, 115, 116, 32, 119, 105,
+  116, 104,  32,  97, 32, 110, 101,
+  119,  32,  74,  83, 32, 102, 105,
+  108, 101,  10
+]
+Test with a new JS file
+
+Uint8Array(49) [
+   84, 101, 115, 116,  32, 119, 105, 116, 104,
+   32,  97,  32,  74,  83,  32, 102, 105, 108,
+  101,  32,  99, 114, 101,  97, 116, 101, 100,
+   32, 117, 110, 100, 101, 114,  32,  97,  32,
+   74,  83,  32, 100, 105, 114, 101,  99, 116,
+  111, 114, 121,  10
+]
+Test with a JS file created under a JS directory