Make native tracking opt-in

Author: arnaud-lb

README.md

@@ -63,15 +63,18 @@ Profiling is enabled at request startup when one of these is true:
  * `$_GET["MEMPROF_PROFILE"]` is non-empty
  * `$_POST["MEMPROF_PROFILE"]` is non-empty
 
-### 2. Dumping the profile
+The `memprof_enabled()` function can be called to check whether profiling is
+currently enabled.
 
-Once profiling is enabled, the program must call ``memprof_dump_callgrind()`` or
-one it its variants to dump the memory profile.
+### 2. Dumping the profile
 
-This can be done at anytime during the program, ideally when the leak is large,
-so that it will be more visible in the profile.
+When profiling is enabled, and once the program has reached a large memory usage,
+call ``memprof_dump_callgrind()`` or one it its variants to save the full
+profiling information to a file.
 
-This can be done multiple times during the same execution, but this is not necessary.
+* Calling the function multiple times is not necessary
+* Waiting for a high memory usage before saving the profile makes it easier to
+  find a leak
 
 ### 3. Visualizing the profile
 
@@ -127,12 +130,32 @@ Setting a POST field works as well:
 curl -d MEMPROF_PROFILE=1 http://127.0.0.1/test.php
 ```
 
+### Profiling native allocations
+
+Memprof doesn't track native allocations by default, but this can be enabled
+by setting `MEMPROF_PROFILE` to `native`.
+
+Native allocations are the allocations made outside of PHP's own memory
+allocator. Typically, external libraries such as libxml2 (used in the DOM
+extension) make native allocations. PHP can also make native allocations for
+persistent resources.
+
+Enabling native allocation tracking will profile these allocations in addition
+to PHP's own allocations.
+
+Note that when native tracking is enabled, the program will crash if a native
+library uses threads, because the underlying hooks are not thread safe.
+
 ## Functions documentation
 
 ### memprof_enabled()
 
 Returns whether memory profiling is currently enabled (see above).
 
+### memprof_enabled_flags()
+
+Returns whether memory profiling and native profiling are enabled (see above).
+
 ### memprof_dump_callgrind(resource $stream)
 
 Dumps the current profile in callgrind format. The result can be visualized with tools such as
@@ -265,7 +288,6 @@ Example output:
 
 ## Troubleshooting
 
- * If you are experiencing crashes, try disabling malloc hooks by setting HAVE_MALLOC_HOOKS to 0 in config.h after running configure; then run ``make clean && make && make install``. (Using malloc hooks may crash if some other extension uses threads internally.)
  * The extensions may conflict with xdebug, blackfire, or other extensions. If that's the case for you, please report it.
 
 ## PHP versions
@@ -274,10 +296,6 @@ The current branch supports PHP 7.1 to PHP 8.
 
 The php5 branch supports PHP 5.
 
-## TODO
-
- * Thread-safe malloc hooks
-
 ## How it works
 
 See [INTERNALS.md][7]

memprof.c

@@ -33,6 +33,8 @@
 #include <assert.h>
 
 #define MEMPROF_ENV_PROFILE "MEMPROF_PROFILE"
+#define MEMPROF_FLAG_NATIVE "native"
+
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 
 #ifdef ZTS
@@ -188,6 +190,9 @@ static void (*old_zend_execute_internal)(zend_execute_data *execute_data_ptr, zv
 
 static PHP_INI_MH((*origOnChangeMemoryLimit)) = NULL;
 
+#define MEMPROF_ENABLED			(1<<0)
+#define MEMPROF_ENABLED_NATIVE  (1<<1)
+
 static int memprof_enabled = 0;
 static int memprof_dumped = 0;
 static int track_mallocs = 0;
@@ -732,8 +737,10 @@ static PHP_INI_MH(OnChangeMemoryLimit)
 	return SUCCESS;
 }
 
-static void memprof_enable()
+static void memprof_enable(int flags)
 {
+	assert(flags & MEMPROF_ENABLED);
+
 	alloc_buckets_init(&current_alloc_buckets);
 
 	init_frame(&root_frame, &root_frame, "root", sizeof("root")-1);
@@ -742,10 +749,12 @@ static void memprof_enable()
 	current_frame = &root_frame;
 	current_alloc_list = &root_frame.allocs;
 
-	MALLOC_HOOK_SAVE_OLD();
-	MALLOC_HOOK_SET_OWN();
+	if (flags & MEMPROF_ENABLED_NATIVE) {
+		MALLOC_HOOK_SAVE_OLD();
+		MALLOC_HOOK_SET_OWN();
+	}
 
-	memprof_enabled = 1;
+	memprof_enabled = flags;
 	memprof_dumped = 0;
 
 	if (is_zend_mm()) {
@@ -781,7 +790,9 @@ static void memprof_disable()
 		free(zheap);
 	}
 
-	MALLOC_HOOK_RESTORE_OLD();
+	if (memprof_enabled & MEMPROF_ENABLED_NATIVE) {
+		MALLOC_HOOK_RESTORE_OLD();
+	}
 
 	memprof_enabled = 0;
 
@@ -852,12 +863,22 @@ static zend_string* read_env_get_post(char *name, size_t len)
 
 static int should_autostart()
 {
+	char *saveptr;
+	const char *delim = ",";
+	char *flag;
+
 	zend_string *value = read_env_get_post(MEMPROF_ENV_PROFILE, strlen(MEMPROF_ENV_PROFILE));
 	if (value == NULL) {
 		return 0;
 	}
 
-	int autostart = ZSTR_LEN(value) > 0;
+	int autostart = ZSTR_LEN(value) > 0 ? MEMPROF_ENABLED : 0;
+
+	for (flag = strtok_r(ZSTR_VAL(value), delim, &saveptr); flag != NULL; flag = strtok_r(NULL, delim, &saveptr)) {
+		if (HAVE_MALLOC_HOOKS && strcmp(MEMPROF_FLAG_NATIVE, flag) == 0) {
+			autostart |= MEMPROF_ENABLED_NATIVE;
+		}
+	}
 
 	zend_string_release(value);
 
@@ -913,6 +934,7 @@ ZEND_END_ARG_INFO()
  */
 const zend_function_entry memprof_functions[] = {
 	PHP_FE(memprof_enabled, arginfo_void)
+	PHP_FE(memprof_enabled_flags, arginfo_void)
 	PHP_FE(memprof_enable, arginfo_void)
 	PHP_FE(memprof_disable, arginfo_void)
 	PHP_FE(memprof_dump_array, arginfo_void)
@@ -1008,9 +1030,11 @@ PHP_MSHUTDOWN_FUNCTION(memprof)
  */
 PHP_RINIT_FUNCTION(memprof)
 {
-	if (should_autostart()) {
+	int flags = should_autostart();
+
+	if (flags) {
 		disable_opcache();
-		memprof_enable();
+		memprof_enable(flags);
 	}
 
 	return SUCCESS;
@@ -1036,6 +1060,7 @@ PHP_MINFO_FUNCTION(memprof)
 	php_info_print_table_start();
 	php_info_print_table_header(2, "memprof support", "enabled");
 	php_info_print_table_header(2, "memprof version", PHP_MEMPROF_VERSION);
+	php_info_print_table_header(2, "memprof native malloc support", HAVE_MALLOC_HOOKS ? "yes" : "no");
 #if MEMPROF_DEBUG
 	php_info_print_table_header(2, "debug build", "Yes");
 #endif
@@ -1444,7 +1469,7 @@ PHP_FUNCTION(memprof_enable)
 
 	zend_error(E_WARNING, "Calling memprof_enable() manually may not work as expected because of PHP optimizations. Prefer using MEMPROF_PROFILE=1 as environment variable, GET, or POST");
 
-	memprof_enable();
+	memprof_enable(MEMPROF_ENABLED);
 
 	RETURN_TRUE;
 }
@@ -1469,14 +1494,28 @@ PHP_FUNCTION(memprof_disable)
 }
 /* }}} */
 
-/* {{{ proto bool memprof_disabled()
+/* {{{ proto bool memprof_enabled()
    Returns whether memprof is enabled */
 PHP_FUNCTION(memprof_enabled)
 {
 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
 		return;
 	}
 
-	RETURN_BOOL(memprof_enabled);
+	RETURN_BOOL(memprof_enabled & MEMPROF_ENABLED);
+}
+/* }}} */
+
+/* {{{ proto array memprof_enabled_flags()
+   Returns whether memprof is enabled */
+PHP_FUNCTION(memprof_enabled_flags)
+{
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+		return;
+	}
+
+	array_init(return_value);
+	add_assoc_bool(return_value, "enabled", (memprof_enabled & MEMPROF_ENABLED) != 0);
+	add_assoc_bool(return_value, "native", (memprof_enabled & MEMPROF_ENABLED_NATIVE) != 0);
 }
 /* }}} */

php_memprof.h

@@ -51,5 +51,6 @@ PHP_FUNCTION(memprof_memory_get_peak_usage);
 PHP_FUNCTION(memprof_enable);
 PHP_FUNCTION(memprof_disable);
 PHP_FUNCTION(memprof_enabled);
+PHP_FUNCTION(memprof_enabled_flags);
 
 #endif	/* PHP_MEMPROF_H */

tests/004.phpt

@@ -5,6 +5,13 @@ MEMPROF_PROFILE=1
 --FILE--
 <?php
 var_dump(memprof_enabled());
+var_dump(memprof_enabled_flags());
 memprof_dump_array();
 --EXPECT--
 bool(true)
+array(2) {
+  ["enabled"]=>
+  bool(true)
+  ["native"]=>
+  bool(false)
+}

tests/007.phpt

@@ -0,0 +1,16 @@
+--TEST--
+Enable native profiling
+--ENV--
+MEMPROF_PROFILE=native
+--FILE--
+<?php
+var_dump(memprof_enabled());
+var_dump(memprof_enabled_flags());
+--EXPECT--
+bool(true)
+array(2) {
+  ["enabled"]=>
+  bool(true)
+  ["native"]=>
+  bool(true)
+}