WIP: Implement a soft memory limit

Author: TimWolla

Zend/zend_alloc.c

@@ -58,6 +58,7 @@
 #include "zend_multiply.h"
 #include "zend_bitset.h"
 #include "zend_mmap.h"
+#include "zend_exceptions.h"
 #include <signal.h>
 
 #ifdef HAVE_UNISTD_H
@@ -251,6 +252,7 @@ struct _zend_mm_heap {
 #endif
 #if ZEND_MM_LIMIT
 	size_t             limit;                   /* memory limit */
+	size_t             soft_limit;              /* soft memory limit */
 	int                overflow;                /* memory overflow flag */
 #endif
 
@@ -1017,6 +1019,14 @@ static void *zend_mm_alloc_pages(zend_mm_heap *heap, uint32_t pages_count ZEND_F
 						return NULL;
 					}
 				}
+
+				if (UNEXPECTED(ZEND_MM_CHUNK_SIZE > heap->soft_limit - heap->real_size)) {
+#if ZEND_DEBUG
+					zend_throw_exception_ex(zend_ce_oom_error, 0, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %zu bytes)", heap->soft_limit, __zend_filename, __zend_lineno, size);
+#else
+					zend_throw_exception_ex(zend_ce_oom_error, 0, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)", heap->soft_limit, ZEND_MM_PAGE_SIZE * pages_count);
+#endif
+				}
 #endif
 				chunk = (zend_mm_chunk*)zend_mm_chunk_alloc(heap, ZEND_MM_CHUNK_SIZE, ZEND_MM_CHUNK_SIZE);
 				if (UNEXPECTED(chunk == NULL)) {
@@ -1543,6 +1553,14 @@ static zend_never_inline void *zend_mm_realloc_huge(zend_mm_heap *heap, void *pt
 					return NULL;
 				}
 			}
+
+			if (UNEXPECTED(new_size - old_size > heap->soft_limit - heap->real_size)) {
+#if ZEND_DEBUG
+				zend_throw_exception_ex(zend_ce_oom_error, 0, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %zu bytes)", heap->soft_limit, __zend_filename, __zend_lineno, size);
+#else
+				zend_throw_exception_ex(zend_ce_oom_error, 0, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)", heap->soft_limit, size);
+#endif
+			}
 #endif
 			/* try to map tail right after this block */
 			if (zend_mm_chunk_extend(heap, ptr, old_size, new_size)) {
@@ -1835,6 +1853,9 @@ static void *zend_mm_alloc_huge(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_D
 			return NULL;
 		}
 	}
+	if (UNEXPECTED(new_size > heap->soft_limit - heap->real_size)) {
+		zend_throw_exception_ex(zend_ce_error, 0, "Allowed memory size of %zu bytes exhausted", heap->soft_limit);
+	}
 #endif
 	ptr = zend_mm_chunk_alloc(heap, new_size, ZEND_MM_CHUNK_SIZE);
 	if (UNEXPECTED(ptr == NULL)) {
@@ -2734,6 +2755,7 @@ ZEND_API zend_result zend_set_memory_limit(size_t memory_limit)
 		return FAILURE;
 	}
 	AG(mm_heap)->limit = memory_limit;
+	AG(mm_heap)->soft_limit = 3 * 1024 * 1024;
 #endif
 	return SUCCESS;
 }
@@ -2817,6 +2839,14 @@ static zend_always_inline void tracked_check_limit(zend_mm_heap *heap, size_t ad
 		zend_mm_safe_error(heap,
 			"Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)",
 			heap->limit, add_size);
+#endif
+	}
+
+	if (add_size > heap->soft_limit - heap->size) {
+#if ZEND_DEBUG
+		zend_throw_exception_ex(zend_ce_error, 0, "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %zu bytes)", heap->soft_limit, "file", 0, add_size);
+#else
+		zend_throw_exception_ex(zend_ce_error, 0, "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)", heap->soft_limit, add_size);
 #endif
 	}
 }

Zend/zend_exceptions.c

@@ -42,6 +42,7 @@ ZEND_API zend_class_entry *zend_ce_value_error;
 ZEND_API zend_class_entry *zend_ce_arithmetic_error;
 ZEND_API zend_class_entry *zend_ce_division_by_zero_error;
 ZEND_API zend_class_entry *zend_ce_unhandled_match_error;
+ZEND_API zend_class_entry *zend_ce_oom_error;
 
 /* Internal pseudo-exception that is not exposed to userland. Throwing this exception *does not* execute finally blocks. */
 static zend_class_entry zend_ce_unwind_exit;
@@ -794,6 +795,9 @@ void zend_register_default_exception(void) /* {{{ */
 	zend_ce_unhandled_match_error = register_class_UnhandledMatchError(zend_ce_error);
 	zend_init_exception_class_entry(zend_ce_unhandled_match_error);
 
+	zend_ce_oom_error = register_class_OomError(zend_ce_error);
+	zend_init_exception_class_entry(zend_ce_oom_error);
+
 	INIT_CLASS_ENTRY(zend_ce_unwind_exit, "UnwindExit", NULL);
 
 	INIT_CLASS_ENTRY(zend_ce_graceful_exit, "GracefulExit", NULL);

Zend/zend_exceptions.h

@@ -36,6 +36,7 @@ extern ZEND_API zend_class_entry *zend_ce_value_error;
 extern ZEND_API zend_class_entry *zend_ce_arithmetic_error;
 extern ZEND_API zend_class_entry *zend_ce_division_by_zero_error;
 extern ZEND_API zend_class_entry *zend_ce_unhandled_match_error;
+extern ZEND_API zend_class_entry *zend_ce_oom_error;
 
 ZEND_API void zend_exception_set_previous(zend_object *exception, zend_object *add_previous);
 ZEND_API void zend_exception_save(void);

Zend/zend_exceptions.stub.php

@@ -170,3 +170,7 @@ class DivisionByZeroError extends ArithmeticError
 class UnhandledMatchError extends Error
 {
 }
+
+class OomError extends Error
+{
+}

Zend/zend_exceptions_arginfo.h

@@ -236,23 +236,31 @@ static int php_json_parser_object_create(php_json_parser *parser, zval *object)
 
 static int php_json_parser_object_update(php_json_parser *parser, zval *object, zend_string *key, zval *zvalue)
 {
+	if (EG(exception)) {
+		goto fail;
+	}
+
 	/* if JSON_OBJECT_AS_ARRAY is set */
 	if (Z_TYPE_P(object) == IS_ARRAY) {
 		zend_symtable_update(Z_ARRVAL_P(object), key, zvalue);
 	} else {
 		if (ZSTR_LEN(key) > 0 && ZSTR_VAL(key)[0] == '\0') {
 			parser->scanner.errcode = PHP_JSON_ERROR_INVALID_PROPERTY_NAME;
-			zend_string_release_ex(key, 0);
-			zval_ptr_dtor_nogc(zvalue);
-			zval_ptr_dtor_nogc(object);
-			return FAILURE;
+			goto fail;
 		}
 		zend_std_write_property(Z_OBJ_P(object), key, zvalue, NULL);
 		Z_TRY_DELREF_P(zvalue);
 	}
 	zend_string_release_ex(key, 0);
 
 	return SUCCESS;
+
+ fail:
+	zend_string_release_ex(key, 0);
+	zval_ptr_dtor_nogc(zvalue);
+	zval_ptr_dtor_nogc(object);
+
+	return FAILURE;
 }
 
 static int php_json_parser_array_create_validate(php_json_parser *parser, zval *array)