Restore Sapi::startup() with write lock for PHP allocator init

ThreadScope alone (ext_php_rs_sapi_per_thread_init) is not sufficient -
it only initializes TSRM thread-local storage but doesn't setup PHP's
memory allocator for the thread.

The SAPI startup callback (sapi_module_startup -> php_module_startup)
must also be called to initialize the allocator. We use a write lock
to serialize these calls across threads to prevent concurrent
php_module_startup from corrupting global state.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: Qard

src/embed.rs

@@ -341,11 +341,14 @@ impl Handler for Embed {
 
     // Spawn blocking PHP execution - ALL PHP operations happen here
     let blocking_handle = tokio::task::spawn_blocking(move || {
-      // Keep _sapi alive for the duration of the blocking task
-      let _ = &_sapi;
-
       // Initialize thread-local storage for this worker thread
       let _thread_scope = ThreadScope::new();
+      // Call SAPI startup on THIS thread to initialize PHP's memory allocator.
+      // This is required before any estrdup calls can be made.
+      // The startup call is serialized via write lock to prevent concurrent php_module_startup.
+      _sapi
+        .startup()
+        .map_err(|_| EmbedRequestError::SapiNotStarted)?;
 
       // Setup RequestContext (always streaming from SAPI perspective)
       // RequestContext::new() will extract the request body's read stream and add it as RequestStream extension
@@ -360,10 +363,10 @@ impl Handler for Embed {
       // All estrdup calls happen here, inside spawn_blocking, after ThreadScope::new()
       // has initialized PHP's thread-local storage. These will be freed by efree in
       // sapi_module_deactivate during request shutdown.
-      let request_uri_c = estrdup(request_uri_str.as_str());
-      let path_translated = estrdup(translated_path_str.as_str());
-      let request_method = estrdup(method_str.as_str());
-      let query_string = estrdup(query_str.as_str());
+      let request_uri_c = estrdup(request_uri_str);
+      let path_translated = estrdup(translated_path_str.clone());
+      let request_method = estrdup(method_str);
+      let query_string = estrdup(query_str);
       let content_type = content_type_str
         .as_ref()
         .map(|s| estrdup(s.as_str()))

src/sapi.rs

@@ -114,6 +114,25 @@ impl Sapi {
     })
   }
 
+  /// Initialize PHP for the current thread and call the SAPI module startup.
+  /// This must be called on each worker thread before using PHP's memory allocator (estrdup).
+  /// On ZTS builds, this initializes thread-local storage and module state.
+  /// Uses a write lock to serialize startup calls across threads.
+  pub fn startup(&self) -> Result<(), EmbedRequestError> {
+    let sapi = &mut self
+      .module
+      .write()
+      .map_err(|_| EmbedRequestError::SapiNotStarted)?;
+
+    if let Some(startup) = sapi.startup {
+      if unsafe { startup(sapi.as_mut()) } != ZEND_RESULT_CODE_SUCCESS {
+        return Err(EmbedRequestError::SapiNotStarted);
+      }
+    }
+
+    Ok(())
+  }
+
   pub fn shutdown(&self) -> Result<(), EmbedRequestError> {
     // Only shutdown if we're on the same thread that created this Sapi
     let current_thread = std::thread::current().id();