ddtrace 1.7.0 → 1.8.0

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.c

@@ -50,6 +50,100 @@ rb_nativethread_id_t pthread_id_for(VALUE thread) {
   #endif
 }
 
+// Queries if the current thread is the owner of the global VM lock.
+//
+// @ivoanjo: Ruby has a similarly-named `ruby_thread_has_gvl_p` but that API is insufficient for our needs because it can
+// still return `true` even when a thread DOES NOT HAVE the global VM lock.
+// In particular, looking at the implementation, that API assumes that if a thread is not in a "blocking region" then it
+// will have the GVL which is probably true for the situations that API was designed to be called from BUT this assumption
+// does not hold true when calling `ruby_thread_has_gvl_p` from a signal handler. (Because the thread may have lost the
+// GVL due to a scheduler decision, not because it decided to block.)
+// I have also submitted https://bugs.ruby-lang.org/issues/19172 to discuss this with upstream Ruby developers.
+//
+// Thus we need our own gvl-checking method which actually looks at the gvl structure to determine if it is the owner.
+bool is_current_thread_holding_the_gvl(void) {
+  current_gvl_owner owner = gvl_owner();
+  return owner.valid && pthread_equal(pthread_self(), owner.owner);
+}
+
+#ifndef NO_GVL_OWNER // Ruby < 2.6 doesn't have the owner/running field
+  // NOTE: Reading the owner in this is a racy read, because we're not grabbing the lock that Ruby uses to protect it.
+  //
+  // While we could potentially grab this lock, I (@ivoanjo) think we actually don't need it because:
+  // * In the case where a thread owns the GVL and calls `gvl_owner`, it will always see the correct value. That's
+  //   because every thread sets itself as the owner when it grabs the GVL and unsets itself at the end.
+  //   That means that `is_current_thread_holding_the_gvl` is always accurate.
+  // * In a case where we observe a different thread, then this may change by the time we do something with this value
+  //   anyway. So unless we want to prevent the Ruby scheduler from switching threads, we need to deal with races here.
+  current_gvl_owner gvl_owner(void) {
+    const rb_thread_t *current_owner =
+      #ifndef NO_RB_THREAD_SCHED // Introduced in Ruby 3.2 as a replacement for struct rb_global_vm_lock_struct
+        GET_RACTOR()->threads.sched.running;
+      #elif HAVE_RUBY_RACTOR_H
+        GET_RACTOR()->threads.gvl.owner;
+      #else
+        GET_VM()->gvl.owner;
+      #endif
+
+    if (current_owner == NULL) return (current_gvl_owner) {.valid = false};
+
+    return (current_gvl_owner) {
+      .valid = true,
+      .owner =
+        #ifndef NO_RB_NATIVE_THREAD
+          current_owner->nt->thread_id
+        #else
+          current_owner->thread_id
+        #endif
+    };
+  }
+#else
+  current_gvl_owner gvl_owner(void) {
+    rb_vm_t *vm =
+      #ifndef NO_GET_VM
+        GET_VM();
+      #else
+        thread_struct_from_object(rb_thread_current())->vm;
+      #endif
+
+    // BIG Issue: Ruby < 2.6 did not have the owner field. The really nice thing about the owner field is that it's
+    // "atomic" -- when a thread sets it, it "declares" two things in a single step
+    // * Declaration 1: Someone has the GVL
+    // * Declaration 2: That someone is the specific thread
+    //
+    // Observation 1: On older versions of Ruby, this ownership concept is actually split. Specifically, `gvl.acquired`
+    // is a boolean that represents declaration 1 above, and `vm->running_thread` (or `ruby_current_thread`/
+    // `ruby_current_execution_context_ptr`) represents declaration 2.
+    //
+    // Observation 2: In addition, when a thread releases the GVL, it only sets `gvl.acquired` back to 0 **BUT CRUCIALLY
+    // DOES NOT CHANGE THE OTHER global variables**.
+    //
+    // Observation 1+2 above lead to the following possible race:
+    // * Thread A grabs the GVL (`gvl.acquired == 1`)
+    // * Thread A sets `running_thread` (`gvl.acquired == 1` + `running_thread == Thread A`)
+    // * Thread A releases the GVL (`gvl.acquired == 0` + `running_thread == Thread A`)
+    // * Thread B grabs the GVL (`gvl.acquired == 1` + `running_thread == Thread A`)
+    // * Thread A calls gvl_owner. Due to the current state (`gvl.acquired == 1` + `running_thread == Thread A`), this
+    //   function returns an incorrect result.
+    // * Thread B finally sets `running_thread` (`gvl.acquired == 1` + `running_thread == Thread B`)
+    //
+    // This is especially problematic because we use `gvl_owner` to implement `is_current_thread_holding_the_gvl` which
+    // is called in a signal handler to decide "is it safe for me to call `rb_postponed_job_register_one` or not".
+    // (See constraints in `collectors_cpu_and_wall_time_worker.c` comments for why).
+    //
+    // Thus an incorrect `is_current_thread_holding_the_gvl` result may lead to issues inside `rb_postponed_job_register_one`.
+    //
+    // For this reason we currently do not enable the new Ruby profiler on Ruby 2.5 and below by default, and we print a
+    // warning when customers force-enable it.
+    bool gvl_acquired = vm->gvl.acquired != 0;
+    rb_thread_t *current_owner = vm->running_thread;
+
+    if (!gvl_acquired || current_owner == NULL) return (current_gvl_owner) {.valid = false};
+
+    return (current_gvl_owner) {.valid = true, .owner = current_owner->thread_id};
+  }
+#endif // NO_GVL_OWNER
+
 // Taken from upstream vm_core.h at commit d9cf0388599a3234b9f3c06ddd006cd59a58ab8b (November 2022, Ruby 3.2 trunk)
 // Copyright (C) 2004-2007 Koichi Sasada
 // to support tid_for (see below)
