Always virtualize file descriptors when using NODERAWFS (#19528)

At least for the `dup*()` syscalls, virtualizing the file
descriptors is necessary due to the absence of an API for these
functions in Node.js.

This commit ensures that a virtualized file descriptor is always
returned, even for the `open()` system call and similar functions.

While doing that, it revealed a few regressions in the NODERAWFS
implementation of `fchmod()`, `fchown()` and `ftruncate()` as they
were not remapping virtualized file descriptors to their native
counterparts.

Author: kleisauke

src/library_noderawfs.js

@@ -69,16 +69,32 @@ mergeInto(LibraryManager.library, {
     stat: function() { return fs.statSync.apply(void 0, arguments); },
     lstat: function() { return fs.lstatSync.apply(void 0, arguments); },
     chmod: function() { fs.chmodSync.apply(void 0, arguments); },
-    fchmod: function() { fs.fchmodSync.apply(void 0, arguments); },
+    fchmod: function(fd, mode) {
+      var stream = FS.getStream(fd);
+      if (!stream) {
+        throw new FS.ErrnoError({{{ cDefs.EBADF }}});
+      }
+      fs.fchmodSync(stream.nfd, mode);
+    },
     chown: function() { fs.chownSync.apply(void 0, arguments); },
-    fchown: function() { fs.fchownSync.apply(void 0, arguments); },
+    fchown: function(fd, owner, group) {
+      var stream = FS.getStream(fd);
+      if (!stream) {
+        throw new FS.ErrnoError({{{ cDefs.EBADF }}});
+      }
+      fs.fchownSync(stream.nfd, owner, group);
+    },
     truncate: function() { fs.truncateSync.apply(void 0, arguments); },
     ftruncate: function(fd, len) {
       // See https://github.com/nodejs/node/issues/35632
       if (len < 0) {
         throw new FS.ErrnoError({{{ cDefs.EINVAL }}});
       }
-      fs.ftruncateSync.apply(void 0, arguments);
+      var stream = FS.getStream(fd);
+      if (!stream) {
+        throw new FS.ErrnoError({{{ cDefs.EBADF }}});
+      }
+      fs.ftruncateSync(stream.nfd, len);
     },
     utime: function(path, atime, mtime) { fs.utimesSync(path, atime/1000, mtime/1000); },
     open: function(path, flags, mode) {
@@ -94,7 +110,7 @@ mergeInto(LibraryManager.library, {
       }
       var newMode = NODEFS.getMode(pathTruncated);
       var node = { id: st.ino, mode: newMode, node_ops: NODERAWFS, path: path }
-      return FS.createStream({ nfd: nfd, position: 0, path: path, flags: flags, node: node, seekable: true }, nfd);
+      return FS.createStream({ nfd: nfd, position: 0, path: path, flags: flags, node: node, seekable: true });
     },
     createStream: function(stream, fd) {
       // Call the original FS.createStream
@@ -106,16 +122,11 @@ mergeInto(LibraryManager.library, {
       }
       return rtn;
     },
-    closeStream: function(fd) {
-      if (FS.streams[fd]) {
-        FS.streams[fd].shared.refcnt--;
-      }
-      VFS.closeStream(fd);
-    },
     close: function(stream) {
-      FS.closeStream(stream.fd);
-      if (!stream.stream_ops && stream.shared.refcnt === 0) {
-        // this stream is created by in-memory filesystem        
+      VFS.closeStream(stream.fd);
+      if (!stream.stream_ops && --stream.shared.refcnt === 0) {
+        // This stream is created by our Node.js filesystem, close the
+        // native file descriptor when its reference count drops to 0.
         fs.closeSync(stream.nfd);
       }
     },

test/unistd/dup.c

@@ -64,13 +64,26 @@ int main() {
   assert(strcmp(buf, "abc") == 0);
   printf("\n");
 
-  printf("DUP2 shared seek position\n");
-  int fd1 = open("./blah.txt", O_RDWR | O_CREAT | O_EXCL, 0600);
-  int fd2 = dup(fd1);
-  int n = write(fd1, "abcabc\n", 7);
-  assert(n == 7);
-  assert(lseek(fd1, 0, SEEK_CUR) == 7);
-  assert(lseek(fd2, 0, SEEK_CUR) == 7);
+  printf("DUP shared seek position\n");
+  f = open("./blah.txt", O_RDWR | O_CREAT | O_EXCL, 0600);
+  f2 = dup(f);
+  rtn = write(f2, "abcabc\n", 7);
+  assert(rtn == 7);
+  assert(lseek(f, 0, SEEK_CUR) == 7);
+  assert(lseek(f2, 0, SEEK_CUR) == 7);
+  printf("close(f): %d\n", close(f));
+  printf("close(f2): %d\n", close(f2));
+  printf("\n");
+
+  printf("DUP truncate\n");
+  f = open("./blah.txt", O_RDWR, 0600);
+  f2 = dup(f);
+  rtn = ftruncate(f2, 0);
+  assert(rtn == 0);
+  assert(lseek(f, 0, SEEK_END) == 0);
+  assert(lseek(f2, 0, SEEK_END) == 0);
+  printf("close(f): %d\n", close(f));
+  printf("close(f2): %d\n", close(f2));
 
   return 0;
 }

test/unistd/dup.out

@@ -22,4 +22,10 @@ close(f): -1
 DUP2 pipe
 buf: abc
 
-DUP2 shared seek position
+DUP shared seek position
+close(f): 0
+close(f2): 0
+
+DUP truncate
+close(f): 0
+close(f2): 0