Add counters

Author: zhengyu123

build-logic/conventions/src/main/kotlin/com/datadoghq/native/config/ConfigurationPresets.kt

@@ -37,12 +37,21 @@ object ConfigurationPresets {
         project.logger.lifecycle("Setting up standard build configurations for $currentPlatform-$currentArch")
         project.logger.lifecycle("Using compiler: $compiler")
 
+        // Opt-in compile-time fault injection. When -PenableFaultInjection is
+        // passed we append -D__FAULT_INJECTION__ to the standard release/debug
+        // library builds, so the documented buildRelease / buildDebug workflows
+        // produce a fault-injected libjavaProfiler.so. It is intentionally NOT
+        // applied to asan/tsan/fuzzer: those configs install their own SIGSEGV
+        // interception, which conflicts with the deliberately-faulting loads.
+        val faultInjection = project.hasProperty("enableFaultInjection")
         extension.buildConfigurations.apply {
             register("release") {
                 configureRelease(this, currentPlatform, currentArch, version)
+                if (faultInjection) compilerArgs.add("-D__FAULT_INJECTION__")
             }
             register("debug") {
                 configureDebug(this, currentPlatform, currentArch, version)
+                if (faultInjection) compilerArgs.add("-D__FAULT_INJECTION__")
             }
             register("asan") {
                 configureAsan(this, currentPlatform, currentArch, version, rootDir, compiler)
@@ -53,14 +62,6 @@ object ConfigurationPresets {
             register("fuzzer") {
                 configureFuzzer(this, currentPlatform, currentArch, version, rootDir, compiler)
             }
-            // Opt-in fault-injection config: a release build with -D__FAULT_INJECTION__.
-            // Only registered when -PenableFaultInjection is passed, so normal
-            // builds never see the define.
-            if (project.hasProperty("enableFaultInjection")) {
-                register("faultinjection") {
-                    configureFaultInjection(this, currentPlatform, currentArch, version)
-                }
-            }
         }
 
         val activeConfigs = extension.getActiveConfigurations(currentPlatform, currentArch)
@@ -133,22 +134,6 @@ object ConfigurationPresets {
         }
     }
 
-    /**
-     * Fault-injection configuration: identical to release but with
-     * -D__FAULT_INJECTION__, which activates the compile-time fault-injection
-     * layer (faultInjection.h) at the profiler's memory-access sites. Opt-in
-     * only (see setupStandardConfigurations); never shipped in production.
-     */
-    fun configureFaultInjection(
-        config: BuildConfiguration,
-        platform: Platform,
-        architecture: Architecture,
-        version: String
-    ) {
-        configureRelease(config, platform, architecture, version)
-        config.compilerArgs.add("-D__FAULT_INJECTION__")
-    }
-
     fun configureDebug(
         config: BuildConfiguration,
         platform: Platform,

ddprof-lib/src/main/cpp/counters.h

@@ -124,7 +124,11 @@
    * paths (delegated and direct) go into SAMPLES_DROPPED_REC_LOCK. */         \
   X(JVMTI_STACKS_DROPPED_LOCK, "jvmti_stacks_dropped_lock")                   \
   X(SAMPLES_DROPPED_REC_LOCK, "samples_dropped_rec_lock")                     \
-  X(SAMPLES_DROPPED_THREAD_LOCAL, "samples_dropped_thread_local")
+  X(SAMPLES_DROPPED_THREAD_LOCAL, "samples_dropped_thread_local")             \
+  X(SAFECOPY_FAILED, "safecopy_failed")                                       \
+  X(SAFEFETCH_FAILED, "safefetch_failed")                                     \
+  X(FAULTS_INJECTED, "faults_injected")                                       \
+  X(WALKVM_LONGJMP_RECOVERED, "walkvm_longjmp_recovered")
 #define X_ENUM(a, b) a,
 typedef enum CounterId : int {
   DD_COUNTER_TABLE(X_ENUM) DD_NUM_COUNTERS

ddprof-lib/src/main/cpp/faultInjection.cpp

@@ -20,6 +20,7 @@
 // normal build links a no-op object file.
 #ifdef __FAULT_INJECTION__
 
+#include "counters.h"          // Counters::increment (FAULTS_INJECTED)
 #include "os.h"                // OS::page_size
 #include "threadLocalData.h"   // ProfiledThread::currentSignalSafe / nextFiRandom
 #include <atomic>
@@ -78,7 +79,13 @@ bool shouldFire(u64 threshold, const char* fn) {
   // stream per call site while keeping the fire probability exactly
   // threshold/2^64.
   u64 r = nextRandom() ^ ((u64)(uintptr_t)fn * KNUTH);
-  return r < threshold;
+  if (__builtin_expect(r < threshold, 0)) {
+    // Every address/int/long injection routes through here, so this is the one
+    // place that counts an actually-injected fault.
+    Counters::increment(FAULTS_INJECTED);
+    return true;
+  }
+  return false;
 }
 
 uintptr_t poisonAddress() {

ddprof-lib/src/main/cpp/hotspot/hotspotSupport.cpp

@@ -970,6 +970,7 @@ void HotspotSupport::checkFault(ProfiledThread* thrd) {
     }
 
     thrd->resetCrashHandler();
+    Counters::increment(WALKVM_LONGJMP_RECOVERED);
     longjmp(*thrd->getJmpCtx(), 1);
 }
 

ddprof-lib/src/main/cpp/safeAccess.cpp

@@ -16,8 +16,7 @@
 
 
 #include "safeAccess.h"
-#include <cstdio>
-#include <cstdlib>
+#include "counters.h"
 #include <signal.h>
 #include <ucontext.h>
 
@@ -280,14 +279,17 @@ bool SafeAccess::handle_safefetch(int sig, void* context) {
   if ((sig == SIGSEGV || sig == SIGBUS) && uc != nullptr) {
     if (pc == (uintptr_t)safefetch32_impl) {
       uc->current_pc = (uintptr_t)safefetch32_cont;
+      Counters::increment(SAFEFETCH_FAILED);
       return true;
     } else if (pc == (uintptr_t)safefetch64_impl) {
       uc->current_pc = (uintptr_t)safefetch64_cont;
+      Counters::increment(SAFEFETCH_FAILED);
       return true;
     } else if (pc >= (uintptr_t)safecopy_impl && pc < (uintptr_t)safecopy_cont) {
       // Unlike safefetch, the faulting load can be at any pc inside the copy
       // loop, so match the whole [safecopy_impl, safecopy_cont) range.
       uc->current_pc = (uintptr_t)safecopy_cont;
+      Counters::increment(SAFECOPY_FAILED);
       return true;
     }
   }