WasmFS: Implement FS.cwd (#19452)

This both adds JS API support for it, and internal support in JS libraries that use it
via PATH_FS, such as SDL1.

Also switch the JS API methods to hold on to their allocations rather than return
them to JS and expect JS to call free. This may use more memory in some cases,
but in others will be more efficient, and it is simpler.

Author: kripken

emcc.py

@@ -2334,6 +2334,7 @@ def phase_linker_setup(options, state, newargs):
         '_wasmfs_readdir_start',
         '_wasmfs_readdir_get',
         '_wasmfs_readdir_finish',
+        '_wasmfs_get_cwd',
       ]
 
   if settings.FETCH and final_suffix in EXECUTABLE_ENDINGS:

src/library_path.js

@@ -82,7 +82,15 @@ mergeInto(LibraryManager.library, {
   },
   // The FS-using parts are split out into a separate object, so simple path
   // usage does not require the FS.
-  $PATH_FS__deps: ['$PATH', '$FS'],
+  $PATH_FS__deps: [
+    '$PATH',
+    '$FS',
+#if WASMFS
+    // In WasmFS, FS.cwd() is implemented via a call into wasm, so we need to
+    // add a dependency on that.
+    '_wasmfs_get_cwd',
+#endif
+  ],
   $PATH_FS: {
     resolve: function() {
       var resolvedPath = '',

src/library_wasmfs.js

@@ -26,6 +26,7 @@ FS.createPreloadedFile = FS_createPreloadedFile;
 #if FORCE_FILESYSTEM
     '$FS_modeStringToFlags',
     'malloc',
+    'free',
 #endif
   ],
   $FS : {
@@ -90,18 +91,15 @@ FS.createPreloadedFile = FS_createPreloadedFile;
         ret = UTF8ArrayToString(ret, 0);
       }
 
-      _free(buf);
       return ret;
     },
-    cwd: () => {
-      // TODO: Remove dependency on FS.cwd().
-      // 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
+
+    cwd: () => {
+      return UTF8ToString(__wasmfs_get_cwd());
+    },
     mkdir: (path, mode) => {
       return withStackSave(() => {
         mode = mode !== undefined ? mode : 511 /* 0777 */;

system/lib/wasmfs/js_api.cpp

@@ -11,6 +11,13 @@
 #include "file.h"
 #include "paths.h"
 
+// Some APIs return data using a thread-local allocation that is never freed.
+// This is simpler and more efficient as it avoids the JS caller needing to free
+// the allocation (which would have both the overhead of free, and also of a
+// call back into wasm), but on the other hand it does mean more memory may be
+// used. This seems a reasonable tradeoff as heavy workloads should ideally
+// avoid the JS API anyhow.
+
 using namespace wasmfs;
 
 extern "C" {
@@ -20,7 +27,6 @@ __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) {
   static_assert(sizeof(off_t) == 8, "File offset type must be 64-bit");
 
@@ -36,7 +42,11 @@ void* _wasmfs_read_file(char* path) {
   // 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));
+
+  static thread_local void* buffer = nullptr;
+  buffer = realloc(buffer, size + sizeof(size));
+
+  auto* result = (uint8_t*)buffer;
   *(off_t*)result = size;
 
   int fd = open(path, O_RDONLY);
@@ -246,4 +256,11 @@ void _wasmfs_readdir_finish(struct wasmfs_readdir_state* state) {
   free(state);
 }
 
+char* _wasmfs_get_cwd(void) {
+  // TODO: PATH_MAX is 4K atm, so it might be good to reduce this somehow.
+  static thread_local void* path = nullptr;
+  path = realloc(path, PATH_MAX);
+  return getcwd((char*)path, PATH_MAX);
+}
+
 } // extern "C"

test/browser/test_sdl_image.c

@@ -14,6 +14,8 @@
 #include <stdlib.h>
 
 int testImage(SDL_Surface* screen, const char* fileName) {
+  printf("testImage: %s\n", fileName);
+
   SDL_Surface *image = IMG_Load(fileName);
   if (!image)
   {

test/other/metadce/test_metadce_cxx_wasmfs.size

@@ -1 +1 @@
-163957
+163973

test/test_browser.py

@@ -749,6 +749,7 @@ def test_sdl_surface_lock_opts(self):
     # Test Emscripten-specific extensions to optimize SDL_LockSurface and SDL_UnlockSurface.
     self.btest('hello_world_sdl.cpp', reference='htmltest.png', args=['-DTEST_SDL_LOCK_OPTS', '-lSDL', '-lGL'])
 
+  @also_with_wasmfs
   def test_sdl_image(self):
     # load an image file, get pixel data. Also O2 coverage for --preload-file, and memory-init
     shutil.copyfile(test_file('screenshot.jpg'), 'screenshot.jpg')
@@ -761,7 +762,6 @@ def test_sdl_image(self):
           '-O2', '-lSDL', '-lGL',
           '--preload-file', dest, '-DSCREENSHOT_DIRNAME="' + dirname + '"', '-DSCREENSHOT_BASENAME="' + basename + '"', '--use-preload-plugins'
         ])
-      return
 
   @also_with_wasmfs
   def test_sdl_image_jpeg(self):
@@ -3722,6 +3722,7 @@ def test_dynamic_link_many(self):
     self.run_process([EMCC, 'side2.c', '-sSIDE_MODULE', '-o', 'side2.wasm'])
     self.btest_exit(self.in_dir('main.c'), args=['-sMAIN_MODULE=2', 'side1.wasm', 'side2.wasm'])
 
+  @requires_threads
   def test_dynamic_link_pthread_many(self):
     # Test asynchronously loading two side modules during startup
     # They should always load in the same order

test/test_core.py

@@ -5680,6 +5680,7 @@ def test_getdents64_special_cases(self):
   def test_getcwd_with_non_ascii_name(self):
     self.do_run_in_out_file_test('fs/test_getcwd_with_non_ascii_name.cpp')
 
+  @no_wasmfs('no support for /proc/self/fd/, see https://github.com/emscripten-core/emscripten/issues/19430')
   def test_proc_self_fd(self):
     self.do_run_in_out_file_test('fs/test_proc_self_fd.c')