src: fix timing of snapshot serialize callback

Previously the addAfterUserSerailizeCallback() wasn't ready to be used for building the built-in snapshot. This patch initializes the callbacks at the time lib/internal/v8/start_snapshot.js is loaded, so that these callbacks get run correctly when building the built-in snapshot. Currently when building the built-in snapshot, addAfterUserSerializeCallback() is only used by createUnsafeBuffer(), other usages can only come from user-land snapshots, which is covered by tests, but what gets run by the built-in snapshot building process is less visible, and the path used by createUnsafeBuffer() isn't reliably visible in user land either. This adds an internal usage counter in debug builds to verify this path when building the built-in snapshot. PR-URL: #60434Fixes: #60423 Reviewed-By: Matteo Collina <[email protected]> Reviewed-By: Antoine du Hamel <[email protected]> Reviewed-By: Richard Lau <[email protected]>

Author: joyeecheung

lib/internal/main/mksnapshot.js

@@ -21,7 +21,6 @@ const{emitExperimentalWarning } = require('internal/util');
 const{ emitWarningSync }=require('internal/process/warning');
 
 const{
- initializeCallbacks,
 namespace: {
  addDeserializeCallback,
  isBuildingSnapshot,
@@ -139,7 +138,6 @@ function requireForUserSnapshot(id){
 
 functionmain(){
 prepareMainThreadExecution(false,false);
-initializeCallbacks();
 
 // In a context created for building snapshots, V8 does not install Error.stackTraceLimit and as
 // a result, if an error is created during the snapshot building process, error.stack would be

lib/internal/v8/startup_snapshot.js

@@ -115,8 +115,8 @@ function setDeserializeMainFunction(callback, data){
 });
 }
 
+initializeCallbacks();
 module.exports={
- initializeCallbacks,
  runDeserializeCallbacks,
  throwIfBuildingSnapshot,
 // Exposed to require('v8').startupSnapshot

test/parallel/test-buffer-alloc-unsafe-is-initialized-with-zero-fill-flag.js

@@ -0,0 +1,21 @@
+// Flags: --expose-internals --zero-fill-buffers
+// Verifies that Buffer.allocUnsafe() allocates initialized memory under --zero-fill-buffers by
+// checking the usage count of the relevant native allocator code path.
+'use strict';
+
+constcommon=require('../common');
+if(!common.isDebug){
+common.skip('Only works in debug mode');
+}
+const{ internalBinding }=require('internal/test/binding');
+const{ getGenericUsageCount }=internalBinding('debug');
+constassert=require('assert');
+
+constinitialUninitializedCount=getGenericUsageCount('NodeArrayBufferAllocator.Allocate.Uninitialized');
+constinitialZeroFilledCount=getGenericUsageCount('NodeArrayBufferAllocator.Allocate.ZeroFilled');
+constbuffer=Buffer.allocUnsafe(Buffer.poolSize+1);
+assert(buffer.every((b)=>b===0));
+constnewUninitializedCount=getGenericUsageCount('NodeArrayBufferAllocator.Allocate.Uninitialized');
+constnewZeroFilledCount=getGenericUsageCount('NodeArrayBufferAllocator.Allocate.ZeroFilled');
+assert.strictEqual(newUninitializedCount,initialUninitializedCount);
+assert.notStrictEqual(newZeroFilledCount,initialZeroFilledCount);

test/parallel/test-buffer-alloc-unsafe-is-uninitialized.js

@@ -0,0 +1,23 @@
+// Flags: --expose-internals
+// Verifies that Buffer.allocUnsafe() indeed allocates uninitialized memory by checking
+// the usage count of the relevant native allocator code path.
+'use strict';
+
+constcommon=require('../common');
+if(!common.isDebug){
+common.skip('Only works in debug mode');
+}
+const{ internalBinding }=require('internal/test/binding');
+const{ getGenericUsageCount }=internalBinding('debug');
+constassert=require('assert');
+
+constinitialUninitializedCount=getGenericUsageCount('NodeArrayBufferAllocator.Allocate.Uninitialized');
+constinitialZeroFilledCount=getGenericUsageCount('NodeArrayBufferAllocator.Allocate.ZeroFilled');
+Buffer.allocUnsafe(Buffer.poolSize+1);
+// We can't reliably check the contents of the buffer here because the OS or memory allocator
+// used might zero-fill memory for us, or they might happen to return reused memory that was
+// previously used by a process that zero-filled it. So instead we just check the usage counts.
+constnewUninitializedCount=getGenericUsageCount('NodeArrayBufferAllocator.Allocate.Uninitialized');
+constnewZeroFilledCount=getGenericUsageCount('NodeArrayBufferAllocator.Allocate.ZeroFilled');
+assert.notStrictEqual(newUninitializedCount,initialUninitializedCount);
+assert.strictEqual(newZeroFilledCount,initialZeroFilledCount);