@@ -128,7 +222,12 @@ VALUE ddtrace_thread_list(void) {
     rb_ractor_t *current_ractor = GET_RACTOR();
     ccan_list_for_each(&current_ractor->threads.set, thread, lt_node) {
   #else
-    rb_vm_t *vm = thread_struct_from_object(rb_thread_current())->vm;
+    rb_vm_t *vm =
+      #ifndef NO_GET_VM
+        GET_VM();
+      #else
+        thread_struct_from_object(rb_thread_current())->vm;
+      #endif
     list_for_each(&vm->living_threads, thread, vmlt_node) {
   #endif
       switch (thread->status) {
@@ -284,9 +383,6 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 // * Add `end_cfp == NULL` and `end_cfp <= cfp` safety checks. These are used in a bunch of places in
 //   `vm_backtrace.c` (`backtrace_each`, `backtrace_size`, `rb_ec_partial_backtrace_object`) but are conspicuously
 //   absent from `rb_profile_frames`. Oversight?
-// * Distinguish between `end_cfp == NULL` (dead thread or some other error, returns 0) and `end_cfp <= cfp`
-//   (alive thread which may just be executing native code and has not pushed anything on the Ruby stack, returns
-//   PLACEHOLDER_STACK_IN_NATIVE_CODE). See comments on `record_placeholder_stack_in_native_code` for more details.
 // * Skip frames where `cfp->iseq && !cfp->pc`. These seem to be internal and are skipped by `backtrace_each` in
 //   `vm_backtrace.c`.
 // * Check thread status and do not sample if thread has been killed.
@@ -340,13 +436,13 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
     const rb_control_frame_t *cfp = ec->cfp, *end_cfp = RUBY_VM_END_CONTROL_FRAME(ec);
     const rb_callable_method_entry_t *cme;
 
-    // `vm_backtrace.c` includes this check in several methods, and I think this happens on either dead or newly-created
-    // threads, but I'm not entirely sure
-    if (end_cfp == NULL) return 0;
-
     // Avoid sampling dead threads
     if (th->status == THREAD_KILLED) return 0;
 
+    // `vm_backtrace.c` includes this check in several methods. This happens on newly-created threads, and may
+    // also (not entirely sure) happen on dead threads
+    if (end_cfp == NULL) return PLACEHOLDER_STACK_IN_NATIVE_CODE;
+
     // Fix: Skip dummy frame that shows up in main thread.
     //
     // According to a comment in `backtrace_each` (`vm_backtrace.c`), there's two dummy frames that we should ignore
@@ -650,9 +746,6 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 // * Add `end_cfp == NULL` and `end_cfp <= cfp` safety checks. These are used in a bunch of places in
 //   `vm_backtrace.c` (`backtrace_each`, `backtrace_size`, `rb_ec_partial_backtrace_object`) but are conspicuously
 //   absent from `rb_profile_frames`. Oversight?
-// * Distinguish between `end_cfp == NULL` (dead thread or some other error, returns 0) and `end_cfp <= cfp`
-//   (alive thread which may just be executing native code and has not pushed anything on the Ruby stack, returns
-//   PLACEHOLDER_STACK_IN_NATIVE_CODE). See comments on `record_placeholder_stack_in_native_code` for more details.
 // * Check thread status and do not sample if thread has been killed.
 //
 // The `rb_profile_frames` function changed quite a bit between Ruby 2.2 and 2.3. Since the change was quite complex
@@ -667,13 +760,13 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
     rb_thread_t *th = thread_struct_from_object(thread);
     rb_control_frame_t *cfp = th->cfp, *end_cfp = RUBY_VM_END_CONTROL_FRAME(th);
 
-    // `vm_backtrace.c` includes this check in several methods, and I think this happens on either dead or newly-created
-    // threads, but I'm not entirely sure
-    if (end_cfp == NULL) return 0;
-
     // Avoid sampling dead threads
     if (th->status == THREAD_KILLED) return 0;
 
+    // `vm_backtrace.c` includes this check in several methods. This happens on newly-created threads, and may
+    // also (not entirely sure) happen on dead threads
+    if (end_cfp == NULL) return PLACEHOLDER_STACK_IN_NATIVE_CODE;
+
     // Fix: Skip dummy frame that shows up in main thread.
     //
     // According to a comment in `backtrace_each` (`vm_backtrace.c`), there's two dummy frames that we should ignore
@@ -717,15 +810,6 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
 
 #endif // USE_LEGACY_RB_PROFILE_FRAMES
 
-#ifdef NO_THREAD_HAS_GVL
-int ruby_thread_has_gvl_p(void) {
-  // TODO: The CpuAndWallTimeWorker needs this function, but Ruby 2.2 doesn't expose it... For now this placeholder
-  // will enable the profiling native extension to continue to compile on Ruby 2.2, but the CpuAndWallTimeWorker will
-  // not work properly on 2.2. Will be addressed later.
-  return 0;
-}
-#endif // NO_THREAD_HAS_GVL
-
 #ifndef NO_RACTORS
   // This API and definition are exported as a public symbol by the VM BUT the function header is not defined in any public header, so we
   // repeat it here to be able to use in our code.

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.h

@@ -7,11 +7,20 @@
 // without also dragging the incompatible includes
 #ifndef PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES
   #include <ruby/thread_native.h>
+  #include <ruby/vm.h>
 #endif
 
 #include "extconf.h"
 
+// Contains the current gvl owner, and a flag to indicate if it is valid
+typedef struct {
+  bool valid;
+  rb_nativethread_id_t owner;
+} current_gvl_owner;
+
 rb_nativethread_id_t pthread_id_for(VALUE thread);
+bool is_current_thread_holding_the_gvl(void);
+current_gvl_owner gvl_owner(void);
 uint64_t native_thread_id_for(VALUE thread);
 ptrdiff_t stack_depth_for(VALUE thread);
 VALUE ddtrace_thread_list(void);

data/ext/ddtrace_profiling_native_extension/profiling.c

@@ -1,18 +1,37 @@
 #include <ruby.h>
+#include <ruby/thread.h>
+#include <errno.h>
 
 #include "clock_id.h"
 #include "helpers.h"
 #include "private_vm_api_access.h"
+#include "ruby_helpers.h"
+#include "setup_signal_handler.h"
+#include "time_helpers.h"
 
 // Each class/module here is implemented in their separate file
 void collectors_cpu_and_wall_time_init(VALUE profiling_module);
 void collectors_cpu_and_wall_time_worker_init(VALUE profiling_module);
+void collectors_dynamic_sampling_rate_init(VALUE profiling_module);
+void collectors_idle_sampling_helper_init(VALUE profiling_module);
 void collectors_stack_init(VALUE profiling_module);
 void http_transport_init(VALUE profiling_module);
 void stack_recorder_init(VALUE profiling_module);
 
 static VALUE native_working_p(VALUE self);
+static VALUE _native_grab_gvl_and_raise(DDTRACE_UNUSED VALUE _self, VALUE exception_class, VALUE test_message, VALUE test_message_arg, VALUE release_gvl);
+static void *trigger_grab_gvl_and_raise(void *trigger_args);
+static VALUE _native_grab_gvl_and_raise_syserr(DDTRACE_UNUSED VALUE _self, VALUE syserr_errno, VALUE test_message, VALUE test_message_arg, VALUE release_gvl);
+static void *trigger_grab_gvl_and_raise_syserr(void *trigger_args);
 static VALUE _native_ddtrace_rb_ractor_main_p(DDTRACE_UNUSED VALUE _self);
+static VALUE _native_is_current_thread_holding_the_gvl(DDTRACE_UNUSED VALUE _self);
+static VALUE _native_release_gvl_and_call_is_current_thread_holding_the_gvl(DDTRACE_UNUSED VALUE _self);
+static void *testing_is_current_thread_holding_the_gvl(DDTRACE_UNUSED void *_unused);
+static VALUE _native_install_holding_the_gvl_signal_handler(DDTRACE_UNUSED VALUE _self);
+static void holding_the_gvl_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext);
+static VALUE _native_trigger_holding_the_gvl_signal_handler_on(DDTRACE_UNUSED VALUE _self, VALUE background_thread);
+static VALUE _native_enforce_success(DDTRACE_UNUSED VALUE _self, VALUE syserr_errno, VALUE with_gvl);
+static void *trigger_enforce_success(void *trigger_args);
 
 void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
   VALUE datadog_module = rb_define_module("Datadog");
@@ -26,13 +45,27 @@ void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
 
   collectors_cpu_and_wall_time_init(profiling_module);
   collectors_cpu_and_wall_time_worker_init(profiling_module);
+  collectors_dynamic_sampling_rate_init(profiling_module);
+  collectors_idle_sampling_helper_init(profiling_module);
   collectors_stack_init(profiling_module);
   http_transport_init(profiling_module);
   stack_recorder_init(profiling_module);
 
   // Hosts methods used for testing the native code using RSpec
   VALUE testing_module = rb_define_module_under(native_extension_module, "Testing");
+  rb_define_singleton_method(testing_module, "_native_grab_gvl_and_raise", _native_grab_gvl_and_raise, 4);
+  rb_define_singleton_method(testing_module, "_native_grab_gvl_and_raise_syserr", _native_grab_gvl_and_raise_syserr, 4);
   rb_define_singleton_method(testing_module, "_native_ddtrace_rb_ractor_main_p", _native_ddtrace_rb_ractor_main_p, 0);
+  rb_define_singleton_method(testing_module, "_native_is_current_thread_holding_the_gvl", _native_is_current_thread_holding_the_gvl, 0);
+  rb_define_singleton_method(
+    testing_module,
+    "_native_release_gvl_and_call_is_current_thread_holding_the_gvl",
+    _native_release_gvl_and_call_is_current_thread_holding_the_gvl,
+    0
+  );
+  rb_define_singleton_method(testing_module, "_native_install_holding_the_gvl_signal_handler", _native_install_holding_the_gvl_signal_handler, 0);
+  rb_define_singleton_method(testing_module, "_native_trigger_holding_the_gvl_signal_handler_on", _native_trigger_holding_the_gvl_signal_handler_on, 1);
+  rb_define_singleton_method(testing_module, "_native_enforce_success", _native_enforce_success, 2);
 }
 
 static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
@@ -41,6 +74,178 @@ static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
   return Qtrue;
 }
 
+struct trigger_grab_gvl_and_raise_arguments {
+  VALUE exception_class;
+  char *test_message;
+  int test_message_arg;
+};
+
+static VALUE _native_grab_gvl_and_raise(DDTRACE_UNUSED VALUE _self, VALUE exception_class, VALUE test_message, VALUE test_message_arg, VALUE release_gvl) {
+  ENFORCE_TYPE(test_message, T_STRING);
+
+  struct trigger_grab_gvl_and_raise_arguments args;
+
+  args.exception_class = exception_class;
+  args.test_message = StringValueCStr(test_message);
+  args.test_message_arg = test_message_arg != Qnil ? NUM2INT(test_message_arg) : -1;
+
+  if (RTEST(release_gvl)) {
+    rb_thread_call_without_gvl(trigger_grab_gvl_and_raise, &args, NULL, NULL);
+  } else {
+    grab_gvl_and_raise(args.exception_class, "%s", args.test_message);
+  }
+
+  rb_raise(rb_eRuntimeError, "Failed to raise exception in _native_grab_gvl_and_raise; this should never happen");
+}
+
+static void *trigger_grab_gvl_and_raise(void *trigger_args) {
+  struct trigger_grab_gvl_and_raise_arguments *args = (struct trigger_grab_gvl_and_raise_arguments *) trigger_args;
+
+  if (args->test_message_arg >= 0) {
+    grab_gvl_and_raise(args->exception_class, "%s%d", args->test_message, args->test_message_arg);
+  } else {
+    grab_gvl_and_raise(args->exception_class, "%s", args->test_message);
+  }
+
+  return NULL;
+}
+
+struct trigger_grab_gvl_and_raise_syserr_arguments {
+  int syserr_errno;
+  char *test_message;
+  int test_message_arg;
+};
+
+static VALUE _native_grab_gvl_and_raise_syserr(DDTRACE_UNUSED VALUE _self, VALUE syserr_errno, VALUE test_message, VALUE test_message_arg, VALUE release_gvl) {
+  ENFORCE_TYPE(test_message, T_STRING);
+
+  struct trigger_grab_gvl_and_raise_syserr_arguments args;
+
+  args.syserr_errno = NUM2INT(syserr_errno);
+  args.test_message = StringValueCStr(test_message);
+  args.test_message_arg = test_message_arg != Qnil ? NUM2INT(test_message_arg) : -1;
+
+  if (RTEST(release_gvl)) {
+    rb_thread_call_without_gvl(trigger_grab_gvl_and_raise_syserr, &args, NULL, NULL);
+  } else {
+    grab_gvl_and_raise_syserr(args.syserr_errno, "%s", args.test_message);
+  }
+
+  rb_raise(rb_eRuntimeError, "Failed to raise exception in _native_grab_gvl_and_raise_syserr; this should never happen");
+}
+
+static void *trigger_grab_gvl_and_raise_syserr(void *trigger_args) {
+  struct trigger_grab_gvl_and_raise_syserr_arguments *args = (struct trigger_grab_gvl_and_raise_syserr_arguments *) trigger_args;
+
+  if (args->test_message_arg >= 0) {
+    grab_gvl_and_raise_syserr(args->syserr_errno, "%s%d", args->test_message, args->test_message_arg);
+  } else {
+    grab_gvl_and_raise_syserr(args->syserr_errno, "%s", args->test_message);
+  }
+
+  return NULL;
+}
+
 static VALUE _native_ddtrace_rb_ractor_main_p(DDTRACE_UNUSED VALUE _self) {
   return ddtrace_rb_ractor_main_p() ? Qtrue : Qfalse;
 }
+
+static VALUE _native_is_current_thread_holding_the_gvl(DDTRACE_UNUSED VALUE _self) {
+  return ((bool) testing_is_current_thread_holding_the_gvl(NULL)) ? Qtrue : Qfalse;
+}
+
+static VALUE _native_release_gvl_and_call_is_current_thread_holding_the_gvl(DDTRACE_UNUSED VALUE _self) {
+  return ((bool) rb_thread_call_without_gvl(testing_is_current_thread_holding_the_gvl, NULL, NULL, NULL)) ? Qtrue : Qfalse;
+}
+
+static void *testing_is_current_thread_holding_the_gvl(DDTRACE_UNUSED void *_unused) {
+  return (void *) is_current_thread_holding_the_gvl();
+}
+
+static VALUE _native_install_holding_the_gvl_signal_handler(DDTRACE_UNUSED VALUE _self) {
+  install_sigprof_signal_handler(holding_the_gvl_signal_handler, "holding_the_gvl_signal_handler");
+  return Qtrue;
+}
+
+static pthread_mutex_t holding_the_gvl_signal_handler_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t holding_the_gvl_signal_handler_executed = PTHREAD_COND_INITIALIZER;
+static VALUE holding_the_gvl_signal_handler_result[3];
+
+// Ruby VM API that is exported but not present in the header files. Only used by holding_the_gvl_signal_handler below and SHOULD NOT
+// be used in any other situation. See the comments on is_current_thread_holding_the_gvl for details.
+int ruby_thread_has_gvl_p(void);
+
+static void holding_the_gvl_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext) {
+  pthread_mutex_lock(&holding_the_gvl_signal_handler_mutex);
+
+  VALUE test_executed = Qtrue;
+  VALUE ruby_thread_has_gvl_p_result = ruby_thread_has_gvl_p() ? Qtrue : Qfalse;
+  VALUE is_current_thread_holding_the_gvl_result = is_current_thread_holding_the_gvl() ? Qtrue : Qfalse;
+
+  holding_the_gvl_signal_handler_result[0] = test_executed;
+  holding_the_gvl_signal_handler_result[1] = ruby_thread_has_gvl_p_result;
+  holding_the_gvl_signal_handler_result[2] = is_current_thread_holding_the_gvl_result;
+
+  pthread_cond_broadcast(&holding_the_gvl_signal_handler_executed);
+  pthread_mutex_unlock(&holding_the_gvl_signal_handler_mutex);
+}
+
+static VALUE _native_trigger_holding_the_gvl_signal_handler_on(DDTRACE_UNUSED VALUE _self, VALUE background_thread) {
+  holding_the_gvl_signal_handler_result[0] = Qfalse;
+  holding_the_gvl_signal_handler_result[1] = Qfalse;
+  holding_the_gvl_signal_handler_result[2] = Qfalse;
+
+  rb_nativethread_id_t thread = pthread_id_for(background_thread);
+
+  ENFORCE_SUCCESS_GVL(pthread_mutex_lock(&holding_the_gvl_signal_handler_mutex));
+
+  // We keep trying for ~5 seconds (500 x 10ms) to try to avoid any flakiness if the test machine is a bit slow
+  for (int tries = 0; holding_the_gvl_signal_handler_result[0] == Qfalse && tries < 500; tries++) {
+    pthread_kill(thread, SIGPROF);
+
+    // pthread_cond_timedwait is simply awful -- the deadline is based on wall-clock using a struct timespec, so we need
+    // all of the below complexity just to tell it "timeout is 10ms". The % limit dance below is needed because the
+    // `tv_nsec` part of a timespec can't go over the limit.
+    struct timespec deadline;
+    clock_gettime(CLOCK_REALTIME, &deadline);
+
+    unsigned int timeout_ns = MILLIS_AS_NS(10);
+    unsigned int tv_nsec_limit = SECONDS_AS_NS(1);
+    if ((deadline.tv_nsec + timeout_ns) < tv_nsec_limit) {
+      deadline.tv_nsec += timeout_ns;
+    } else {
+      deadline.tv_nsec = (deadline.tv_nsec + timeout_ns) % tv_nsec_limit;
+      deadline.tv_sec++;
+    }
+
+    int error = pthread_cond_timedwait(&holding_the_gvl_signal_handler_executed, &holding_the_gvl_signal_handler_mutex, &deadline);
+    if (error && error != ETIMEDOUT) ENFORCE_SUCCESS_GVL(error);
+  }
+
+  ENFORCE_SUCCESS_GVL(pthread_mutex_unlock(&holding_the_gvl_signal_handler_mutex));
+
+  replace_sigprof_signal_handler_with_empty_handler(holding_the_gvl_signal_handler);
+
+  if (holding_the_gvl_signal_handler_result[0] == Qfalse) rb_raise(rb_eRuntimeError, "Could not signal background_thread");
+
+  VALUE result = rb_hash_new();
+  rb_hash_aset(result, ID2SYM(rb_intern("ruby_thread_has_gvl_p")), holding_the_gvl_signal_handler_result[1]);
+  rb_hash_aset(result, ID2SYM(rb_intern("is_current_thread_holding_the_gvl")), holding_the_gvl_signal_handler_result[2]);
+  return result;
+}
+
+static VALUE _native_enforce_success(DDTRACE_UNUSED VALUE _self, VALUE syserr_errno, VALUE with_gvl) {
+  if (RTEST(with_gvl)) {
+    ENFORCE_SUCCESS_GVL(NUM2INT(syserr_errno));
+  } else {
+    rb_thread_call_without_gvl(trigger_enforce_success, (void *) (intptr_t) NUM2INT(syserr_errno), NULL, NULL);
+  }
+
+  return Qtrue;
+}
+
+static void *trigger_enforce_success(void *trigger_args) {
+  intptr_t syserr_errno = (intptr_t) trigger_args;
+  ENFORCE_SUCCESS_NO_GVL(syserr_errno);
+  return NULL;
+}

