fix: reboot threads on opcache reset and watcher

caddy/caddy_test.go

@@ -1731,6 +1731,75 @@ func TestDd(t *testing.T) {
 	)
 }
 
+// test to force the opcache segfault race condition under concurrency (~1.7s)
+func TestOpcacheReset(t *testing.T) {
+	tester := caddytest.NewTester(t)
+	tester.Client.Timeout = 60 * time.Second
+	tester.InitServer(`
+		{
+			skip_install_trust
+			admin localhost:2999
+			http_port `+testPort+`
+			metrics
+
+			frankenphp {
+				num_threads 40
+				php_ini {
+					opcache.enable 1
+					opcache.log_verbosity_level 4
+					max_execution_time 30s
+				}
+			}
+		}
+
+		localhost:`+testPort+` {
+			php {
+				root ../testdata
+				worker {
+                    file sleep.php
+                    match /sleep*
+                    num 20
+                }
+			}
+		}
+		`, "caddyfile")
+
+	wg := sync.WaitGroup{}
+	numRequests := 500
+	wg.Add(numRequests)
+	for i := 0; i < numRequests; i++ {
+
+		// introduce a delay every 10 requests
+		if i%10 == 0 {
+			time.Sleep(time.Millisecond * 10)
+		}
+
+		go func() {
+			defer wg.Done()
+			// spam opcache_reset on intervals
+			if i%10 > 7 {
+				tester.AssertGetResponse(
+					"http://localhost:"+testPort+"/opcache_reset.php",
+					http.StatusOK,
+					"opcache reset done",
+				)
+				return
+			}
+
+			// otherwise call sleep.php with different sleep and work values
+			sleep := i % 100
+			work := i % 100
+			tester.AssertGetResponse(
+				fmt.Sprintf("http://localhost:%s/sleep.php?sleep=%d&work=%d", testPort, sleep, work),
+				http.StatusOK,
+				fmt.Sprintf("slept for %d ms and worked for %d iterations", sleep, work),
+			)
+		}()
+	}
+
+	wg.Wait()
+}
+
 func TestLog(t *testing.T) {
 	tester := caddytest.NewTester(t)
 	initServer(t, tester, `

frankenphp.c

@@ -844,6 +844,26 @@ PHP_FUNCTION(frankenphp_log) {
   }
 }
 
+/* {{{ thread-safe opcache reset */
+PHP_FUNCTION(frankenphp_opcache_reset) {
+  go_schedule_opcache_reset(thread_index);
+
+  RETVAL_TRUE;
+} /* }}} */
+
+/* Try to override opcache_reset if opcache is loaded.
+ * instead of resetting opcache, reboot all threads */
+static void frankenphp_override_opcache_reset(void) {
+  zend_function *func = zend_hash_str_find_ptr(
+      CG(function_table), "opcache_reset", sizeof("opcache_reset") - 1);
+  if (func != NULL && func->type == ZEND_INTERNAL_FUNCTION &&
+      ((zend_internal_function *)func)->handler !=
+          ZEND_FN(frankenphp_opcache_reset)) {
+    ((zend_internal_function *)func)->handler =
+        ZEND_FN(frankenphp_opcache_reset);
+  }
+}
+
 #ifdef FRANKENPHP_TEST
 /* Test-only entry point that exercises zval.h end-to-end:
  * validate -> persist (request -> persistent memory) ->
@@ -915,6 +935,10 @@ PHP_MINIT_FUNCTION(frankenphp) {
     php_error(E_WARNING, "Failed to find built-in getenv function");
   }
 
+  // Override opcache_reset (may not be available yet if opcache loads as a
+  // shared extension in PHP 8.4 and below)
+  frankenphp_override_opcache_reset();
+
   return SUCCESS;
 }
 
@@ -933,7 +957,16 @@ static zend_module_entry frankenphp_module = {
 static int frankenphp_startup(sapi_module_struct *sapi_module) {
   php_import_environment_variables = get_full_env;
 
-  return php_module_startup(sapi_module, &frankenphp_module);
+  int result = php_module_startup(sapi_module, &frankenphp_module);
+#if PHP_VERSION_ID < 80500
+  if (result == SUCCESS) {
+    /* Override opcache here again if loaded as a shared extension
+     * (php 8.4 and under) */
+    frankenphp_override_opcache_reset();
+  }
+#endif
+
+  return result;
 }
 
 static int frankenphp_deactivate(void) { return SUCCESS; }
@@ -1288,6 +1321,12 @@ static void *php_thread(void *arg) {
         zend_bailout();
       }
 
+#if PHP_VERSION_ID < 80500
+      /* Override opcache here again if loaded as a shared extension
+       * (php 8.4 and under) */
+      frankenphp_override_opcache_reset();
+#endif
+
       zend_file_handle file_handle;
       zend_stream_init_filename(&file_handle, scriptName);
 
@@ -1670,16 +1709,6 @@ int frankenphp_execute_script_cli(char *script, int argc, char **argv,
   return (intptr_t)exit_status;
 }
 
-int frankenphp_reset_opcache(void) {
-  zend_function *opcache_reset =
-      zend_hash_str_find_ptr(CG(function_table), ZEND_STRL("opcache_reset"));
-  if (opcache_reset) {
-    zend_call_known_function(opcache_reset, NULL, NULL, NULL, 0, NULL, NULL);
-  }
-
-  return 0;
-}
-
 int frankenphp_get_current_memory_limit() { return PG(memory_limit); }
 
 void frankenphp_init_thread_metrics(int max_threads) {

frankenphp.go

@@ -370,7 +370,6 @@ func Shutdown() {
 	}
 
 	drainWatchers()
-	drainAutoScaling()
 	drainPHPThreads()
 
 	metrics.Shutdown()
@@ -756,6 +755,11 @@ func go_is_context_done(threadIndex C.uintptr_t) C.bool {
 	return C.bool(phpThreads[threadIndex].frankenPHPContext().isDone)
 }
 
+//export go_schedule_opcache_reset
+func go_schedule_opcache_reset(threadIndex C.uintptr_t) {
+	go mainThread.rebootAllThreads()
+}
+
 func convertArgs(args []string) (C.int, []*C.char) {
 	argc := C.int(len(args))
 	argv := make([]*C.char, argc)

frankenphp.h

@@ -204,7 +204,6 @@ void frankenphp_register_server_vars(zval *track_vars_array,
                                      frankenphp_server_vars vars);
 
 zend_string *frankenphp_init_persistent_string(const char *string, size_t len);
-int frankenphp_reset_opcache(void);
 int frankenphp_get_current_memory_limit();
 
 typedef struct {

internal/state/state.go

@@ -12,19 +12,15 @@ type State int
 
 const (
 	// lifecycle States of a thread
-	Reserved State = iota
+	Reserved State = iota // stable
 	Booting
 	BootRequested
 	ShuttingDown
 	Done
 
 	// these States are 'stable' and safe to transition from at any time
-	Inactive
-	Ready
-
-	// States necessary for restarting workers
-	Restarting
-	Yielding
+	Inactive // stable
+	Ready // stable
 
 	// States necessary for transitioning between different handlers
 	TransitionRequested
@@ -35,6 +31,8 @@ const (
 	Rebooting
 	// C thread has exited and ZTS state is cleaned up, ready to spawn a new C thread
 	RebootReady
+	// all threads are yielding for main thread reboot
+	YieldingForReboot
 )
 
 func (s State) String() string {
@@ -53,10 +51,6 @@ func (s State) String() string {
 		return "inactive"
 	case Ready:
 		return "ready"
-	case Restarting:
-		return "restarting"
-	case Yielding:
-		return "yielding"
 	case TransitionRequested:
 		return "transition requested"
 	case TransitionInProgress:
@@ -67,6 +61,8 @@ func (s State) String() string {
 		return "rebooting"
 	case RebootReady:
 		return "reboot ready"
+	case YieldingForReboot:
+		return "yielding for reboot"
 	default:
 		return "unknown"
 	}
@@ -168,16 +164,39 @@ func (ts *ThreadState) WaitFor(states ...State) {
 	<-sub.ch
 }
 
+func (ts *ThreadState) WaitForStateWithTimeout(timeout time.Duration, states ...State) bool {
+	ts.mu.Lock()
+	if slices.Contains(states, ts.currentState) {
+		ts.mu.Unlock()
+
+		return true
+	}
+
+	sub := stateSubscriber{
+		states: states,
+		ch:     make(chan struct{}),
+	}
+	ts.subscribers = append(ts.subscribers, sub)
+	ts.mu.Unlock()
+	select {
+	case <-sub.ch:
+		return true
+	case <-time.After(timeout):
+		return false
+	}
+}
+
 // RequestSafeStateChange safely requests a state change from a different goroutine
+// returns false if thread is already in reserved state (shut down)
 func (ts *ThreadState) RequestSafeStateChange(nextState State) bool {
 	ts.mu.Lock()
 	switch ts.currentState {
-	// disallow state changes if shutting down or done
-	case ShuttingDown, Done, Reserved:
+	// disallow state changes when already shutting down or done
+	case Reserved, ShuttingDown, Done:
 		ts.mu.Unlock()
 
 		return false
-	// ready and inactive are safe states to transition from
+	// ready and inactive are stable states to transition from
 	case Ready, Inactive:
 		ts.currentState = nextState
 		ts.notifySubscribers(nextState)
@@ -187,8 +206,8 @@ func (ts *ThreadState) RequestSafeStateChange(nextState State) bool {
 	}
 	ts.mu.Unlock()
 
-	// wait for the state to change to a safe state
-	ts.WaitFor(Ready, Inactive, ShuttingDown)
+	// wait for the state to change to a stable state
+	ts.WaitFor(Ready, Inactive, Reserved)
 
 	return ts.RequestSafeStateChange(nextState)
 }