datadog 2.43.0 → 2.45.0

data/ext/datadog_profiling_native_extension/collectors_idle_sampling_helper.c

@@ -22,24 +22,24 @@
 typedef enum { ACTION_WAIT, ACTION_RUN, ACTION_STOP } action;
 
 // Contains state for a single CpuAndWallTimeWorker instance
-typedef struct {
+struct idle_sampling_loop_state {
   pthread_mutex_t wakeup_mutex;
   pthread_cond_t wakeup;
   action requested_action;
   void (*run_action_function)(void);
-} idle_sampling_loop_state;
+};
 
 static VALUE _native_new(VALUE klass);
 static void reset_state(idle_sampling_loop_state *state);
-static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE thread_context_collector_instance);
+static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE cpu_and_wall_time_worker_instance);
 static VALUE idle_sampling_loop_body(VALUE self_instance);
-static VALUE idle_sampling_loop_ensure(VALUE thread_context_collector_instance);
+static VALUE idle_sampling_loop_ensure(VALUE cpu_and_wall_time_worker_instance);
 static VALUE _native_stop(DDTRACE_UNUSED VALUE self, VALUE self_instance);
 static void *run_idle_sampling_loop(void *state_ptr);
 static void interrupt_idle_sampling_loop(void *state_ptr);
 static VALUE _native_reset(DDTRACE_UNUSED VALUE self, VALUE self_instance);
 static VALUE _native_idle_sampling_helper_request_action(DDTRACE_UNUSED VALUE self, VALUE self_instance);
-static void *request_testing_action(void *self_instance_ptr);
+static void *request_testing_action(void *state_ptr);
 static void grab_gvl_and_run_testing_action(void);
 static void *run_testing_action(DDTRACE_UNUSED void *unused);
 
@@ -112,8 +112,8 @@ static VALUE _native_reset(DDTRACE_UNUSED VALUE self, VALUE self_instance) {
   return Qtrue;
 }
 
