feat(prof): detect parallel threads (#3515)

* Detect parallel threads by reading the TLS runtime pointer

* call public API function and fallback if not available

Author: realFlowControl

profiling/src/php_ffi.c

@@ -624,3 +624,83 @@ zval *ddog_php_prof_get_memoized_config(uint16_t config_id) {
 // dummy symbol for tests, so that they can be run without being linked into PHP
 __attribute__((weak)) zend_write_func_t zend_write;
 #endif
+
+/**
+ * Returns true if the thread was spawned by the parallel extension, false otherwise.
+ *
+ * This function is meant to be called in the GINIT phase of a PHP request, it is also safe to be
+ * called in RINIT or during request processing, but its outcome won't change anymore after GINIT.
+ * That being said, it being a costly function (module registry lookup, `dlsym()`,
+ * `__tls_get_addr()` in the fallback branch), the best usage pattern is to call this in GINIT and
+ * cache the result in a thread local.
+ */
+bool ddog_php_prof_is_parallel_thread() {
+    // Check if parallel extension is loaded to retrieve it's dl handle
+    zend_module_entry *parallel_module = zend_hash_str_find_ptr(&module_registry, ZEND_STRL("parallel"));
+
+    if (parallel_module == NULL || parallel_module->handle == NULL) {
+        return false;
+    }
+
+    // Try to find the new public API function first (available in parallel >= 1.2.9)
+    zend_bool (*is_worker)(void) = DL_FETCH_SYMBOL(parallel_module->handle, "php_parallel_is_parallel_worker_thread");
+    if (is_worker) {
+        return is_worker();
+    }
+
+    // Fallback: for older versions of parallel, we can access the TLS variable
+    // `php_parallel_scheduler_context` and do a NULL check.
+
+    // Why not just `__attribute__((weak)) php_parallel_scheduler_context;`?
+    // This would work if we could enforce the order of `dlopen()` calls for extensions (which we
+    // can't). If the parallel extension is loaded before the profiler extension it works just nice
+    // but if the profiler gets loaded first this will not resolve correct. Luckily `dlsym()`
+    // behaves as a safe wrapper around this.
+    void *tls_symbol = DL_FETCH_SYMBOL(parallel_module->handle, "php_parallel_scheduler_context");
+
+    if (tls_symbol == NULL) {
+        return false;
+    }
+
+    void **tls_ptr;
+#ifdef __APPLE__
+    // On macOS TLS variables accessed via dlsym return a descriptor structure containing a
+    // function pointer (thunk) that must be called to get the actual thread-local address.
+    // see https://github.com/apple-oss-distributions/dyld/blob/637911768f664e38e7e50b4fbf17e303e14fdc01/libdyld/ThreadLocalVariables.h#L110-L115
+    typedef struct {
+        void* (*thunk)(void* desc);
+        unsigned long key;
+        unsigned long offset;
+    } tls_descriptor;
+
+    tls_descriptor *desc = (tls_descriptor*)tls_symbol;
+
+    if (desc->thunk == NULL) {
+        return false;
+    }
+
+    tls_ptr = (void**)desc->thunk(desc);
+#else
+    // Linux (musl and glibc) are nice to us, `dlsym()` detects that this symbol is a STT_TLS
+    // (Symbol Table Type Thread-Local Storage) and calls `__tls_get_addr()` on it.
+    //
+    // musl implemenation at
+    // https://git.musl-libc.org/cgit/musl/tree/ldso/dynlink.c?h=v1.2.5#n2287
+    // glibc implementation at
+    // https://github.com/bminor/glibc/blob/56d0e2cca1e5ac4a9ed9332c46c64d7021ab011f/elf/dl-sym.c#L162-L165
+    //
+    // So in the end it just returns a pointer to the correct TLS variable for `this` thread we are
+    // in, which makes it an easy pointer deref to get the value.
+    tls_ptr = (void**)tls_symbol;
+#endif
+
+    if (tls_ptr == NULL) {
+        return false;
+    }
+
+    // The parallel context is non-NULL when this is a parallel thread, see the
+    // `php_parallel_scheduler_setup()` function in `src/scheduler.c` in the parallel extension.
+    // This inits the `php_parallel_scheduler_context` TLS to point to a `php_parallel_runtime_t`
+    // struct right before triggering `GINIT`.
+    return (*tls_ptr != NULL);
+}

profiling/src/php_ffi.h

@@ -161,3 +161,9 @@ void ddog_php_test_free_fake_zend_execute_data(zend_execute_data *execute_data);
 
 void ddog_php_opcache_init_handle();
 bool ddog_php_jit_enabled();
+
+/**
+ * Detects if the current thread is a parallel extension thread.
+ * Returns true if the thread was spawned by the parallel extension.
+ */
+bool ddog_php_prof_is_parallel_thread();

profiling/src/profiling/thread_utils.rs

@@ -5,6 +5,8 @@ use std::mem::MaybeUninit;
 use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
 
+#[cfg(php_zts)]
+use crate::bindings::ddog_php_prof_is_parallel_thread;
 #[cfg(php_zts)]
 use crate::sapi::Sapi;
 #[cfg(php_zts)]
@@ -93,14 +95,16 @@ thread_local! {
 
 pub fn get_current_thread_name() -> String {
     THREAD_NAME.with(|name| {
-        name.get_or_init(|| {
-            #[cfg(php_zts)]
-            let mut thread_name = SAPI.to_string();
+        name.get_or_init(|| -> String {
             #[cfg(not(php_zts))]
-            let thread_name = SAPI.to_string();
+            return SAPI.to_string();
 
             #[cfg(php_zts)]
             {
+                if unsafe { ddog_php_prof_is_parallel_thread() } {
+                    return "parallel worker".to_string();
+                }
+                let mut thread_name = SAPI.to_string();
                 // So far, only FrankenPHP sets meaningful thread names
                 if *SAPI == Sapi::FrankenPHP {
                     let mut name = [0u8; 32];
@@ -124,9 +128,8 @@ pub fn get_current_thread_name() -> String {
                         }
                     }
                 }
+                thread_name
             }
-
-            thread_name
         })
         .clone()
     })

profiling/tests/correctness/exceptions_zts.json

@@ -25,9 +25,7 @@
             },
             {
               "key": "thread name",
-              "values": [
-                "cli"
-              ]
+              "values_regex": "(cli|parallel worker)"
             }
           ]
         }