Allow pipes to be stat'ed

src/library_fs.js

@@ -956,6 +956,16 @@ FS.staticInit();
       }
       return node.node_ops.getattr(node);
     },
+    fstat(fd) {
+      var stream = FS.getStreamChecked(fd);
+      var node = stream.node;
+      if (stream.stream_ops.getattr) {
+        return stream.stream_ops.getattr(stream);
+      } else if (node.node_ops.getattr) {
+        return node.node_ops.getattr(node);
+      }
+      throw new FS.ErrnoError({{{ cDefs.EPERM }}});
+    },
     lstat(path) {
       return FS.stat(path, true);
     },
@@ -980,7 +990,17 @@ FS.staticInit();
     },
     fchmod(fd, mode) {
       var stream = FS.getStreamChecked(fd);
-      FS.chmod(stream.node, mode);
+      var node = stream.node;
+      var attrs = {
+        mode: (mode & {{{ cDefs.S_IALLUGO }}}) | (node.mode & ~{{{ cDefs.S_IALLUGO }}}),
+        ctime: Date.now()
+      };
+      if (stream.stream_ops.getattr) {
+        return stream.stream_ops.setattr(stream, attrs);
+      } else if (node.node_ops.getattr) {
+        return node.node_ops.setattr(node, attrs);
+      }
+      throw new FS.ErrnoError({{{ cDefs.EPERM }}});
     },
     chown(path, uid, gid, dontFollow) {
       var node;
@@ -1003,20 +1023,20 @@ FS.staticInit();
     },
     fchown(fd, uid, gid) {
       var stream = FS.getStreamChecked(fd);
-      FS.chown(stream.node, uid, gid);
-    },
-    truncate(path, len) {
-      if (len < 0) {
-        throw new FS.ErrnoError({{{ cDefs.EINVAL }}});
-      }
-      var node;
-      if (typeof path == 'string') {
-        var lookup = FS.lookupPath(path, { follow: true });
-        node = lookup.node;
-      } else {
-        node = path;
+      var node = stream.node;
+      var attrs = {
+        timestamp: Date.now()
+        // we ignore the uid / gid for now
+      };
+      if (stream.stream_ops.getattr) {
+        return stream.stream_ops.setattr(stream, attrs);
+      } else if (node.node_ops.getattr) {
+        return node.node_ops.setattr(node, attrs);
       }
-      if (!node.node_ops.setattr) {
+      throw new FS.ErrnoError({{{ cDefs.EPERM }}});
+    },
+    truncateCommon(node, stream, len) {
+      if (!node.node_ops.setattr && !stream?.stream_ops.setattr) {
         throw new FS.ErrnoError({{{ cDefs.EPERM }}});
       }
       if (FS.isDir(node.mode)) {
@@ -1029,17 +1049,35 @@ FS.staticInit();
       if (errCode) {
         throw new FS.ErrnoError(errCode);
       }
-      node.node_ops.setattr(node, {
+      var attrs = {
         size: len,
         timestamp: Date.now()
-      });
+      };
+      if (stream?.stream_ops.setattr) {
+        stream.stream_ops.setattr(stream, attrs);
+      } else {
+        node.node_ops.setattr(node, attrs);
+      }
+    },
+    truncate(path, len) {
+      if (len < 0) {
+        throw new FS.ErrnoError({{{ cDefs.EINVAL }}});
+      }
+      var node;
+      if (typeof path == 'string') {
+        var lookup = FS.lookupPath(path, { follow: true });
+        node = lookup.node;
+      } else {
+        node = path;
+      }
+      FS.truncateCommon(node, undefined, len, false);
     },
     ftruncate(fd, len) {
       var stream = FS.getStreamChecked(fd);
-      if ((stream.flags & {{{ cDefs.O_ACCMODE }}}) === {{{ cDefs.O_RDONLY}}}) {
+      if (len < 0 || (stream.flags & {{{ cDefs.O_ACCMODE }}}) === {{{ cDefs.O_RDONLY}}}) {
         throw new FS.ErrnoError({{{ cDefs.EINVAL }}});
       }
-      FS.truncate(stream.node, len);
+      FS.truncateCommon(stream.node, stream, len);
     },
     utime(path, atime, mtime) {
       var lookup = FS.lookupPath(path, { follow: true });

src/library_nodefs.js

@@ -116,65 +116,76 @@ addToLibrary({
       }
       return newFlags;
     },
-
+    getattr(func, node) {
+      var stat = NODEFS.tryFSOperation(func);
+      if (NODEFS.isWindows) {
+        // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake
+        // them with default blksize of 4096.
+        // See http://support.microsoft.com/kb/140365
+        if (!stat.blksize) {
+          stat.blksize = 4096;
+        }
+        if (!stat.blocks) {
+          stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
+        }
+        // Windows does not report the 'x' permission bit, so propagate read
+        // bits to execute bits.
+        stat.mode |= (stat.mode & {{{ cDefs.S_IRUGO }}}) >> 2;
+      }
+      return {
+        dev: stat.dev,
+        ino: node.id,
+        mode: stat.mode,
+        nlink: stat.nlink,
+        uid: stat.uid,
+        gid: stat.gid,
+        rdev: stat.rdev,
+        size: stat.size,
+        atime: stat.atime,
+        mtime: stat.mtime,
+        ctime: stat.ctime,
+        blksize: stat.blksize,
+        blocks: stat.blocks
+      };
+    },
+    // Common code for both node and stream setattr
+    // For node getatrr:
+    //  - arg is a native path
+    //  - chmod, utimes, truncate are fs.chmodSync,  fs.utimesSync,  fs.truncateSync
+    // For stream getatrr:
+    //  - arg is a native file descriptor
+    //  - chmod, utimes, truncate are fs.fchmodSync, fs.futimesSync, fs.ftruncateSync
+    setattr(arg, node, attr, chmod, utimes, truncate) {
+      NODEFS.tryFSOperation(() => {
+        if (attr.mode !== undefined) {
+          var mode = attr.mode;
+          if (NODEFS.isWindows) {
+            // Windows only supports S_IREAD / S_IWRITE (S_IRUSR / S_IWUSR)
+            // https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/chmod-wchmod
+            mode &= {{{ cDefs.S_IRUSR | cDefs.S_IWUSR }}};
+          }
+          chmod(arg, mode);
+          // update the common node structure mode as well
+          node.mode = attr.mode;
+        }
+        if (attr.atime || attr.mtime) {
+          var atime = attr.atime && new Date(attr.atime);
+          var mtime = attr.mtime && new Date(attr.mtime);
+          utimes(arg, atime, mtime);
+        }
+        if (attr.size !== undefined) {
+          truncate(arg, attr.size);
+        }
+      });
+    },
     node_ops: {
       getattr(node) {
         var path = NODEFS.realPath(node);
-        var stat;
-        NODEFS.tryFSOperation(() => stat = fs.lstatSync(path));
-        if (NODEFS.isWindows) {
-          // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake
-          // them with default blksize of 4096.
-          // See http://support.microsoft.com/kb/140365
-          if (!stat.blksize) {
-            stat.blksize = 4096;
-          }
-          if (!stat.blocks) {
-            stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
-          }
-          // Windows does not report the 'x' permission bit, so propagate read
-          // bits to execute bits.
-          stat.mode |= (stat.mode & {{{ cDefs.S_IRUGO }}}) >> 2;
-        }
-        return {
-          dev: stat.dev,
-          ino: node.id,
-          mode: stat.mode,
-          nlink: stat.nlink,
-          uid: stat.uid,
-          gid: stat.gid,
-          rdev: stat.rdev,
-          size: stat.size,
-          atime: stat.atime,
-          mtime: stat.mtime,
-          ctime: stat.ctime,
-          blksize: stat.blksize,
-          blocks: stat.blocks
-        };
+        return NODEFS.getattr(() => fs.lstatSync(path), node);
       },
       setattr(node, attr) {
         var path = NODEFS.realPath(node);
-        NODEFS.tryFSOperation(() => {
-          if (attr.mode !== undefined) {
-            var mode = attr.mode;
-            if (NODEFS.isWindows) {
-              // Windows only supports S_IREAD / S_IWRITE (S_IRUSR / S_IWUSR)
-              // https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/chmod-wchmod
-              mode &= {{{ cDefs.S_IRUSR | cDefs.S_IWUSR }}};
-            }
-            fs.chmodSync(path, mode);
-            // update the common node structure mode as well
-            node.mode = attr.mode;
-          }
-          if (attr.atime || attr.mtime) {
-            var atime = attr.atime && new Date(attr.atime);
-            var mtime = attr.mtime && new Date(attr.mtime);
-            fs.utimesSync(path, atime, mtime);
-          }
-          if (attr.size !== undefined) {
-            fs.truncateSync(path, attr.size);
-          }
-        });
+        NODEFS.setattr(path, node, attr, fs.chmodSync, fs.utimesSync, fs.truncateSync);
       },
       lookup(parent, name) {
         var path = PATH.join2(NODEFS.realPath(parent), name);
@@ -232,18 +243,22 @@ addToLibrary({
       }
     },
     stream_ops: {
+      getattr(stream) {
+        return NODEFS.getattr(() => fs.fstatSync(stream.nfd), stream.node);
+      },
+      setattr(stream, attr) {
+        NODEFS.setattr(stream.nfd, stream.node, attr, fs.fchmodSync, fs.futimesSync, fs.ftruncateSync);
+      },
       open(stream) {
         var path = NODEFS.realPath(stream.node);
         NODEFS.tryFSOperation(() => {
-          if (FS.isFile(stream.node.mode)) {
-            stream.shared.refcount = 1;
-            stream.nfd = fs.openSync(path, NODEFS.flagsForNode(stream.flags));
-          }
+          stream.shared.refcount = 1;
+          stream.nfd = fs.openSync(path, NODEFS.flagsForNode(stream.flags));
         });
       },
       close(stream) {
         NODEFS.tryFSOperation(() => {
-          if (FS.isFile(stream.node.mode) && stream.nfd && --stream.shared.refcount === 0) {
+          if (stream.nfd && --stream.shared.refcount === 0) {
             fs.closeSync(stream.nfd);
           }
         });

src/library_noderawfs.js

@@ -79,6 +79,10 @@ addToLibrary({
       }
       return stat;
     },
+    fstat(fd) {
+      var stream = FS.getStreamChecked(fd);
+      return fs.fstatSync(stream.nfd);
+    },
     chmod(path, mode, dontFollow) {
       mode &= {{{ cDefs.S_IALLUGO }}};
       if (NODEFS.isWindows) {

src/library_pipefs.js

@@ -20,6 +20,7 @@ addToLibrary({
         // refcnt 2 because pipe has a read end and a write end. We need to be
         // able to read from the read end after write end is closed.
         refcnt : 2,
+        timestamp: new Date(),
       };
 
       pipe.buckets.push({
@@ -60,6 +61,25 @@ addToLibrary({
       };
     },
     stream_ops: {
+      getattr(stream) {
+        var node = stream.node;
+        var timestamp = node.pipe.timestamp;
+        return {
+          dev: 14,
+          ino: node.id,
+          mode: 0o10600,
+          nlink: 1,
+          uid: 0,
+          gid: 0,
+          rdev: 0,
+          size: 0,
+          atime: timestamp,
+          mtime: timestamp,
+          ctime: timestamp,
+          blksize: 4096,
+          blocks: 0,
+        };
+      },
       poll(stream) {
         var pipe = stream.node.pipe;
 

src/library_syscall.js

@@ -678,8 +678,7 @@ var SyscallsLibrary = {
     return SYSCALLS.writeStat(buf, FS.lstat(path));
   },
   __syscall_fstat64: (fd, buf) => {
-    var stream = SYSCALLS.getStreamFromFD(fd);
-    return SYSCALLS.writeStat(buf, FS.stat(stream.path));
+    return SYSCALLS.writeStat(buf, FS.fstat(fd));
   },
   __syscall_fchown32: (fd, owner, group) => {
     FS.fchown(fd, owner, group);

test/fs/test_stat_unnamed_file_descriptor.c

@@ -0,0 +1,21 @@
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <assert.h>
+#include "stdio.h"
+
+int main() {
+  setup();
+  int fd = open("file.txt", O_RDWR | O_CREAT, 0666);
+  unlink("file.txt");
+  int res;
+  struct stat buf;
+  res = fstat(fd, &buf);
+  assert(res == 0);
+  assert(buf.st_atime > 1000000000);
+  res = fchmod(fd, 0777);
+  assert(res == 0);
+  res = ftruncate(fd, 10);
+  assert(res == 0);
+  printf("success\n");
+}

test/test_core.py

@@ -5842,6 +5842,16 @@ def test_fs_64bit(self):
       self.set_setting('FORCE_FILESYSTEM')
     self.do_runf('fs/test_64bit.c', 'success')
 
+  @crossplatform
+  @also_with_nodefs_both
+  def test_fs_stat_unnamed_file_descriptor(self):
+    nodefs = '-DNODEFS' in self.emcc_args or '-DNODERAWFS' in self.emcc_args
+    if self.get_setting('WASMFS'):
+      if nodefs:
+        self.skipTest('NODEFS in WasmFS')
+      self.set_setting('FORCE_FILESYSTEM')
+    self.do_runf('fs/test_stat_unnamed_file_descriptor.c', 'success', emcc_args=args)
+
   @requires_node
   @crossplatform
   @with_all_fs

test/unistd/pipe.c

@@ -7,6 +7,7 @@
 
 #include <unistd.h>
 #include <sys/types.h>
+#include <sys/stat.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <errno.h>
@@ -65,6 +66,10 @@ int test_most() {
 
   assert(pipe(fd) == 0);
 
+  // Test that pipe is statable
+  struct stat st;
+  assert(fstat(fd[0], &st) == 0);
+
   // Test that pipe is not seekable
 
   memset(buf, 0, sizeof buf);