Implement mmap and msync for NODERAWFS (#13052)

kleisauke · web-flow · commit 0320c041834e · 2021-01-06T16:51:43.000-08:00
(this commit fixes also a TypeError in $syscallMunmap,
which was hit by this test case)
diff --git a/src/library_memfs.js b/src/library_memfs.js
@@ -353,9 +353,10 @@ mergeInto(LibraryManager.library, {
         stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
       },
       mmap: function(stream, address, length, position, prot, flags) {
-        // We don't currently support location hints for the address of the mapping
-        assert(address === 0);
-
+        if (address !== 0) {
+          // We don't currently support location hints for the address of the mapping
+          throw new FS.ErrnoError({{{ cDefine('EINVAL') }}});
+        }
         if (!FS.isFile(stream.node.mode)) {
           throw new FS.ErrnoError({{{ cDefine('ENODEV') }}});
         }
diff --git a/src/library_nodefs.js b/src/library_nodefs.js
@@ -296,9 +296,10 @@ mergeInto(LibraryManager.library, {
         return position;
       },
       mmap: function(stream, address, length, position, prot, flags) {
-        // We don't currently support location hints for the address of the mapping
-        assert(address === 0);
-
+        if (address !== 0) {
+          // We don't currently support location hints for the address of the mapping
+          throw new FS.ErrnoError({{{ cDefine('EINVAL') }}});
+        }
         if (!FS.isFile(stream.node.mode)) {
           throw new FS.ErrnoError({{{ cDefine('ENODEV') }}});
         }
diff --git a/src/library_noderawfs.js b/src/library_noderawfs.js
@@ -5,7 +5,7 @@
  */
 
 mergeInto(LibraryManager.library, {
-  $NODERAWFS__deps: ['$ERRNO_CODES', '$FS', '$NODEFS'],
+  $NODERAWFS__deps: ['$ERRNO_CODES', '$FS', '$NODEFS', '$mmapAlloc'],
   $NODERAWFS__postset: 'if (ENVIRONMENT_IS_NODE) {' +
     'var _wrapNodeError = function(func) { return function() { try { return func.apply(this, arguments) } catch (e) { if (!e.code) throw e; throw new FS.ErrnoError(ERRNO_CODES[e.code]); } } };' +
     'var VFS = Object.assign({}, FS);' +
@@ -122,10 +122,31 @@ mergeInto(LibraryManager.library, {
     allocate: function() {
       throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
     },
-    mmap: function() {
-      throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+    mmap: function(stream, address, length, position, prot, flags) {
+      if (stream.stream_ops) {
+        // this stream is created by in-memory filesystem
+        return VFS.mmap(stream, address, length, position, prot, flags);
+      }
+      if (address !== 0) {
+        // We don't currently support location hints for the address of the mapping
+        throw new FS.ErrnoError({{{ cDefine('EINVAL') }}});
+      }
+
+      var ptr = mmapAlloc(length);
+      FS.read(stream, HEAP8, ptr, length, position);
+      return { ptr: ptr, allocated: true };
     },
-    msync: function() {
+    msync: function(stream, buffer, offset, length, mmapFlags) {
+      if (stream.stream_ops) {
+        // this stream is created by in-memory filesystem
+        return VFS.msync(stream, buffer, offset, length, mmapFlags);
+      }
+      if (mmapFlags & {{{ cDefine('MAP_PRIVATE') }}}) {
+        // MAP_PRIVATE calls need not to be synced back to underlying fs
+        return 0;
+      }
+
+      FS.write(stream, buffer, 0, length, offset);
       return 0;
     },
     munmap: function() {
diff --git a/src/library_syscall.js b/src/library_syscall.js
@@ -279,10 +279,12 @@ var SyscallsLibrary = {
     if (len === info.len) {
 #if FILESYSTEM && SYSCALLS_REQUIRE_FILESYSTEM
       var stream = FS.getStream(info.fd);
-      if (info.prot & {{{ cDefine('PROT_WRITE') }}}) {
-        SYSCALLS.doMsync(addr, stream, len, info.flags, info.offset);
+      if (stream) {
+        if (info.prot & {{{ cDefine('PROT_WRITE') }}}) {
+          SYSCALLS.doMsync(addr, stream, len, info.flags, info.offset);
+        }
+        FS.munmap(stream);
       }
-      FS.munmap(stream);
 #else
 #if ASSERTIONS
       // Without FS support, only anonymous mappings are supported.
diff --git a/tests/fs/test_mmap.c b/tests/fs/test_mmap.c
@@ -16,28 +16,28 @@
 #include <sys/stat.h>
 #include <unistd.h>
 #include <sys/io.h>
-#include <sys/mman.h>
+#include <errno.h>
 
 int main() {
   EM_ASM(
     FS.mkdir('yolo');
     #if NODEFS
         FS.mount(NODEFS, { root: '.' }, 'yolo');
     #endif
-    FS.writeFile('/yolo/in.txt', 'mmap ftw!');
+    FS.writeFile('yolo/in.txt', 'mmap ftw!');
   );
 
   // Use mmap to read in.txt
   {
-    const char* path = "/yolo/in.txt";
+    const char* path = "yolo/in.txt";
     int fd = open(path, O_RDONLY);
     assert(fd != -1);
 
     int filesize = 9;
     char* map = (char*)mmap(NULL, filesize, PROT_READ, MAP_PRIVATE, fd, 0);
     assert(map != MAP_FAILED);
 
-    printf("/yolo/in.txt content=");
+    printf("yolo/in.txt content=");
     for (int i = 0; i < filesize; i++) {
         printf("%c", map[i]);
     }
@@ -52,7 +52,7 @@ int main() {
   // Use mmap to write out.txt
   {
     const char* text = "written mmap";
-    const char* path = "/yolo/out.txt";
+    const char* path = "yolo/out.txt";
 
     int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
     assert(fd != -1);
@@ -78,15 +78,15 @@ int main() {
   }
 
   {
-    FILE* fd = fopen("/yolo/out.txt", "r");
+    FILE* fd = fopen("yolo/out.txt", "r");
     if (fd == NULL) {
-      printf("failed to open /yolo/out.txt\n");
+      printf("failed to open yolo/out.txt\n");
       return 1;
     }
     char buffer[15];
     memset(buffer, 0, 15);
     fread(buffer, 1, 14, fd);
-    printf("/yolo/out.txt content=%s\n", buffer);
+    printf("yolo/out.txt content=%s\n", buffer);
     fclose(fd);
   }
 
@@ -95,7 +95,7 @@ int main() {
   {
     const char* readonlytext = "readonly mmap\0";
     const char* text = "write mmap\0";
-    const char* path = "/yolo/outreadonly.txt";
+    const char* path = "yolo/outreadonly.txt";
     size_t readonlytextsize = strlen(readonlytext);
     size_t textsize = strlen(text);
 
@@ -117,22 +117,22 @@ int main() {
   }
 
   {
-    FILE* fd = fopen("/yolo/outreadonly.txt", "r");
+    FILE* fd = fopen("yolo/outreadonly.txt", "r");
     if (fd == NULL) {
-      printf("failed to open /yolo/outreadonly.txt\n");
+      printf("failed to open yolo/outreadonly.txt\n");
       return 1;
     }
     char buffer[16];
     memset(buffer, 0, 16);
     fread(buffer, 1, 15, fd);
-    printf("/yolo/outreadonly.txt content=%s\n", buffer);
+    printf("yolo/outreadonly.txt content=%s\n", buffer);
     fclose(fd);
   }
 
   // MAP_PRIVATE
   {
     const char* text = "written mmap";
-    const char* path = "/yolo/private.txt";
+    const char* path = "yolo/private.txt";
 
     int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
     assert(fd != -1);
@@ -158,22 +158,22 @@ int main() {
   }
 
   {
-    FILE* fd = fopen("/yolo/private.txt", "r");
+    FILE* fd = fopen("yolo/private.txt", "r");
     if (fd == NULL) {
-      printf("failed to open /yolo/private.txt\n");
+      printf("failed to open yolo/private.txt\n");
       return 1;
     }
     char buffer[15];
     memset(buffer, 0, 15);
     fread(buffer, 1, 14, fd);
-    printf("/yolo/private.txt content=%s\n", buffer);
+    printf("yolo/private.txt content=%s\n", buffer);
     fclose(fd);
   }
 
   // MAP_SHARED with offset
   {
     const char* text = "written shared mmap with offset";
-    const char* path = "/yolo/sharedoffset.txt";
+    const char* path = "yolo/sharedoffset.txt";
 
     int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
     assert(fd != -1);
@@ -206,10 +206,31 @@ int main() {
     close(fd);
   }
 
+  // mmap with a address will fail
+  {
+    const char* path = "yolo/private.txt";
+
+    int fd = open(path, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
+    assert(fd != -1);
+
+    size_t map_size = 1 << 16;
+
+    // Reserve some address space in which to perform the experiment
+    char *alloc = (char*)mmap(NULL, map_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    assert(alloc != MAP_FAILED);
+
+    char *addr = (char*)mmap((void*)alloc, map_size, PROT_READ, MAP_PRIVATE | MAP_FIXED, fd, 0);
+    assert(addr == MAP_FAILED && errno == EINVAL); // Emscripten
+    //assert(addr == alloc); // Native environments
+
+    assert(munmap(alloc, map_size) != -1);
+    close(fd);
+  }
+
   {
-    FILE* fd = fopen("/yolo/sharedoffset.txt", "r");
+    FILE* fd = fopen("yolo/sharedoffset.txt", "r");
     if (fd == NULL) {
-      printf("failed to open /yolo/sharedoffset.txt\n");
+      printf("failed to open yolo/sharedoffset.txt\n");
       return 1;
     }
     size_t offset = sysconf(_SC_PAGE_SIZE) * 2;
@@ -218,11 +239,11 @@ int main() {
     memset(buffer, 0, offset + 33);
     fread(buffer, 1, offset + 32, fd);
     // expect text written from mmap operation to appear at offset in the file
-    printf("/yolo/sharedoffset.txt content=%s %zu\n", buffer + offset, offset);
+    printf("yolo/sharedoffset.txt content=%s %zu\n", buffer + offset, offset);
     fclose(fd);
   }
 
-#if !defined(NODEFS)
+#if !defined(NODEFS) && !defined(NODERAWFS)
   /**
    * MMAP to an 'over-allocated' file
    * 
@@ -233,7 +254,7 @@ int main() {
    * is not written beyond the allocated memory area for the mmap operation.
    */
   {
-    int fd = open("/yolo/overallocatedfile.txt", O_RDWR | O_CREAT, (mode_t)0600);
+    int fd = open("yolo/overallocatedfile.txt", O_RDWR | O_CREAT, (mode_t)0600);
     assert(fd != -1);
 
     const size_t textsize = 33;
@@ -244,13 +265,13 @@ int main() {
     }
 
     EM_ASM_({
-        const stream = FS.streams.find(stream => stream.path.indexOf('/yolo/overallocatedfile.txt')>=0);
+        const stream = FS.streams.find(stream => stream.path.indexOf('yolo/overallocatedfile.txt') >= 0);
         assert(stream.node.usedBytes === $0,
-          'Used bytes on the over-allocated file (' + stream.node.usedBytes+ ') ' +
+          'Used bytes on the over-allocated file (' + stream.node.usedBytes + ') ' +
           'should be 33'
         );
         assert(stream.node.contents.length > stream.node.usedBytes,
-          'Used bytes on the over-allocated file (' + stream.node.usedBytes+ ') ' +
+          'Used bytes on the over-allocated file (' + stream.node.usedBytes + ') ' +
           'should be less than the length of the content buffer (' + stream.node.contents.length + ')'
         );
         stream.node.contents[stream.node.usedBytes] = 98; // 'b', we don't want to see this in the mmap area
diff --git a/tests/fs/test_mmap.out b/tests/fs/test_mmap.out
@@ -1,5 +1,5 @@
-/yolo/in.txt content=mmap ftw!
-/yolo/out.txt content=written mmap
-/yolo/outreadonly.txt content=readonly mmap
-/yolo/private.txt content=
-/yolo/sharedoffset.txt content=written shared mmap with offset 32768
+yolo/in.txt content=mmap ftw!
+yolo/out.txt content=written mmap
+yolo/outreadonly.txt content=readonly mmap
+yolo/private.txt content=
+yolo/sharedoffset.txt content=written shared mmap with offset 32768
diff --git a/tests/test_core.py b/tests/test_core.py
@@ -5132,10 +5132,12 @@ def test_fs_append(self):
   def test_fs_mmap(self):
     self.uses_es6 = True
     orig_compiler_opts = self.emcc_args[:]
-    for fs in ['MEMFS', 'NODEFS']:
+    for fs in ['MEMFS', 'NODEFS', 'NODERAWFS']:
       self.emcc_args = orig_compiler_opts + ['-D' + fs]
       if fs == 'NODEFS':
         self.emcc_args += ['-lnodefs.js']
+      if fs == 'NODERAWFS':
+        self.emcc_args += ['-lnodefs.js', '-lnoderawfs.js']
       self.do_run_in_out_file_test('tests', 'fs', 'test_mmap.c')
 
   @also_with_noderawfs
