fix: keep custom extensions registered after worker reload

Author: ousamabenyounes

ext.go

@@ -3,26 +3,43 @@ package frankenphp
 // #include "frankenphp.h"
 import "C"
 import (
+	"errors"
 	"sync"
 	"unsafe"
 )
 
 var (
-	extensions   []*C.zend_module_entry
-	registerOnce sync.Once
+	extensions           []*C.zend_module_entry
+	extensionsMu         sync.Mutex
+	extensionsRegistered bool
+	registerOnce         sync.Once
+
+	// ErrExtensionRegistrationStarted is panicked with when an extension is registered after PHP startup.
+	ErrExtensionRegistrationStarted = errors.New("frankenphp: RegisterExtension called after PHP extension registration started")
 )
 
 // RegisterExtension registers a new PHP extension.
 func RegisterExtension(me unsafe.Pointer) {
+	extensionsMu.Lock()
+	defer extensionsMu.Unlock()
+
+	if extensionsRegistered {
+		panic(ErrExtensionRegistrationStarted)
+	}
+
 	extensions = append(extensions, (*C.zend_module_entry)(me))
 }
 
 func registerExtensions() {
-	if len(extensions) == 0 {
-		return
-	}
-
 	registerOnce.Do(func() {
+		extensionsMu.Lock()
+		defer extensionsMu.Unlock()
+
+		extensionsRegistered = true
+		if len(extensions) == 0 {
+			return
+		}
+
 		C.register_extensions((**C.zend_module_entry)(unsafe.Pointer(&extensions[0])), C.int(len(extensions)))
 		extensions = nil
 	})

frankenphp.c

@@ -26,6 +26,7 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #ifndef PHP_WIN32
 #include <unistd.h>
 #endif
@@ -1957,14 +1958,24 @@ int register_internal_extensions(void) {
     }
   }
 
-  modules = NULL;
-  modules_len = 0;
-
   return SUCCESS;
 }
 
 void register_extensions(zend_module_entry **m, int len) {
-  modules = m;
+  if (len <= 0 || original_php_register_internal_extensions_func != NULL) {
+    return;
+  }
+
+  zend_module_entry **persistent_modules =
+      malloc(sizeof(zend_module_entry *) * len);
+
+  if (persistent_modules == NULL) {
+    return;
+  }
+
+  memcpy(persistent_modules, m, sizeof(zend_module_entry *) * len);
+
+  modules = persistent_modules;
   modules_len = len;
 
   original_php_register_internal_extensions_func =

internal/testext/extensions.c

@@ -4,6 +4,28 @@
 
 #include "_cgo_export.h"
 
+ZEND_BEGIN_MODULE_GLOBALS(ext2)
+zend_long minit_count;
+ZEND_END_MODULE_GLOBALS(ext2)
+
+ZEND_DECLARE_MODULE_GLOBALS(ext2)
+
+#ifdef ZTS
+#define EXT2_G(v) ZEND_TSRMG(ext2_globals_id, zend_ext2_globals *, v)
+#else
+#define EXT2_G(v) (ext2_globals.v)
+#endif
+
+static PHP_GINIT_FUNCTION(ext2) { ext2_globals->minit_count = 0; }
+
+PHP_MINIT_FUNCTION(ext2) {
+  EXT2_G(minit_count)++;
+  REGISTER_LONG_CONSTANT("EXT2_MINIT_COUNT", EXT2_G(minit_count),
+                         CONST_CS | CONST_PERSISTENT);
+
+  return SUCCESS;
+}
+
 zend_module_entry module1_entry = {STANDARD_MODULE_HEADER,
                                    "ext1",
                                    NULL, /* Functions */
@@ -18,10 +40,14 @@ zend_module_entry module1_entry = {STANDARD_MODULE_HEADER,
 zend_module_entry module2_entry = {STANDARD_MODULE_HEADER,
                                    "ext2",
                                    NULL, /* Functions */
-                                   NULL, /* MINIT */
+                                   PHP_MINIT(ext2), /* MINIT */
                                    NULL, /* MSHUTDOWN */
                                    NULL, /* RINIT */
                                    NULL, /* RSHUTDOWN */
                                    NULL, /* MINFO */
                                    "0.1.0",
-                                   STANDARD_MODULE_PROPERTIES};
+                                   PHP_MODULE_GLOBALS(ext2),
+                                   PHP_GINIT(ext2),
+                                   NULL,
+                                   NULL,
+                                   STANDARD_MODULE_PROPERTIES_EX};

internal/testext/exttest.go

@@ -28,13 +28,28 @@ func testRegisterExtension(t *testing.T) {
 
 	err := frankenphp.Init()
 	require.Nil(t, err)
-	defer frankenphp.Shutdown()
+
+	assertRegisteredExtensions(t)
+
+	require.True(t, frankenphp.RestartWorkers())
+
+	assertRegisteredExtensions(t)
+
+	frankenphp.Shutdown()
+
+	require.PanicsWithValue(t, frankenphp.ErrExtensionRegistrationStarted, func() {
+		frankenphp.RegisterExtension(unsafe.Pointer(&C.module1_entry))
+	})
+}
+
+func assertRegisteredExtensions(t *testing.T) {
+	t.Helper()
 
 	req := httptest.NewRequest("GET", "http://example.com/index.php", nil)
 	w := httptest.NewRecorder()
 
-	req, err = frankenphp.NewRequestWithContext(req, frankenphp.WithRequestDocumentRoot("./testdata", false))
-	assert.NoError(t, err)
+	req, err := frankenphp.NewRequestWithContext(req, frankenphp.WithRequestDocumentRoot("./testdata", false))
+	require.NoError(t, err)
 
 	err = frankenphp.ServeHTTP(w, req)
 	assert.NoError(t, err)
@@ -43,4 +58,5 @@ func testRegisterExtension(t *testing.T) {
 	body, _ := io.ReadAll(resp.Body)
 	assert.Contains(t, string(body), "ext1")
 	assert.Contains(t, string(body), "ext2")
+	assert.Contains(t, string(body), "EXT2_MINIT_COUNT=1")
 }

internal/testext/testdata/index.php

@@ -1,3 +1,4 @@
 <?php
 
 print_r(get_loaded_extensions());
+printf("\nEXT2_MINIT_COUNT=%d\n", EXT2_MINIT_COUNT);

worker.go

@@ -183,10 +183,12 @@ func newWorker(o workerOpt) (*worker, error) {
 // force-kill is armed after a grace period to wake threads parked in
 // blocking syscalls so a stuck sleep doesn't make this hang for the
 // full duration of the syscall.
-func RestartWorkers() {
+func RestartWorkers() bool {
 	if mainThread != nil {
-		mainThread.rebootAllThreads()
+		return mainThread.rebootAllThreads()
 	}
+
+	return false
 }
 
 func (worker *worker) attachThread(thread *phpThread) {