diagnostics_channel: fix USDT hot path under startup snapshot

The publish() hot path captured the probe semaphore Uint16Array
view at module load.  This module is baked into the startup
snapshot, and the view's native backing store cannot be serialized:
the captured view is detached when the snapshot is deserialized, so
publish() never called emitPublishProbe() in snapshot builds and
the dc__publish probe never fired for JavaScript publishes even
with a tracer attached.  Caught by the new bpftrace CI job.

Resolve the view lazily from the binding (once per process; 'null'
marks a USDT-less build) and add positive-path coverage to
test-diagnostics-channel-usdt.js: force the semaphore and verify
that publish() calls emitPublishProbe() for string-named channels,
never for symbol-named ones, and not when the semaphore is 0.

Signed-off-by: Bryan English <bryan@bryanenglish.com>

Author: bengl

lib/diagnostics_channel.js

@@ -32,12 +32,15 @@ const {
 const { triggerUncaughtException } = internalBinding('errors');
 
 const dc_binding = internalBinding('diagnostics_channel');
-const { subscribers: subscriberCounts, probeSemaphore } = dc_binding;
-// When compiled without USDT support, probeSemaphore is undefined and
-// emitPublishProbe does not exist.  Capture this once at load time so that
-// when USDT is absent, the hot path in publish() can skip all probe logic
-// with a single boolean check.
-const hasUSDT = probeSemaphore !== undefined;
+const { subscribers: subscriberCounts } = dc_binding;
+// The USDT probe semaphore is exposed by the binding as a Uint16Array
+// view over static native memory.  It must be resolved lazily rather than
+// captured at module load: this module is included in the startup
+// snapshot, and the view's native backing store cannot be serialized:
+// a view captured while building the snapshot is detached when the
+// snapshot is deserialized.  `null` marks a USDT-less build after the
+// first resolution so that the hot path stays branch-only in that case.
+let probeSemaphore;
 
 const { WeakReference } = require('internal/util');
 
@@ -163,7 +166,12 @@ class ActiveChannel {
   }
 
   publish(data) {
-    if (hasUSDT && probeSemaphore[0] > 0 && typeof this.name === 'string') {
+    if (probeSemaphore === undefined) {
+      probeSemaphore = dc_binding.probeSemaphore ?? null;
+    }
+    if (probeSemaphore !== null &&
+        probeSemaphore[0] > 0 &&
+        typeof this.name === 'string') {
       dc_binding.emitPublishProbe(this.name, data);
     }
     const subscribers = this._subscribers;

test/parallel/test-diagnostics-channel-usdt.js

@@ -23,9 +23,9 @@ const binding = internalBinding('diagnostics_channel');
   );
 
   if (probeSemaphore !== undefined) {
-    // Without a tracer attached the semaphore must be 0 (Linux SystemTap
-    // dtrace -h path) or 1 (macOS/FreeBSD/illumos dtrace -h path, or
-    // fallback sys/sdt.h path where the probe always fires).
+    // Without a tracer attached the semaphore must be 0 (Linux, committed
+    // SystemTap-generated header) or 1 (macOS --with-dtrace path, which
+    // has no native semaphore).
     assert.ok(
       probeSemaphore[0] === 0 || probeSemaphore[0] === 1,
       `Expected semaphore to be 0 or 1, got ${probeSemaphore[0]}`,
@@ -41,10 +41,11 @@ const binding = internalBinding('diagnostics_channel');
 
 // --- JS probe guard: verify emitPublishProbe is called/skipped ---
 
-// When the semaphore is > 0 (Tier 2 fallback), emitPublishProbe must be
-// called for string-named channels and must NOT be called for symbol-named
-// channels.  When the semaphore is 0 (Tier 1, no tracer) or USDT is absent,
-// emitPublishProbe must never be called.
+// When the semaphore is > 0 (macOS --with-dtrace, which has no native
+// semaphore), emitPublishProbe must be called for string-named channels and
+// must NOT be called for symbol-named channels.  When the semaphore is 0
+// (Linux Tier 1, no tracer) or USDT is absent, emitPublishProbe must never
+// be called.
 {
   const { probeSemaphore, emitPublishProbe } = binding;
   const semaphoreEnabled = probeSemaphore !== undefined &&
@@ -68,10 +69,12 @@ const binding = internalBinding('diagnostics_channel');
 
   if (semaphoreEnabled) {
     assert.strictEqual(probeCallCount, 1,
-      'emitPublishProbe should be called once for string-named channel');
+                       `emitPublishProbe should be called once for ` +
+                       `string-named channel, got ${probeCallCount}`);
   } else {
     assert.strictEqual(probeCallCount, 0,
-      'emitPublishProbe should not be called when semaphore is 0');
+                       `emitPublishProbe should not be called when the ` +
+                       `semaphore is 0, got ${probeCallCount}`);
   }
 
   // Symbol-named channel — probe must never fire regardless of semaphore.
@@ -84,14 +87,72 @@ const binding = internalBinding('diagnostics_channel');
   symCh.unsubscribe(symSub);
 
   assert.strictEqual(probeCallCount, 0,
-    'emitPublishProbe must not be called for symbol-named channels');
+                     `emitPublishProbe must not be called for symbol-named ` +
+                     `channels, got ${probeCallCount}`);
 
   // Restore original.
   if (origProbe !== undefined) {
     binding.emitPublishProbe = origProbe;
   }
 }
 
+// --- JS probe guard: positive path through the public publish() API ---
+
+// Force the semaphore to look "attached" and verify that the hot path in
+// lib/internal/diagnostics_channel actually calls emitPublishProbe.  This
+// exercises the module-level view of the semaphore (which must survive
+// startup-snapshot deserialization) rather than the binding directly.
+if (binding.probeSemaphore !== undefined) {
+  const { probeSemaphore } = binding;
+  const origSemaphore = probeSemaphore[0];
+  let probeCalls = [];
+  const origProbe = binding.emitPublishProbe;
+  binding.emitPublishProbe = (name) => probeCalls.push(name);
+
+  try {
+    probeSemaphore[0] = 1;
+    const ch = dc.channel('test:usdt:probe-positive');
+    const subscriber = common.mustCall();
+    ch.subscribe(subscriber);
+    probeCalls = [];
+    ch.publish({ probePositive: true });
+    ch.unsubscribe(subscriber);
+
+    assert.deepStrictEqual(probeCalls, ['test:usdt:probe-positive'],
+                           `publish() must call emitPublishProbe for string-named channels ` +
+      `when the semaphore is > 0, got ${JSON.stringify(probeCalls)}`);
+
+    // Symbol-named channels must never emit the probe.
+    probeCalls = [];
+    const sym = Symbol('test:usdt:symbol-probe-positive');
+    const symCh = dc.channel(sym);
+    const symSub = common.mustCall();
+    symCh.subscribe(symSub);
+    symCh.publish({ symbolPositive: true });
+    symCh.unsubscribe(symSub);
+
+    assert.deepStrictEqual(probeCalls, [],
+                           `publish() must not call emitPublishProbe for symbol-named ` +
+      `channels, got ${JSON.stringify(probeCalls)}`);
+
+    // With the semaphore back at 0, the probe must not be emitted.
+    probeSemaphore[0] = 0;
+    probeCalls = [];
+    const ch0 = dc.channel('test:usdt:probe-negative');
+    const sub0 = common.mustCall();
+    ch0.subscribe(sub0);
+    ch0.publish({ probeNegative: true });
+    ch0.unsubscribe(sub0);
+
+    assert.deepStrictEqual(probeCalls, [],
+                           `publish() must not call emitPublishProbe when the semaphore is 0, ` +
+      `got ${JSON.stringify(probeCalls)}`);
+  } finally {
+    probeSemaphore[0] = origSemaphore;
+    binding.emitPublishProbe = origProbe;
+  }
+}
+
 // --- Publish with and without subscribers ---
 
 // String-named channel with subscribers.