Merge branch 'main' into emmalloc-fix-verbose

Author: kleisauke

ChangeLog.md

@@ -20,10 +20,14 @@ See docs/process.md for more on how version tagging works.
 
 3.1.74 (in development)
 -----------------------
+- The file system was updated to independently track atime, mtime and ctime
+  instead of using the same time for all three. (#22998)
+- The minimum supported chrome version was bumped from 32 to 33. (#23077)
 
 3.1.73 - 11/28/24
 -----------------
 - libunwind was updated to LLVM 19.1.4. (#22394)
+- mimalloc was updated to 2.1.7. (#21548)
 
 3.1.72 - 11/19/24
 -----------------

site/source/docs/tools_reference/settings_reference.rst

@@ -2939,7 +2939,7 @@ This setting also applies to modern Chromium-based Edge, which shares version
 numbers with Chrome.
 Chrome 85 was released on 2020-08-25.
 MAX_INT (0x7FFFFFFF, or -1) specifies that target is not supported.
-Minimum supported value is 32, which was released on 2014-01-04.
+Minimum supported value is 33, which was released on 2014-02-18.
 
 Default value: 85
 

src/closure-externs/node-externs.js

@@ -119,3 +119,15 @@ fs.Stats.prototype.mtimeMs;
  * @type {number}
  */
 fs.Stats.prototype.ctimeMs;
+
+/**
+ * @param {string} p
+ * @return {boolean}
+ * @nosideeffects
+ */
+path.isAbsolute;
+
+/**
+ * @type {Object.<string,*>}
+ */
+path.posix;

src/library_async.js

@@ -520,9 +520,7 @@ addToLibrary({
     var imports = {'primary': wasmExports};
     // Replace '.wasm' suffix with '.deferred.wasm'.
     var deferred = wasmBinaryFile.slice(0, -5) + '.deferred.wasm';
-    await new Promise((resolve) => {
-      instantiateAsync(null, deferred, imports, resolve);
-    });
+    await instantiateAsync(null, deferred, imports);
   },
 
   $Fibers__deps: ['$Asyncify', 'emscripten_stack_set_limits', '$stackRestore'],

src/library_fs.js

@@ -146,6 +146,7 @@ FS.staticInit();
         this.name = name;
         this.mode = mode;
         this.rdev = rdev;
+        this.atime = this.mtime = this.ctime = Date.now();
       }
       get read() {
         return (this.mode & this.readMode) === this.readMode;
@@ -192,8 +193,18 @@ FS.staticInit();
             break;
           }
 
-          current = FS.lookupNode(current, parts[i]);
           current_path = PATH.join2(current_path, parts[i]);
+          try {
+            current = FS.lookupNode(current, parts[i]);
+          } catch (e) {
+            // if noent_okay is true, suppress a ENOENT in the last component
+            // and return an object with an undefined node. This is needed for
+            // resolving symlinks in the path when creating a file.
+            if ((e?.errno === {{{ cDefs.ENOENT }}}) && islast && opts.noent_okay) {
+              return { path: current_path };
+            }
+            throw e;
+          }
 
           // jump to the mount's root node if this is a mountpoint
           if (FS.isMountpoint(current) && (!islast || opts.follow_mount)) {
@@ -943,7 +954,7 @@ FS.staticInit();
       }
       node.node_ops.setattr(node, {
         mode: (mode & {{{ cDefs.S_IALLUGO }}}) | (node.mode & ~{{{ cDefs.S_IALLUGO }}}),
-        timestamp: Date.now()
+        ctime: Date.now()
       });
     },
     lchmod(path, mode) {
@@ -1016,7 +1027,8 @@ FS.staticInit();
       var lookup = FS.lookupPath(path, { follow: true });
       var node = lookup.node;
       node.node_ops.setattr(node, {
-        timestamp: Math.max(atime, mtime)
+        atime: atime,
+        mtime: mtime
       });
     },
     open(path, flags, mode = 0o666) {
@@ -1034,14 +1046,15 @@ FS.staticInit();
         node = path;
       } else {
         path = PATH.normalize(path);
-        try {
-          var lookup = FS.lookupPath(path, {
-            follow: !(flags & {{{ cDefs.O_NOFOLLOW }}})
-          });
-          node = lookup.node;
-        } catch (e) {
-          // ignore
-        }
+        // noent_okay makes it so that if the final component of the path
+        // doesn't exist, lookupPath returns `node: undefined`. `path` will be
+        // updated to point to the target of all symlinks.
+        var lookup = FS.lookupPath(path, {
+          follow: !(flags & {{{ cDefs.O_NOFOLLOW }}}),
+          noent_okay: true
+        });
+        node = lookup.node;
+        path = lookup.path;
       }
       // perhaps we need to create the node
       var created = false;
@@ -1391,6 +1404,9 @@ FS.staticInit();
       FS.mount({
         mount() {
           var node = FS.createNode(proc_self, 'fd', {{{ cDefs.S_IFDIR | 0o777 }}}, {{{ cDefs.S_IXUGO }}});
+          node.stream_ops = {
+            llseek: MEMFS.stream_ops.llseek,
+          };
           node.node_ops = {
             lookup(parent, name) {
               var fd = +name;
@@ -1399,9 +1415,15 @@ FS.staticInit();
                 parent: null,
                 mount: { mountpoint: 'fake' },
                 node_ops: { readlink: () => stream.path },
+                id: fd + 1,
               };
               ret.parent = ret; // make it look like a simple root node
               return ret;
+            },
+            readdir() {
+              return Array.from(FS.streams.entries())
+                .filter(([k, v]) => v)
+                .map(([k, v]) => k.toString());
             }
           };
           return node;
@@ -1618,7 +1640,7 @@ FS.staticInit();
             buffer[offset+i] = result;
           }
           if (bytesRead) {
-            stream.node.timestamp = Date.now();
+            stream.node.atime = Date.now();
           }
           return bytesRead;
         },
@@ -1631,7 +1653,7 @@ FS.staticInit();
             }
           }
           if (length) {
-            stream.node.timestamp = Date.now();
+            stream.node.mtime = stream.node.ctime = Date.now();
           }
           return i;
         }

