Hi,
This is simple, fast and system independent solution for safe timeout
handling. The patch does the same as "Zend Signal Handling" and it does
it safer (correct me if I'm wrong).
The signal handler just set EG(timed_out) flag (as on Windows).
This flag is checked during execute() loop, but only on instructions
that may cause loops (jmp(s) and function call).
The slowdown because of additional checks is near invisible (0.5% on
bench.php according to valgrind).
The only disadvantage is inability to terminate internal functions, but
each such termination may be unsafe and cause future memory corruptions,
crashes, memory and resource leaks.
I don't persist to include it in 5.3, as it need to be discussed and may
delay release. (Personally, I'm irrelevant if it committed or not)
It just an illustration of another simple approach.
Thanks. Dmitry.
Index: Zend/zend_alloc.c
===================================================================
RCS file: /repository/ZendEngine2/zend_alloc.c,v
retrieving revision 1.144.2.3.2.43.2.16
diff -u -p -d -r1.144.2.3.2.43.2.16 zend_alloc.c
--- Zend/zend_alloc.c 15 Aug 2008 19:47:23 -0000 1.144.2.3.2.43.2.16
+++ Zend/zend_alloc.c 28 Aug 2008 13:44:06 -0000
@@ -1826,15 +1826,12 @@ static void *_zend_mm_alloc_int(zend_mm_
segment_size = heap->block_size;
}
- HANDLE_BLOCK_INTERRUPTIONS();
-
if (segment_size < true_size ||
heap->real_size + segment_size > heap->limit) {
/* Memory limit overflow */
#if ZEND_MM_CACHE
zend_mm_free_cache(heap);
#endif
- HANDLE_UNBLOCK_INTERRUPTIONS();
#if ZEND_DEBUG
zend_mm_safe_error(heap, "Allowed memory size of %ld
bytes exhausted at %s:%d (tried to allocate %lu bytes)", heap->limit,
__zend_filename, __zend_lineno, size);
#else
@@ -1849,7 +1846,6 @@ static void *_zend_mm_alloc_int(zend_mm_
#if ZEND_MM_CACHE
zend_mm_free_cache(heap);
#endif
- HANDLE_UNBLOCK_INTERRUPTIONS();
out_of_memory:
#if ZEND_DEBUG
zend_mm_safe_error(heap, "Out of memory (allocated %ld)
at %s:%d (tried to allocate %lu bytes)", heap->real_size, __zend_filename,
__zend_lineno, size);
@@ -1878,7 +1874,6 @@ out_of_memory:
} else {
zend_mm_finished_searching_for_block:
/* remove from free list */
- HANDLE_BLOCK_INTERRUPTIONS();
ZEND_MM_CHECK_MAGIC(best_fit, MEM_BLOCK_FREED);
ZEND_MM_CHECK_COOKIE(best_fit);
ZEND_MM_CHECK_BLOCK_LINKAGE(best_fit);
@@ -1915,8 +1910,6 @@ zend_mm_finished_searching_for_block:
heap->peak = heap->size;
}
- HANDLE_UNBLOCK_INTERRUPTIONS();
-
return ZEND_MM_DATA_OF(best_fit);
}
@@ -1957,8 +1950,6 @@ static void _zend_mm_free_int(zend_mm_he
}
#endif
- HANDLE_BLOCK_INTERRUPTIONS();
-
heap->size -= size;
next_block = ZEND_MM_BLOCK_AT(mm_block, size);
@@ -1978,7 +1969,6 @@ static void _zend_mm_free_int(zend_mm_he
ZEND_MM_BLOCK(mm_block, ZEND_MM_FREE_BLOCK, size);
zend_mm_add_to_free_list(heap, (zend_mm_free_block *) mm_block);
}
- HANDLE_UNBLOCK_INTERRUPTIONS();
}
static void *_zend_mm_realloc_int(zend_mm_heap *heap, void *p, size_t size
ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
@@ -2007,7 +1997,6 @@ static void *_zend_mm_realloc_int(zend_m
if (remaining_size >= ZEND_MM_ALIGNED_MIN_HEADER_SIZE) {
zend_mm_free_block *new_free_block;
- HANDLE_BLOCK_INTERRUPTIONS();
next_block = ZEND_MM_BLOCK_AT(mm_block, orig_size);
if (ZEND_MM_IS_FREE_BLOCK(next_block)) {
remaining_size +=
ZEND_MM_FREE_BLOCK_SIZE(next_block);
@@ -2023,7 +2012,6 @@ static void *_zend_mm_realloc_int(zend_m
/* add the new free block to the free list */
zend_mm_add_to_free_list(heap, new_free_block);
heap->size += (true_size - orig_size);
- HANDLE_UNBLOCK_INTERRUPTIONS();
}
ZEND_MM_SET_DEBUG_INFO(mm_block, size, 0, 0);
return p;
@@ -2082,7 +2070,6 @@ static void *_zend_mm_realloc_int(zend_m
size_t block_size = orig_size +
ZEND_MM_FREE_BLOCK_SIZE(next_block);
size_t remaining_size = block_size - true_size;
- HANDLE_BLOCK_INTERRUPTIONS();
zend_mm_remove_from_free_list(heap, (zend_mm_free_block
*) next_block);
if (remaining_size < ZEND_MM_ALIGNED_MIN_HEADER_SIZE) {
@@ -2109,11 +2096,9 @@ static void *_zend_mm_realloc_int(zend_m
if (heap->peak < heap->size) {
heap->peak = heap->size;
}
- HANDLE_UNBLOCK_INTERRUPTIONS();
return p;
} else if (ZEND_MM_IS_FIRST_BLOCK(mm_block) &&
ZEND_MM_IS_GUARD_BLOCK(ZEND_MM_BLOCK_AT(next_block,
ZEND_MM_FREE_BLOCK_SIZE(next_block)))) {
- HANDLE_BLOCK_INTERRUPTIONS();
zend_mm_remove_from_free_list(heap, (zend_mm_free_block
*) next_block);
goto realloc_segment;
}
@@ -2124,7 +2109,6 @@ static void *_zend_mm_realloc_int(zend_m
size_t block_size;
size_t remaining_size;
- HANDLE_BLOCK_INTERRUPTIONS();
realloc_segment:
/* segment size, size of block and size of guard block */
if (true_size > heap->block_size -
(ZEND_MM_ALIGNED_SEGMENT_SIZE + ZEND_MM_ALIGNED_HEADER_SIZE)) {
@@ -2143,7 +2127,6 @@ realloc_segment:
#if ZEND_MM_CACHE
zend_mm_free_cache(heap);
#endif
- HANDLE_UNBLOCK_INTERRUPTIONS();
#if ZEND_DEBUG
zend_mm_safe_error(heap, "Allowed memory size of %ld
bytes exhausted at %s:%d (tried to allocate %ld bytes)", heap->limit,
__zend_filename, __zend_lineno, size);
#else
@@ -2157,7 +2140,6 @@ realloc_segment:
#if ZEND_MM_CACHE
zend_mm_free_cache(heap);
#endif
- HANDLE_UNBLOCK_INTERRUPTIONS();
out_of_memory:
#if ZEND_DEBUG
zend_mm_safe_error(heap, "Out of memory (allocated %ld)
at %s:%d (tried to allocate %ld bytes)", heap->real_size, __zend_filename,
__zend_lineno, size);
@@ -2211,7 +2193,6 @@ out_of_memory:
heap->peak = heap->size;
}
- HANDLE_UNBLOCK_INTERRUPTIONS();
return ZEND_MM_DATA_OF(mm_block);
}
Index: Zend/zend_execute.c
===================================================================
RCS file: /repository/ZendEngine2/zend_execute.c,v
retrieving revision 1.716.2.12.2.24.2.36
diff -u -p -d -r1.716.2.12.2.24.2.36 zend_execute.c
--- Zend/zend_execute.c 15 Aug 2008 19:47:23 -0000 1.716.2.12.2.24.2.36
+++ Zend/zend_execute.c 28 Aug 2008 13:44:06 -0000
@@ -1292,10 +1292,16 @@ ZEND_API void execute_internal(zend_exec
#define ZEND_VM_SET_OPCODE(new_op) \
CHECK_SYMBOL_TABLES() \
+ if (UNEXPECTED(EG(timed_out) != 0)) { \
+ zend_timeout(); \
+ } \
EX(opline) = new_op
#define ZEND_VM_JMP(new_op) \
CHECK_SYMBOL_TABLES() \
+ if (UNEXPECTED(EG(timed_out) != 0)) { \
+ zend_timeout(); \
+ } \
if (EXPECTED(!EG(exception))) { \
EX(opline) = new_op; \
} \
Index: Zend/zend_execute.h
===================================================================
RCS file: /repository/ZendEngine2/zend_execute.h,v
retrieving revision 1.84.2.4.2.8.2.11
diff -u -p -d -r1.84.2.4.2.8.2.11 zend_execute.h
--- Zend/zend_execute.h 12 Aug 2008 17:20:24 -0000 1.84.2.4.2.8.2.11
+++ Zend/zend_execute.h 28 Aug 2008 13:44:06 -0000
@@ -302,7 +302,11 @@ ZEND_API zend_bool zend_is_executing(TSR
ZEND_API void zend_set_timeout(long seconds, int reset_signals);
ZEND_API void zend_unset_timeout(TSRMLS_D);
-ZEND_API void zend_timeout(int dummy);
+#if defined(__GNUC__) && !defined(__INTEL_COMPILER) && !defined(DARWIN) &&
!defined(__hpux) && !defined(_AIX) && !defined(__osf__)
+ZEND_API void zend_timeout(void) __attribute__ ((noreturn));
+#else
+ZEND_API void zend_timeout(void);
+#endif
ZEND_API zend_class_entry *zend_fetch_class(const char *class_name, uint
class_name_len, int fetch_type TSRMLS_DC);
void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC);
Index: Zend/zend_execute_API.c
===================================================================
RCS file: /repository/ZendEngine2/zend_execute_API.c,v
retrieving revision 1.331.2.20.2.24.2.56
diff -u -p -d -r1.331.2.20.2.24.2.56 zend_execute_API.c
--- Zend/zend_execute_API.c 26 Aug 2008 08:38:26 -0000
1.331.2.20.2.24.2.56
+++ Zend/zend_execute_API.c 28 Aug 2008 13:44:06 -0000
@@ -181,9 +181,7 @@ void init_executor(TSRMLS_D) /* {{{ */
zend_objects_store_init(&EG(objects_store), 1024);
EG(full_tables_cleanup) = 0;
-#ifdef ZEND_WIN32
EG(timed_out) = 0;
-#endif
EG(exception) = NULL;
EG(prev_exception) = NULL;
@@ -1229,15 +1227,16 @@ void execute_new_code(TSRMLS_D) /* {{{ *
}
/* }}} */
-ZEND_API void zend_timeout(int dummy) /* {{{ */
+ZEND_API void zend_timeout(void) /* {{{ */
{
TSRMLS_FETCH();
+ EG(timed_out) = 0;
if (zend_on_timeout) {
zend_on_timeout(EG(timeout_seconds) TSRMLS_CC);
}
- zend_error(E_ERROR, "Maximum execution time of %d second%s exceeded",
EG(timeout_seconds), EG(timeout_seconds) == 1 ? "" : "s");
+ zend_error_noreturn(E_ERROR, "Maximum execution time of %d second%s
exceeded", EG(timeout_seconds), EG(timeout_seconds) == 1 ? "" : "s");
}
/* }}} */
@@ -1347,6 +1346,16 @@ void zend_shutdown_timeout_thread(void)
}
/* }}} */
+#else
+
+static void zend_timeout_handler(int dummy) /* {{{ */
+{
+ TSRMLS_FETCH();
+
+ EG(timed_out) = 1;
+}
+/* }}} */
+
#endif
/* This one doesn't exists on QNX */
@@ -1385,7 +1394,7 @@ void zend_set_timeout(long seconds, int
setitimer(ITIMER_REAL, &t_r, NULL);
}
if(reset_signals) {
- signal(SIGALRM, zend_timeout);
+ signal(SIGALRM, zend_timeout_handler);
sigemptyset(&sigset);
sigaddset(&sigset, SIGALRM);
}
@@ -1393,7 +1402,7 @@ void zend_set_timeout(long seconds, int
setitimer(ITIMER_PROF, &t_r, NULL);
}
if(reset_signals) {
- signal(SIGPROF, zend_timeout);
+ signal(SIGPROF, zend_timeout_handler);
sigemptyset(&sigset);
sigaddset(&sigset, SIGPROF);
}
Index: Zend/zend_globals.h
===================================================================
RCS file: /repository/ZendEngine2/zend_globals.h,v
retrieving revision 1.141.2.3.2.7.2.19
diff -u -p -d -r1.141.2.3.2.7.2.19 zend_globals.h
--- Zend/zend_globals.h 14 Aug 2008 10:24:51 -0000 1.141.2.3.2.7.2.19
+++ Zend/zend_globals.h 28 Aug 2008 13:44:06 -0000
@@ -211,9 +211,7 @@ struct _zend_executor_globals {
/* for extended information support */
zend_bool no_extensions;
-#ifdef ZEND_WIN32
zend_bool timed_out;
-#endif
HashTable regular_list;
HashTable persistent_list;
Index: Zend/zend_hash.c
===================================================================
RCS file: /repository/ZendEngine2/zend_hash.c,v
retrieving revision 1.121.2.4.2.8.2.7
diff -u -p -d -r1.121.2.4.2.8.2.7 zend_hash.c
--- Zend/zend_hash.c 12 Aug 2008 17:20:24 -0000 1.121.2.4.2.8.2.7
+++ Zend/zend_hash.c 28 Aug 2008 13:44:06 -0000
@@ -222,11 +222,9 @@ ZEND_API int _zend_hash_add_or_update(Ha
if (flag & HASH_ADD) {
return FAILURE;
}
- HANDLE_BLOCK_INTERRUPTIONS();
#if ZEND_DEBUG
if (p->pData == pData) {
ZEND_PUTS("Fatal error in
zend_hash_update: p->pData == pData\n");
- HANDLE_UNBLOCK_INTERRUPTIONS();
return FAILURE;
}
#endif
@@ -237,7 +235,6 @@ ZEND_API int _zend_hash_add_or_update(Ha
if (pDest) {
*pDest = p->pData;
}
- HANDLE_UNBLOCK_INTERRUPTIONS();
return SUCCESS;
}
}
@@ -257,10 +254,8 @@ ZEND_API int _zend_hash_add_or_update(Ha
*pDest = p->pData;
}
- HANDLE_BLOCK_INTERRUPTIONS();
CONNECT_TO_GLOBAL_DLLIST(p, ht);
ht->arBuckets[nIndex] = p;
- HANDLE_UNBLOCK_INTERRUPTIONS();
ht->nNumOfElements++;
ZEND_HASH_IF_FULL_DO_RESIZE(ht); /* If the Hash table is
full, resize it */
@@ -287,11 +282,9 @@ ZEND_API int _zend_hash_quick_add_or_upd
if (flag & HASH_ADD) {
return FAILURE;
}
- HANDLE_BLOCK_INTERRUPTIONS();
#if ZEND_DEBUG
if (p->pData == pData) {
ZEND_PUTS("Fatal error in
zend_hash_update: p->pData == pData\n");
- HANDLE_UNBLOCK_INTERRUPTIONS();
return FAILURE;
}
#endif
@@ -302,7 +295,6 @@ ZEND_API int _zend_hash_quick_add_or_upd
if (pDest) {
*pDest = p->pData;
}
- HANDLE_UNBLOCK_INTERRUPTIONS();
return SUCCESS;
}
}
@@ -325,10 +317,8 @@ ZEND_API int _zend_hash_quick_add_or_upd
*pDest = p->pData;
}
- HANDLE_BLOCK_INTERRUPTIONS();
ht->arBuckets[nIndex] = p;
CONNECT_TO_GLOBAL_DLLIST(p, ht);
- HANDLE_UNBLOCK_INTERRUPTIONS();
ht->nNumOfElements++;
ZEND_HASH_IF_FULL_DO_RESIZE(ht); /* If the Hash table is
full, resize it */
@@ -362,11 +352,9 @@ ZEND_API int _zend_hash_index_update_or_
if (flag & HASH_NEXT_INSERT || flag & HASH_ADD) {
return FAILURE;
}
- HANDLE_BLOCK_INTERRUPTIONS();
#if ZEND_DEBUG
if (p->pData == pData) {
ZEND_PUTS("Fatal error in
zend_hash_index_update: p->pData == pData\n");
- HANDLE_UNBLOCK_INTERRUPTIONS();
return FAILURE;
}
#endif
@@ -374,7 +362,6 @@ ZEND_API int _zend_hash_index_update_or_
ht->pDestructor(p->pData);
}
UPDATE_DATA(ht, p, pData, nDataSize);
- HANDLE_UNBLOCK_INTERRUPTIONS();
if ((long)h >= (long)ht->nNextFreeElement) {
ht->nNextFreeElement = h + 1;
}
@@ -398,10 +385,8 @@ ZEND_API int _zend_hash_index_update_or_
CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[nIndex]);
- HANDLE_BLOCK_INTERRUPTIONS();
ht->arBuckets[nIndex] = p;
CONNECT_TO_GLOBAL_DLLIST(p, ht);
- HANDLE_UNBLOCK_INTERRUPTIONS();
if ((long)h >= (long)ht->nNextFreeElement) {
ht->nNextFreeElement = h + 1;
@@ -421,12 +406,10 @@ static int zend_hash_do_resize(HashTable
if ((ht->nTableSize << 1) > 0) { /* Let's double the table size
*/
t = (Bucket **) perealloc_recoverable(ht->arBuckets,
(ht->nTableSize << 1) * sizeof(Bucket *), ht->persistent);
if (t) {
- HANDLE_BLOCK_INTERRUPTIONS();
ht->arBuckets = t;
ht->nTableSize = (ht->nTableSize << 1);
ht->nTableMask = ht->nTableSize - 1;
zend_hash_rehash(ht);
- HANDLE_UNBLOCK_INTERRUPTIONS();
return SUCCESS;
}
return FAILURE;
@@ -470,7 +453,6 @@ ZEND_API int zend_hash_del_key_or_index(
&& (p->nKeyLength == nKeyLength)
&& ((p->nKeyLength == 0) /* Numeric index (short
circuits the memcmp() check) */
|| !memcmp(p->arKey, arKey, nKeyLength))) { /*
String index */
- HANDLE_BLOCK_INTERRUPTIONS();
if (p == ht->arBuckets[nIndex]) {
ht->arBuckets[nIndex] = p->pNext;
} else {
@@ -500,7 +482,6 @@ ZEND_API int zend_hash_del_key_or_index(
pefree(p->pData, ht->persistent);
}
pefree(p, ht->persistent);
- HANDLE_UNBLOCK_INTERRUPTIONS();
ht->nNumOfElements--;
return SUCCESS;
}
@@ -575,7 +556,6 @@ static Bucket *zend_hash_apply_deleter(H
{
Bucket *retval;
- HANDLE_BLOCK_INTERRUPTIONS();
if (p->pLast) {
p->pLast->pNext = p->pNext;
} else {
@@ -605,7 +585,6 @@ static Bucket *zend_hash_apply_deleter(H
ht->pInternalPointer = p->pListNext;
}
ht->nNumOfElements--;
- HANDLE_UNBLOCK_INTERRUPTIONS();
if (ht->pDestructor) {
ht->pDestructor(p->pData);
@@ -1271,8 +1250,6 @@ ZEND_API int zend_hash_update_current_ke
return FAILURE;
}
- HANDLE_BLOCK_INTERRUPTIONS();
-
if (p->pNext) {
p->pNext->pLast = p->pLast;
}
@@ -1323,7 +1300,6 @@ ZEND_API int zend_hash_update_current_ke
CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[p->h &
ht->nTableMask]);
ht->arBuckets[p->h & ht->nTableMask] = p;
- HANDLE_UNBLOCK_INTERRUPTIONS();
return SUCCESS;
} else {
@@ -1357,7 +1333,6 @@ ZEND_API int zend_hash_sort(HashTable *h
(*sort_func)((void *) arTmp, i, sizeof(Bucket *), compar TSRMLS_CC);
- HANDLE_BLOCK_INTERRUPTIONS();
ht->pListHead = arTmp[0];
ht->pListTail = NULL;
ht->pInternalPointer = ht->pListHead;
@@ -1377,7 +1352,6 @@ ZEND_API int zend_hash_sort(HashTable *h
ht->pListTail = arTmp[i-1];
pefree(arTmp, ht->persistent);
- HANDLE_UNBLOCK_INTERRUPTIONS();
if (renumber) {
p = ht->pListHead;
Index: Zend/zend_vm_execute.h
===================================================================
RCS file: /repository/ZendEngine2/zend_vm_execute.h,v
retrieving revision 1.62.2.30.2.49.2.70
diff -u -p -d -r1.62.2.30.2.49.2.70 zend_vm_execute.h
--- Zend/zend_vm_execute.h 15 Aug 2008 19:47:28 -0000
1.62.2.30.2.49.2.70
+++ Zend/zend_vm_execute.h 28 Aug 2008 13:44:07 -0000
@@ -43,13 +43,17 @@ ZEND_API void execute(zend_op_array *op_
zend_bool original_in_execution = EG(in_execution);
- if (EG(exception)) {
+ if (UNEXPECTED(EG(exception) != NULL)) {
return;
}
EG(in_execution) = 1;
zend_vm_enter:
+ if (UNEXPECTED(EG(timed_out) != 0)) {
+ zend_timeout();
+ }
+
/* Initialize execute_data */
execute_data = (zend_execute_data *)zend_vm_stack_alloc(
sizeof(zend_execute_data) +
@@ -95,11 +99,6 @@ zend_vm_enter:
while (1) {
int ret;
-#ifdef ZEND_WIN32
- if (EG(timed_out)) {
- zend_timeout(0);
- }
-#endif
if ((ret = EX(opline)->handler(execute_data TSRMLS_CC)) > 0) {
switch (ret) {
Index: Zend/zend_vm_execute.skl
===================================================================
RCS file: /repository/ZendEngine2/zend_vm_execute.skl,v
retrieving revision 1.2.2.2.2.1.2.9
diff -u -p -d -r1.2.2.2.2.1.2.9 zend_vm_execute.skl
--- Zend/zend_vm_execute.skl 11 Jun 2008 13:18:41 -0000 1.2.2.2.2.1.2.9
+++ Zend/zend_vm_execute.skl 28 Aug 2008 13:44:07 -0000
@@ -9,13 +9,17 @@ ZEND_API void {%EXECUTOR_NAME%}(zend_op_
{%INTERNAL_LABELS%}
- if (EG(exception)) {
+ if (UNEXPECTED(EG(exception) != NULL)) {
return;
}
EG(in_execution) = 1;
zend_vm_enter:
+ if (UNEXPECTED(EG(timed_out) != 0)) {
+ zend_timeout();
+ }
+
/* Initialize execute_data */
execute_data = (zend_execute_data *)zend_vm_stack_alloc(
sizeof(zend_execute_data) +
@@ -61,11 +65,6 @@ zend_vm_enter:
while (1) {
{%ZEND_VM_CONTINUE_LABEL%}
-#ifdef ZEND_WIN32
- if (EG(timed_out)) {
- zend_timeout(0);
- }
-#endif
{%ZEND_VM_DISPATCH%} {
{%INTERNAL_EXECUTOR%}
--
PHP Internals - PHP Runtime Development Mailing List
To unsubscribe, visit: http://www.php.net/unsub.php
