lib: detect --frozen-intrinsics mismatch when loading

Author: watilde

src/node.h

@@ -648,6 +648,10 @@ enum class SnapshotFlags : uint32_t {
   // in the snapshot at the expense of a bigger snapshot size and
   // potentially breaking portability of the snapshot.
   kWithoutCodeCache = 1 << 0,
+  // Whether --frozen-intrinsics was active when the snapshot was built.
+  // Loading a snapshot built with --frozen-intrinsics without the flag (or
+  // vice versa) would result in inconsistent intrinsics state.
+  kFrozenIntrinsics = 1 << 1,
 };
 
 struct SnapshotConfig {

src/node_snapshotable.cc

@@ -536,7 +536,7 @@ size_t SnapshotSerializer::Write(const EnvSerializeInfo& data) {
 // [    ...    ]  |length| bytes of node arch
 // [ 4/8 bytes ]  length of the node platform string
 // [    ...    ]  |length| bytes of node platform
-// [  4 bytes  ]  v8 cache version tag
+// [  4 bytes  ]  SnapshotFlags
 template <>
 SnapshotMetadata SnapshotDeserializer::Read() {
   Debug("Read<SnapshotMetadata>()\n");
@@ -697,7 +697,23 @@ bool SnapshotData::Check() const {
     return false;
   }
 
-  // TODO(joyeecheung): check incompatible Node.js flags.
+  // For fully customized snapshots, check that Node.js flags affecting the
+  // snapshot were the same when the snapshot was built.
+  if (metadata.type == SnapshotMetadata::Type::kFullyCustomized) {
+    bool snapshot_frozen =
+        static_cast<bool>(metadata.flags & SnapshotFlags::kFrozenIntrinsics);
+    bool current_frozen =
+        per_process::cli_options->per_isolate->per_env->frozen_intrinsics;
+    if (snapshot_frozen != current_frozen) {
+      fprintf(stderr,
+              "Failed to load the startup snapshot because it was built "
+              "%s--frozen-intrinsics but the current process is run "
+              "%s--frozen-intrinsics.\n",
+              snapshot_frozen ? "with " : "without ",
+              current_frozen ? "with " : "without ");
+      return false;
+    }
+  }
   return true;
 }
 
@@ -1255,11 +1271,15 @@ ExitCode SnapshotBuilder::CreateSnapshot(SnapshotData* out,
     return ExitCode::kStartupSnapshotFailure;
   }
 
+  SnapshotFlags flags = config->flags;
+  if (env->options()->frozen_intrinsics) {
+    flags |= SnapshotFlags::kFrozenIntrinsics;
+  }
   out->metadata = SnapshotMetadata{snapshot_type,
                                    per_process::metadata.versions.node,
                                    per_process::metadata.arch,
                                    per_process::metadata.platform,
-                                   config->flags};
+                                   flags};
 
   // We cannot resurrect the handles from the snapshot, so make sure that
   // no handles are left open in the environment after the blob is created

test/parallel/test-snapshot-incompatible.js

@@ -1,7 +1,7 @@
 'use strict';
 
 // This tests that Node.js refuses to load snapshots built with incompatible
-// V8 configurations.
+// configurations (V8 or Node.js flags).
 
 require('../common');
 const assert = require('assert');
@@ -73,3 +73,77 @@ const entry = fixtures.path('empty.js');
     assert.strictEqual(child.status, 0);
   }
 }
+
+// Test that --frozen-intrinsics mismatch is detected.
+const frozenBlobPath = tmpdir.resolve('snapshot-frozen.blob');
+{
+  // Build a snapshot with --frozen-intrinsics.
+  const child = spawnSync(process.execPath, [
+    '--frozen-intrinsics',
+    '--snapshot-blob',
+    frozenBlobPath,
+    '--build-snapshot',
+    entry,
+  ], {
+    cwd: tmpdir.path
+  });
+  if (child.status !== 0) {
+    console.log(child.stderr.toString());
+    console.log(child.stdout.toString());
+    assert.strictEqual(child.status, 0);
+  }
+  const stats = fs.statSync(frozenBlobPath);
+  assert(stats.isFile());
+}
+
+{
+  // Load the snapshot without --frozen-intrinsics, which should fail.
+  const child = spawnSync(process.execPath, [
+    '--snapshot-blob',
+    frozenBlobPath,
+  ], {
+    cwd: tmpdir.path,
+    env: { ...process.env }
+  });
+
+  const stderr = child.stderr.toString().trim();
+  assert.match(stderr, /Failed to load the startup snapshot/);
+  assert.match(stderr, /--frozen-intrinsics/);
+  assert.strictEqual(child.status, 14);
+}
+
+{
+  // Load it again with --frozen-intrinsics and it should work.
+  const child = spawnSync(process.execPath, [
+    '--frozen-intrinsics',
+    '--snapshot-blob',
+    frozenBlobPath,
+  ], {
+    cwd: tmpdir.path,
+    env: { ...process.env }
+  });
+
+  if (child.status !== 0) {
+    console.log(child.stderr.toString());
+    console.log(child.stdout.toString());
+    assert.strictEqual(child.status, 0);
+  }
+}
+
+{
+  // Build a snapshot without --frozen-intrinsics and load with it, which
+  // should also fail.
+  const child = spawnSync(process.execPath, [
+    '--frozen-intrinsics',
+    '--snapshot-blob',
+    blobPath,
+  ], {
+    cwd: tmpdir.path,
+    env: { ...process.env }
+  });
+
+  const stderr = child.stderr.toString().trim();
+  assert.match(stderr, /Failed to load the startup snapshot/);
+  assert.match(stderr, /--frozen-intrinsics/);
+  assert.strictEqual(child.status, 14);
+}