-static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE thread_context_collector_instance) {
-  return rb_ensure(idle_sampling_loop_body, self_instance, idle_sampling_loop_ensure, thread_context_collector_instance);
+static VALUE _native_idle_sampling_loop(DDTRACE_UNUSED VALUE self, VALUE self_instance, VALUE cpu_and_wall_time_worker_instance) {
+  return rb_ensure(idle_sampling_loop_body, self_instance, idle_sampling_loop_ensure, cpu_and_wall_time_worker_instance);
 }
 
 static VALUE idle_sampling_loop_body(VALUE self_instance) {
@@ -128,9 +128,8 @@ static VALUE idle_sampling_loop_body(VALUE self_instance) {
   return Qtrue;
 }
 
-static VALUE idle_sampling_loop_ensure(VALUE thread_context_collector_instance) {
-  thread_context_collector_profiler_internal_thread_done(thread_context_collector_instance);
-  return Qnil;
+static VALUE idle_sampling_loop_ensure(VALUE cpu_and_wall_time_worker_instance) {
+  return rb_funcall(cpu_and_wall_time_worker_instance, rb_intern("_native_profiler_internal_thread_done"), 0);
 }
 
 static void *run_idle_sampling_loop(void *state_ptr) {
@@ -216,15 +215,14 @@ static VALUE _native_stop(DDTRACE_UNUSED VALUE self, VALUE self_instance) {
   return Qtrue;
 }
 
-// Assumption: Function gets called without the global VM lock
-void idle_sampling_helper_request_action(VALUE self_instance, void (*run_action_function)(void)) {
+idle_sampling_loop_state *idle_sampling_helper_get_state(VALUE self_instance) {
   idle_sampling_loop_state *state;
-  if (!rb_typeddata_is_kind_of(self_instance, &idle_sampling_helper_typed_data)) {
-    grab_gvl_and_raise(rb_eTypeError, "Wrong argument for idle_sampling_helper_request_action");
-  }
-  // This should never fail when the above check passes
   TypedData_Get_Struct(self_instance, idle_sampling_loop_state, &idle_sampling_helper_typed_data, state);
+  return state;
+}
 
+// Called without the GVL, so we access native state directly: touching the Ruby self_instance is unsafe during GC compaction.
+void idle_sampling_helper_request_action(idle_sampling_loop_state *state, void (*run_action_function)(void)) {
   ENFORCE_SUCCESS_NO_GVL(pthread_mutex_lock(&state->wakeup_mutex));
   if (state->requested_action == ACTION_WAIT) {
     state->requested_action = ACTION_RUN;
@@ -239,13 +237,14 @@ void idle_sampling_helper_request_action(VALUE self_instance, void (*run_action_
 // Because the idle_sampling_helper_request_action is built to be called without the global VM lock, here we release it
 // to be able to call that API.
 static VALUE _native_idle_sampling_helper_request_action(DDTRACE_UNUSED VALUE self, VALUE self_instance) {
-  rb_thread_call_without_gvl(request_testing_action, (void *) self_instance, NULL, NULL);
+  idle_sampling_loop_state *state = idle_sampling_helper_get_state(self_instance);
+  rb_thread_call_without_gvl(request_testing_action, state, NULL, NULL);
+  RB_GC_GUARD(self_instance);
   return Qtrue;
 }
 
-static void *request_testing_action(void *self_instance_ptr) {
-  VALUE self_instance = (VALUE) self_instance_ptr;
-  idle_sampling_helper_request_action(self_instance, grab_gvl_and_run_testing_action);
+static void *request_testing_action(void *state_ptr) {
+  idle_sampling_helper_request_action(state_ptr, grab_gvl_and_run_testing_action);
   return NULL;
 }
 

data/ext/datadog_profiling_native_extension/collectors_idle_sampling_helper.h

@@ -1,3 +1,7 @@
 #pragma once
 
-void idle_sampling_helper_request_action(VALUE self_instance, void (*run_action_function)(void));
+typedef struct idle_sampling_loop_state idle_sampling_loop_state;
+
+// Must be called with the GVL held; keep self_instance alive while using the returned pointer.
+idle_sampling_loop_state *idle_sampling_helper_get_state(VALUE self_instance);
+void idle_sampling_helper_request_action(idle_sampling_loop_state *state, void (*run_action_function)(void));

data/ext/datadog_profiling_native_extension/collectors_stack.c

@@ -641,9 +641,10 @@ void record_placeholder_stack(
   );
 }
 
+// Also called from a signal handler or during GC; check callers' safety requirements before changing this function.
 bool prepare_sample_thread(VALUE thread, sampling_buffer *buffer) {
-  // Since this can get called from inside a signal handler, we don't want to touch the buffer if
-  // the thread was actually in the middle of marking it.
+  // While the signal handler checks if there's GC going on, it's actually possible for `sampling_buffer_mark` to
+  // still run outside of GC (see comments on that function) and thus we guard for it here.
   if (buffer->is_marking) return false;
 
   buffer->pending_sample = true;
@@ -705,12 +706,11 @@ void sampling_buffer_mark(sampling_buffer *buffer) {
   }
 
   buffer->is_marking = true;
-  // Tell the compiler it's not allowed to reorder the `is_marking` flag with the iteration below.
-  //
-  // Specifically, in the middle of `sampling_buffer_mark` a signal handler may execute and call
-  // `prepare_sample_thread` to add a new sample to the buffer. This flag is here to prevent that BUT we need to
-  // make sure the signal handler actually sees the flag being set.
+  // The sampling buffer isn't supposed to be touched during GC. Yet, marking can happen outside of GC -- in particular
+  // ObjectSpace.dump/dump_all and reachable_objects_from invoke mark callbacks outside GC to enumerate references.
+  // Thus we keep this flag to tell the signal handler "hey you're still not allowed to touch the buffer at this time".
   //
+  // The fences ensure the compiler doesn't reorder the flags and a signal handler observes them
   // See https://github.com/ruby/ruby/pull/11036 for a similar change made to the Ruby VM with more context.
   atomic_signal_fence(memory_order_seq_cst);
 

data/ext/datadog_profiling_native_extension/collectors_stack.h

@@ -13,7 +13,7 @@ typedef struct {
   uint16_t max_frames;
   frame_info *stack_buffer;
   bool pending_sample;
-  bool is_marking; // Used to avoid recording a sample when marking
+  bool is_marking; // Used to avoid recording a sample when marking (marking can happen outside of GC as well)
   int pending_sample_result;
 } sampling_buffer;