data/ext/ddtrace_profiling_native_extension/ruby_helpers.c

@@ -1,4 +1,8 @@
+#include <ruby.h>
+#include <ruby/thread.h>
+
 #include "ruby_helpers.h"
+#include "private_vm_api_access.h"
 
 void raise_unexpected_type(
   VALUE value,
@@ -22,3 +26,85 @@ void raise_unexpected_type(
     )
   );
 }
+
+#define MAX_RAISE_MESSAGE_SIZE 256
+
+struct raise_arguments {
+  VALUE exception_class;
+  char exception_message[MAX_RAISE_MESSAGE_SIZE];
+};
+
+static void *trigger_raise(void *raise_arguments) {
+  struct raise_arguments *args = (struct raise_arguments *) raise_arguments;
+  rb_raise(args->exception_class, "%s", args->exception_message);
+}
+
+void grab_gvl_and_raise(VALUE exception_class, const char *format_string, ...) {
+  struct raise_arguments args;
+
+  args.exception_class = exception_class;
+
+  va_list format_string_arguments;
+  va_start(format_string_arguments, format_string);
+  vsnprintf(args.exception_message, MAX_RAISE_MESSAGE_SIZE, format_string, format_string_arguments);
+
+  if (is_current_thread_holding_the_gvl()) {
+    rb_raise(
+      rb_eRuntimeError,
+      "grab_gvl_and_raise called by thread holding the global VM lock. exception_message: '%s'",
+      args.exception_message
+    );
+  }
+
+  rb_thread_call_with_gvl(trigger_raise, &args);
+
+  rb_bug("[DDTRACE] Unexpected: Reached the end of grab_gvl_and_raise while raising '%s'\n", args.exception_message);
+}
+
+struct syserr_raise_arguments {
+  int syserr_errno;
+  char exception_message[MAX_RAISE_MESSAGE_SIZE];
+};
+
+static void *trigger_syserr_raise(void *syserr_raise_arguments) {
+  struct syserr_raise_arguments *args = (struct syserr_raise_arguments *) syserr_raise_arguments;
+  rb_syserr_fail(args->syserr_errno, args->exception_message);
+}
+
+void grab_gvl_and_raise_syserr(int syserr_errno, const char *format_string, ...) {
+  struct syserr_raise_arguments args;
+
+  args.syserr_errno = syserr_errno;
+
+  va_list format_string_arguments;
+  va_start(format_string_arguments, format_string);
+  vsnprintf(args.exception_message, MAX_RAISE_MESSAGE_SIZE, format_string, format_string_arguments);
+
+  if (is_current_thread_holding_the_gvl()) {
+    rb_raise(
+      rb_eRuntimeError,
+      "grab_gvl_and_raise_syserr called by thread holding the global VM lock. syserr_errno: %d, exception_message: '%s'",
+      syserr_errno,
+      args.exception_message
+    );
+  }
+
+  rb_thread_call_with_gvl(trigger_syserr_raise, &args);
+
+  rb_bug("[DDTRACE] Unexpected: Reached the end of grab_gvl_and_raise_syserr while raising '%s'\n", args.exception_message);
+}
+
+void raise_syserr(
+  int syserr_errno,
+  bool have_gvl,
+  const char *expression,
+  const char *file,
+  int line,
+  const char *function_name
+) {
+  if (have_gvl) {
+    rb_exc_raise(rb_syserr_new_str(syserr_errno, rb_sprintf("Failure returned by '%s' at %s:%d:in `%s'", expression, file, line, function_name)));
+  } else {
+    grab_gvl_and_raise_syserr(syserr_errno, "Failure returned by '%s' at %s:%d:in `%s'", expression, file, line, function_name);
+  }
+}