src/library_lz4.js

@@ -70,7 +70,7 @@ addToLibrary({
       node.mode = mode;
       node.node_ops = LZ4.node_ops;
       node.stream_ops = LZ4.stream_ops;
-      node.timestamp = (mtime || new Date).getTime();
+      this.atime = this.mtime = this.ctime = (mtime || new Date).getTime();
       assert(LZ4.FILE_MODE !== LZ4.DIR_MODE);
       if (mode === LZ4.FILE_MODE) {
         node.size = contents.end - contents.start;
@@ -95,19 +95,18 @@ addToLibrary({
           gid: 0,
           rdev: 0,
           size: node.size,
-          atime: new Date(node.timestamp),
-          mtime: new Date(node.timestamp),
-          ctime: new Date(node.timestamp),
+          atime: new Date(node.atime),
+          mtime: new Date(node.mtime),
+          ctime: new Date(node.ctime),
           blksize: 4096,
           blocks: Math.ceil(node.size / 4096),
         };
       },
       setattr(node, attr) {
-        if (attr.mode !== undefined) {
-          node.mode = attr.mode;
-        }
-        if (attr.timestamp !== undefined) {
-          node.timestamp = attr.timestamp;
+        for (const key of ['mode', 'atime', 'mtime', 'ctime']) {
+          if (attr[key]) {
+            node[key] = attr[key];
+          }
         }
       },
       lookup(parent, name) {

src/library_memfs.js

@@ -92,11 +92,11 @@ addToLibrary({
         node.node_ops = MEMFS.ops_table.chrdev.node;
         node.stream_ops = MEMFS.ops_table.chrdev.stream;
       }
-      node.timestamp = Date.now();
+      node.atime = node.mtime = node.ctime = Date.now();
       // add the new node to the parent
       if (parent) {
         parent.contents[name] = node;
-        parent.timestamp = node.timestamp;
+        parent.atime = parent.mtime = parent.ctime = node.atime;
       }
       return node;
     },
@@ -161,21 +161,20 @@ addToLibrary({
         } else {
           attr.size = 0;
         }
-        attr.atime = new Date(node.timestamp);
-        attr.mtime = new Date(node.timestamp);
-        attr.ctime = new Date(node.timestamp);
+        attr.atime = new Date(node.atime);
+        attr.mtime = new Date(node.mtime);
+        attr.ctime = new Date(node.ctime);
         // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
         //       but this is not required by the standard.
         attr.blksize = 4096;
         attr.blocks = Math.ceil(attr.size / attr.blksize);
         return attr;
       },
       setattr(node, attr) {
-        if (attr.mode !== undefined) {
-          node.mode = attr.mode;
-        }
-        if (attr.timestamp !== undefined) {
-          node.timestamp = attr.timestamp;
+        for (const key of ["mode", "atime", "mtime", "ctime"]) {
+          if (attr[key]) {
+            node[key] = attr[key];
+          }
         }
         if (attr.size !== undefined) {
           MEMFS.resizeFileStorage(node, attr.size);
@@ -192,44 +191,39 @@ addToLibrary({
         return MEMFS.createNode(parent, name, mode, dev);
       },
       rename(old_node, new_dir, new_name) {
-        // if we're overwriting a directory at new_name, make sure it's empty.
-        if (FS.isDir(old_node.mode)) {
-          var new_node;
-          try {
-            new_node = FS.lookupNode(new_dir, new_name);
-          } catch (e) {
-          }
-          if (new_node) {
+        var new_node;
+        try {
+          new_node = FS.lookupNode(new_dir, new_name);
+        } catch (e) {}
+        if (new_node) {
+          if (FS.isDir(old_node.mode)) {
+            // if we're overwriting a directory at new_name, make sure it's empty.
             for (var i in new_node.contents) {
               throw new FS.ErrnoError({{{ cDefs.ENOTEMPTY }}});
             }
           }
+          FS.hashRemoveNode(new_node);
         }
         // do the internal rewiring
         delete old_node.parent.contents[old_node.name];
-        old_node.parent.timestamp = Date.now()
-        old_node.name = new_name;
         new_dir.contents[new_name] = old_node;
-        new_dir.timestamp = old_node.parent.timestamp;
+        old_node.name = new_name;
+        new_dir.ctime = new_dir.mtime = old_node.parent.ctime = old_node.parent.mtime = Date.now();
       },
       unlink(parent, name) {
         delete parent.contents[name];
-        parent.timestamp = Date.now();
+        parent.ctime = parent.mtime = Date.now();
       },
       rmdir(parent, name) {
         var node = FS.lookupNode(parent, name);
         for (var i in node.contents) {
           throw new FS.ErrnoError({{{ cDefs.ENOTEMPTY }}});
         }
         delete parent.contents[name];
-        parent.timestamp = Date.now();
+        parent.ctime = parent.mtime = Date.now();
       },
       readdir(node) {
-        var entries = ['.', '..'];
-        for (var key of Object.keys(node.contents)) {
-          entries.push(key);
-        }
-        return entries;
+        return ['.', '..', ...Object.keys(node.contents)];
       },
       symlink(parent, newname, oldpath) {
         var node = MEMFS.createNode(parent, newname, 0o777 | {{{ cDefs.S_IFLNK }}}, 0);
@@ -282,7 +276,7 @@ addToLibrary({
 
         if (!length) return 0;
         var node = stream.node;
-        node.timestamp = Date.now();
+        node.mtime = node.ctime = Date.now();
 
         if (buffer.subarray && (!node.contents || node.contents.subarray)) { // This write is from a typed array to a typed array?
           if (canOwn) {

src/library_nodefs.js

@@ -166,9 +166,10 @@ addToLibrary({
             // update the common node structure mode as well
             node.mode = attr.mode;
           }
-          if (attr.timestamp !== undefined) {
-            var date = new Date(attr.timestamp);
-            fs.utimesSync(path, date, date);
+          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);
@@ -196,6 +197,9 @@ addToLibrary({
       rename(oldNode, newDir, newName) {
         var oldPath = NODEFS.realPath(oldNode);
         var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
+        try {
+          FS.unlink(newPath);
+        } catch(e) {}
         NODEFS.tryFSOperation(() => fs.renameSync(oldPath, newPath));
         oldNode.name = newName;
       },

src/library_nodepath.js

@@ -12,23 +12,23 @@
 // operations. Hence, using `nodePath` should be safe here.
 
 addToLibrary({
-  $PATH: {
-    isAbs: (path) => nodePath['isAbsolute'](path),
-    normalize: (path) => nodePath['normalize'](path),
-    dirname: (path) => nodePath['dirname'](path),
-    basename: (path) => nodePath['basename'](path),
-    join: (...args) => nodePath['join'](...args),
-    join2: (l, r) => nodePath['join'](l, r),
-  },
+  $PATH: `{
+    isAbs: nodePath.isAbsolute,
+    normalize: nodePath.normalize,
+    dirname: nodePath.dirname,
+    basename: nodePath.basename,
+    join: nodePath.join,
+    join2: nodePath.join,
+  }`,
   // The FS-using parts are split out into a separate object, so simple path
   // usage does not require the FS.
   $PATH_FS__deps: ['$FS'],
   $PATH_FS__docs: '/** @type{{resolve: function(...*)}} */',
   $PATH_FS: {
     resolve: (...paths) => {
       paths.unshift(FS.cwd());
-      return nodePath['posix']['resolve'](...paths);
+      return nodePath.posix.resolve(...paths);
     },
-    relative: (from, to) => nodePath['posix']['relative'](from || FS.cwd(), to || FS.cwd()),
+    relative: (from, to) => nodePath.posix.relative(from || FS.cwd(), to || FS.cwd()),
   }
 });

src/library_noderawfs.js

@@ -40,7 +40,7 @@ addToLibrary({
     },
     lookupPath(path, opts = {}) {
       if (opts.parent) {
-        path = nodePath.dirname(path);
+        path = PATH.dirname(path);
       }
       var st = fs.lstatSync(path);
       var mode = NODEFS.getMode(path);
@@ -112,13 +112,13 @@ addToLibrary({
       fs.ftruncateSync(stream.nfd, len);
     },
     utime(path, atime, mtime) {
-      // -1 here for atime or mtime means UTIME_OMIT was passed.  Since node
+      // null here for atime or mtime means UTIME_OMIT was passed.  Since node
       // doesn't support this concept we need to first find the existing
       // timestamps in order to preserve them.
-      if (atime == -1 || mtime == -1) {
+      if ((atime === null) || (mtime === null)) {
         var st = fs.statSync(path);
-        if (atime == -1) atime = st.atimeMs;
-        if (mtime == -1) mtime = st.mtimeMs;
+        atime ||= st.atimeMs;
+        mtime ||= st.mtimeMs;
       }
       fs.utimesSync(path, atime/1000, mtime/1000);
     },