data/ext/ddtrace_profiling_native_extension/ruby_helpers.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <ruby.h>
+#include <stdbool.h>
 
 #include "helpers.h"
 
@@ -57,11 +58,32 @@ NORETURN(void raise_unexpected_type(
   const char *type_name,
   const char *file,
   int line,
-  const char* function_name
+  const char *function_name
 ));
 
-// This API is exported as a public symbol by the VM BUT the function header is not defined in any public header, so we
-// repeat it here to be able to use in our code.
-//
-// Queries if the current thread is the owner of the global VM lock.
-int ruby_thread_has_gvl_p(void);
+#define VALUE_COUNT(array) (sizeof(array) / sizeof(VALUE))
+
+NORETURN(
+  void grab_gvl_and_raise(VALUE exception_class, const char *format_string, ...)
+  __attribute__ ((format (printf, 2, 3)));
+);
+NORETURN(
+  void grab_gvl_and_raise_syserr(int syserr_errno, const char *format_string, ...)
+  __attribute__ ((format (printf, 2, 3)));
+);
+
+#define ENFORCE_SUCCESS_GVL(expression) ENFORCE_SUCCESS_HELPER(expression, true)
+#define ENFORCE_SUCCESS_NO_GVL(expression) ENFORCE_SUCCESS_HELPER(expression, false)
+
+#define ENFORCE_SUCCESS_HELPER(expression, have_gvl) \
+  { int result_syserr_errno = expression; if (RB_UNLIKELY(result_syserr_errno)) raise_syserr(result_syserr_errno, have_gvl, ADD_QUOTES(expression), __FILE__, __LINE__, __func__); }
+
+// Called by ENFORCE_SUCCESS_HELPER; should not be used directly
+NORETURN(void raise_syserr(
+  int syserr_errno,
+  bool have_gvl,
+  const char *expression,
+  const char *file,
+  int line,
+  const char *function_name
+));

data/ext/ddtrace_profiling_native_extension/setup_signal_handler.c

@@ -5,6 +5,9 @@
 
 #include "helpers.h"
 #include "setup_signal_handler.h"
+#include "ruby_helpers.h"
+
+// Used by Collectors::CpuAndWallTimeWorker to setup SIGPROF signal handlers used for cpu/wall-time profiling.
 
 static void install_sigprof_signal_handler_internal(
   void (*signal_handler_function)(int, siginfo_t *, void *),
@@ -88,9 +91,25 @@ void remove_sigprof_signal_handler(void) {
   if (sigaction(SIGPROF, &signal_handler_config, NULL) != 0) rb_sys_fail("Failure while removing the signal handler");
 }
 
+static void toggle_sigprof_signal_handler_for_current_thread(int action) {
+  sigset_t signals_to_toggle;
+  sigemptyset(&signals_to_toggle);
+  sigaddset(&signals_to_toggle, SIGPROF);
+  int error = pthread_sigmask(action, &signals_to_toggle, NULL);
+  if (error) rb_exc_raise(rb_syserr_new_str(error, rb_sprintf("Unexpected failure in pthread_sigmask, action=%d", action)));
+}
+
 void block_sigprof_signal_handler_from_running_in_current_thread(void) {
-  sigset_t signals_to_block;
-  sigemptyset(&signals_to_block);
-  sigaddset(&signals_to_block, SIGPROF);
-  pthread_sigmask(SIG_BLOCK, &signals_to_block, NULL);
+  toggle_sigprof_signal_handler_for_current_thread(SIG_BLOCK);
+}
+
+void unblock_sigprof_signal_handler_from_running_in_current_thread(void) {
+  toggle_sigprof_signal_handler_for_current_thread(SIG_UNBLOCK);
+}
+
+VALUE is_sigprof_blocked_in_current_thread(void) {
+  sigset_t current_signals;
+  sigemptyset(&current_signals);
+  ENFORCE_SUCCESS_GVL(pthread_sigmask(0, NULL, &current_signals));
+  return sigismember(&current_signals, SIGPROF) ? Qtrue : Qfalse;
 }

data/ext/ddtrace_profiling_native_extension/setup_signal_handler.h

@@ -1,7 +1,11 @@
 #pragma once
 
+#include <signal.h>
+
 void empty_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext);
 void install_sigprof_signal_handler(void (*signal_handler_function)(int, siginfo_t *, void *), const char *handler_pretty_name);
 void replace_sigprof_signal_handler_with_empty_handler(void (*expected_existing_handler)(int, siginfo_t *, void *));
 void remove_sigprof_signal_handler(void);
 void block_sigprof_signal_handler_from_running_in_current_thread(void);
+void unblock_sigprof_signal_handler_from_running_in_current_thread(void);
+VALUE is_sigprof_blocked_in_current_thread(void);