Merge branch 'master' of http://git.php.net/repository/php-src

7 files changed, 28 insertions, 52 deletions

diff --git a/Zend/Zend.m4 b/Zend/Zend.m4
index bdeac672b4..9d3b46a755 100644
--- a/Zend/Zend.m4
+++ b/Zend/Zend.m4
@@ -370,10 +370,10 @@ AC_CHECK_FUNCS(mremap)
 
 
 AC_ARG_ENABLE(zend-signals,
-[  --enable-zend-signals   Use zend signal handling],[
+[  --disable-zend-signals  whether to enable zend signal handling],[
   ZEND_SIGNALS=$enableval
 ],[
-  ZEND_SIGNALS=no
+  ZEND_SIGNALS=yes
 ])  
 
 AC_CHECK_FUNC(sigaction, [
diff --git a/Zend/zend.h b/Zend/zend.h
index 8fb2726dcf..1e0a5613e6 100644
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -42,16 +42,8 @@
 #include "zend_smart_str_public.h"
 #include "zend_signal.h"
 
-#ifndef ZEND_SIGNALS
-/* block/unblock interruptions callbacks might be used by SAPI, and were used
- * by mod_php for Apache 1, but now they are not usefull anymore.
- */
-# define HANDLE_BLOCK_INTERRUPTIONS()
-# define HANDLE_UNBLOCK_INTERRUPTIONS()
-#else
-# define HANDLE_BLOCK_INTERRUPTIONS()		ZEND_SIGNAL_BLOCK_INTERRUPTIONS()
-# define HANDLE_UNBLOCK_INTERRUPTIONS()		ZEND_SIGNAL_UNBLOCK_INTERRUPTIONS()
-#endif
+#define HANDLE_BLOCK_INTERRUPTIONS()		ZEND_SIGNAL_BLOCK_INTERRUPTIONS()
+#define HANDLE_UNBLOCK_INTERRUPTIONS()		ZEND_SIGNAL_UNBLOCK_INTERRUPTIONS()
 
 #define INTERNAL_FUNCTION_PARAMETERS zend_execute_data *execute_data, zval *return_value
 #define INTERNAL_FUNCTION_PARAM_PASSTHRU execute_data, return_value
diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c
index 95652d598d..47215d3511 100644
--- a/Zend/zend_hash.c
+++ b/Zend/zend_hash.c
@@ -191,10 +191,8 @@ static void ZEND_FASTCALL zend_hash_packed_grow(HashTable *ht)
 	if (ht->nTableSize >= HT_MAX_SIZE) {
 		zend_error_noreturn(E_ERROR, "Possible integer overflow in memory allocation (%zu * %zu + %zu)", ht->nTableSize * 2, sizeof(Bucket), sizeof(Bucket));
 	}
-	HANDLE_BLOCK_INTERRUPTIONS();
 	ht->nTableSize += ht->nTableSize;
 	HT_SET_DATA_ADDR(ht, perealloc2(HT_GET_DATA_ADDR(ht), HT_SIZE(ht), HT_USED_SIZE(ht), ht->u.flags & HASH_FLAG_PERSISTENT));
-	HANDLE_UNBLOCK_INTERRUPTIONS();
 }
 
 ZEND_API void ZEND_FASTCALL zend_hash_real_init(HashTable *ht, zend_bool packed)
@@ -211,7 +209,6 @@ ZEND_API void ZEND_FASTCALL zend_hash_packed_to_hash(HashTable *ht)
 	Bucket *old_buckets = ht->arData;
 
 	HT_ASSERT(GC_REFCOUNT(ht) == 1);
-	HANDLE_BLOCK_INTERRUPTIONS();
 	ht->u.flags &= ~HASH_FLAG_PACKED;
 	new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, -ht->nTableSize), (ht)->u.flags & HASH_FLAG_PERSISTENT);
 	ht->nTableMask = -ht->nTableSize;
@@ -219,7 +216,6 @@ ZEND_API void ZEND_FASTCALL zend_hash_packed_to_hash(HashTable *ht)
 	memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed);
 	pefree(old_data, (ht)->u.flags & HASH_FLAG_PERSISTENT);
 	zend_hash_rehash(ht);
-	HANDLE_UNBLOCK_INTERRUPTIONS();
 }
 
 ZEND_API void ZEND_FASTCALL zend_hash_to_packed(HashTable *ht)
@@ -228,7 +224,6 @@ ZEND_API void ZEND_FASTCALL zend_hash_to_packed(HashTable *ht)
 	Bucket *old_buckets = ht->arData;
 
 	HT_ASSERT(GC_REFCOUNT(ht) == 1);
-	HANDLE_BLOCK_INTERRUPTIONS();
 	new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, HT_MIN_MASK), (ht)->u.flags & HASH_FLAG_PERSISTENT);
 	ht->u.flags |= HASH_FLAG_PACKED | HASH_FLAG_STATIC_KEYS;
 	ht->nTableMask = HT_MIN_MASK;
@@ -236,7 +231,6 @@ ZEND_API void ZEND_FASTCALL zend_hash_to_packed(HashTable *ht)
 	HT_HASH_RESET_PACKED(ht);
 	memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed);
 	pefree(old_data, (ht)->u.flags & HASH_FLAG_PERSISTENT);
-	HANDLE_UNBLOCK_INTERRUPTIONS();
 }
 
 ZEND_API void ZEND_FASTCALL _zend_hash_init_ex(HashTable *ht, uint32_t nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC)
@@ -260,10 +254,8 @@ ZEND_API void ZEND_FASTCALL zend_hash_extend(HashTable *ht, uint32_t nSize, zend
 		if (packed) {
 			ZEND_ASSERT(ht->u.flags & HASH_FLAG_PACKED);
 			if (nSize > ht->nTableSize) {
-				HANDLE_BLOCK_INTERRUPTIONS();
 				ht->nTableSize = zend_hash_check_size(nSize);
 				HT_SET_DATA_ADDR(ht, perealloc2(HT_GET_DATA_ADDR(ht), HT_SIZE(ht), HT_USED_SIZE(ht), ht->u.flags & HASH_FLAG_PERSISTENT));
-				HANDLE_UNBLOCK_INTERRUPTIONS();
 			}
 		} else {
 			ZEND_ASSERT(!(ht->u.flags & HASH_FLAG_PACKED));
@@ -271,7 +263,6 @@ ZEND_API void ZEND_FASTCALL zend_hash_extend(HashTable *ht, uint32_t nSize, zend
 				void *new_data, *old_data = HT_GET_DATA_ADDR(ht);
 				Bucket *old_buckets = ht->arData;
 				nSize = zend_hash_check_size(nSize);
-				HANDLE_BLOCK_INTERRUPTIONS();
 				new_data = pemalloc(HT_SIZE_EX(nSize, -nSize), ht->u.flags & HASH_FLAG_PERSISTENT);
 				ht->nTableSize = nSize;
 				ht->nTableMask = -ht->nTableSize;
@@ -279,7 +270,6 @@ ZEND_API void ZEND_FASTCALL zend_hash_extend(HashTable *ht, uint32_t nSize, zend
 				memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed);
 				pefree(old_data, ht->u.flags & HASH_FLAG_PERSISTENT);
 				zend_hash_rehash(ht);
-				HANDLE_UNBLOCK_INTERRUPTIONS();
 			}
 		}
 	}
@@ -591,12 +581,10 @@ static zend_always_inline zval *_zend_hash_add_or_update_i(HashTable *ht, zend_s
 					data = Z_INDIRECT_P(data);
 				}
 			}
-			HANDLE_BLOCK_INTERRUPTIONS();
 			if (ht->pDestructor) {
 				ht->pDestructor(data);
 			}
 			ZVAL_COPY_VALUE(data, pData);
-			HANDLE_UNBLOCK_INTERRUPTIONS();
 			return data;
 		}
 	}
@@ -604,7 +592,6 @@ static zend_always_inline zval *_zend_hash_add_or_update_i(HashTable *ht, zend_s
 	ZEND_HASH_IF_FULL_DO_RESIZE(ht);		/* If the Hash table is full, resize it */
 
 add_to_hash:
-	HANDLE_BLOCK_INTERRUPTIONS();
 	idx = ht->nNumUsed++;
 	ht->nNumOfElements++;
 	if (ht->nInternalPointer == HT_INVALID_IDX) {
@@ -623,7 +610,6 @@ add_to_hash:
 	nIndex = h | ht->nTableMask;
 	Z_NEXT(p->val) = HT_HASH(ht, nIndex);
 	HT_HASH(ht, nIndex) = HT_IDX_TO_HASH(idx);
-	HANDLE_UNBLOCK_INTERRUPTIONS();
 
 	return &p->val;
 }
@@ -762,7 +748,6 @@ static zend_always_inline zval *_zend_hash_index_add_or_update_i(HashTable *ht,
 		}
 
 add_to_packed:
-		HANDLE_BLOCK_INTERRUPTIONS();
 		/* incremental initialization of empty Buckets */
 		if ((flag & (HASH_ADD_NEW|HASH_ADD_NEXT)) == (HASH_ADD_NEW|HASH_ADD_NEXT)) {
 			ht->nNumUsed = h + 1;
@@ -788,8 +773,6 @@ add_to_packed:
 		p->key = NULL;
 		ZVAL_COPY_VALUE(&p->val, pData);
 
-		HANDLE_UNBLOCK_INTERRUPTIONS();
-
 		return &p->val;
 
 convert_to_hash:
@@ -801,12 +784,10 @@ convert_to_hash:
 				return NULL;
 			}
 			ZEND_ASSERT(&p->val != pData);
-			HANDLE_BLOCK_INTERRUPTIONS();
 			if (ht->pDestructor) {
 				ht->pDestructor(&p->val);
 			}
 			ZVAL_COPY_VALUE(&p->val, pData);
-			HANDLE_UNBLOCK_INTERRUPTIONS();
 			if ((zend_long)h >= (zend_long)ht->nNextFreeElement) {
 				ht->nNextFreeElement = h < ZEND_LONG_MAX ? h + 1 : ZEND_LONG_MAX;
 			}
@@ -817,7 +798,6 @@ convert_to_hash:
 	ZEND_HASH_IF_FULL_DO_RESIZE(ht);		/* If the Hash table is full, resize it */
 
 add_to_hash:
-	HANDLE_BLOCK_INTERRUPTIONS();
 	idx = ht->nNumUsed++;
 	ht->nNumOfElements++;
 	if (ht->nInternalPointer == HT_INVALID_IDX) {
@@ -834,7 +814,6 @@ add_to_hash:
 	ZVAL_COPY_VALUE(&p->val, pData);
 	Z_NEXT(p->val) = HT_HASH(ht, nIndex);
 	HT_HASH(ht, nIndex) = HT_IDX_TO_HASH(idx);
-	HANDLE_UNBLOCK_INTERRUPTIONS();
 
 	return &p->val;
 }
@@ -876,15 +855,12 @@ static void ZEND_FASTCALL zend_hash_do_resize(HashTable *ht)
 	HT_ASSERT(GC_REFCOUNT(ht) == 1);
 
 	if (ht->nNumUsed > ht->nNumOfElements + (ht->nNumOfElements >> 5)) { /* additional term is there to amortize the cost of compaction */
-		HANDLE_BLOCK_INTERRUPTIONS();
 		zend_hash_rehash(ht);
-		HANDLE_UNBLOCK_INTERRUPTIONS();
 	} else if (ht->nTableSize < HT_MAX_SIZE) {	/* Let's double the table size */
 		void *new_data, *old_data = HT_GET_DATA_ADDR(ht);
 		uint32_t nSize = ht->nTableSize + ht->nTableSize;
 		Bucket *old_buckets = ht->arData;
 
-		HANDLE_BLOCK_INTERRUPTIONS();
 		new_data = pemalloc(HT_SIZE_EX(nSize, -nSize), ht->u.flags & HASH_FLAG_PERSISTENT);
 		ht->nTableSize = nSize;
 		ht->nTableMask = -ht->nTableSize;
@@ -892,7 +868,6 @@ static void ZEND_FASTCALL zend_hash_do_resize(HashTable *ht)
 		memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed);
 		pefree(old_data, ht->u.flags & HASH_FLAG_PERSISTENT);
 		zend_hash_rehash(ht);
-		HANDLE_UNBLOCK_INTERRUPTIONS();
 	} else {
 		zend_error_noreturn(E_ERROR, "Possible integer overflow in memory allocation (%zu * %zu + %zu)", ht->nTableSize * 2, sizeof(Bucket) + sizeof(uint32_t), sizeof(Bucket));
 	}
@@ -984,7 +959,6 @@ ZEND_API int ZEND_FASTCALL zend_hash_rehash(HashTable *ht)
 
 static zend_always_inline void _zend_hash_del_el_ex(HashTable *ht, uint32_t idx, Bucket *p, Bucket *prev)
 {
-	HANDLE_BLOCK_INTERRUPTIONS();
 	if (!(ht->u.flags & HASH_FLAG_PACKED)) {
 		if (prev) {
 			Z_NEXT(prev->val) = Z_NEXT(p->val);
@@ -1027,7 +1001,6 @@ static zend_always_inline void _zend_hash_del_el_ex(HashTable *ht, uint32_t idx,
 	} else {
 		ZVAL_UNDEF(&p->val);
 	}
-	HANDLE_UNBLOCK_INTERRUPTIONS();
 }
 
 static zend_always_inline void _zend_hash_del_el(HashTable *ht, uint32_t idx, Bucket *p)
@@ -2296,7 +2269,6 @@ ZEND_API int ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort, co
 			(swap_func_t)(renumber? zend_hash_bucket_renum_swap :
 				((ht->u.flags & HASH_FLAG_PACKED) ? zend_hash_bucket_packed_swap : zend_hash_bucket_swap)));
 
-	HANDLE_BLOCK_INTERRUPTIONS();
 	ht->nNumUsed = i;
 	ht->nInternalPointer = 0;
 
@@ -2333,8 +2305,6 @@ ZEND_API int ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort, co
 		}
 	}
 
-	HANDLE_UNBLOCK_INTERRUPTIONS();
-
 	return SUCCESS;
 }
 
diff --git a/Zend/zend_string.c b/Zend/zend_string.c
index 7b64dd6256..612c8049ef 100644
--- a/Zend/zend_string.c
+++ b/Zend/zend_string.c
@@ -161,7 +161,6 @@ static zend_string *zend_new_interned_string_int(zend_string *str)
 			void *old_data = HT_GET_DATA_ADDR(&CG(interned_strings));
 			Bucket *old_buckets = CG(interned_strings).arData;
 
-			HANDLE_BLOCK_INTERRUPTIONS();
 			CG(interned_strings).nTableSize += CG(interned_strings).nTableSize;
 			CG(interned_strings).nTableMask = -CG(interned_strings).nTableSize;
 			new_data = malloc(HT_SIZE(&CG(interned_strings)));
@@ -175,12 +174,9 @@ static zend_string *zend_new_interned_string_int(zend_string *str)
 				CG(interned_strings).nTableSize = CG(interned_strings).nTableSize >> 1;
 				CG(interned_strings).nTableMask = -CG(interned_strings).nTableSize;
 			}
-			HANDLE_UNBLOCK_INTERRUPTIONS();
 		}
 	}
 
-	HANDLE_BLOCK_INTERRUPTIONS();
-
 	idx = CG(interned_strings).nNumUsed++;
 	CG(interned_strings).nNumOfElements++;
 	p = CG(interned_strings).arData + idx;
@@ -192,8 +188,6 @@ static zend_string *zend_new_interned_string_int(zend_string *str)
 	Z_NEXT(p->val) = HT_HASH(&CG(interned_strings), nIndex);
 	HT_HASH(&CG(interned_strings), nIndex) = HT_IDX_TO_HASH(idx);
 
-	HANDLE_UNBLOCK_INTERRUPTIONS();
-
 	return str;
 #else
 	return str;
diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c
index 222935bad0..2f756b0844 100644
--- a/ext/opcache/ZendAccelerator.c
+++ b/ext/opcache/ZendAccelerator.c
@@ -989,6 +989,7 @@ char *accel_make_persistent_key(const char *path, int path_length, int *key_len)
 
 					zend_string *str = accel_find_interned_string(cwd_str);
 					if (!str) {
+						HANDLE_BLOCK_INTERRUPTIONS();
 						SHM_UNPROTECT();
 						zend_shared_alloc_lock();
 						str = accel_new_interned_string(zend_string_copy(cwd_str));
@@ -998,6 +999,7 @@ char *accel_make_persistent_key(const char *path, int path_length, int *key_len)
 						}
 						zend_shared_alloc_unlock();
 						SHM_PROTECT();
+						HANDLE_UNBLOCK_INTERRUPTIONS();
 					}
 					if (str) {
 						char buf[32];
@@ -1029,6 +1031,7 @@ char *accel_make_persistent_key(const char *path, int path_length, int *key_len)
 
 					zend_string *str = accel_find_interned_string(ZCG(include_path));
 					if (!str) {
+						HANDLE_BLOCK_INTERRUPTIONS();
 						SHM_UNPROTECT();
 						zend_shared_alloc_lock();
 						str = accel_new_interned_string(zend_string_copy(ZCG(include_path)));
@@ -1037,6 +1040,7 @@ char *accel_make_persistent_key(const char *path, int path_length, int *key_len)
 						}
 						zend_shared_alloc_unlock();
 						SHM_PROTECT();
+						HANDLE_UNBLOCK_INTERRUPTIONS();
 					}
 					if (str) {
 						char buf[32];
@@ -1134,6 +1138,7 @@ int zend_accel_invalidate(const char *filename, int filename_len, zend_bool forc
 		if (force ||
 			!ZCG(accel_directives).validate_timestamps ||
 			do_validate_timestamps(persistent_script, &file_handle) == FAILURE) {
+			HANDLE_BLOCK_INTERRUPTIONS();
 			SHM_UNPROTECT();
 			zend_shared_alloc_lock();
 			if (!persistent_script->corrupted) {
@@ -1148,6 +1153,7 @@ int zend_accel_invalidate(const char *filename, int filename_len, zend_bool forc
 			}
 			zend_shared_alloc_unlock();
 			SHM_PROTECT();
+			HANDLE_UNBLOCK_INTERRUPTIONS();
 		}
 	}
 
@@ -1594,9 +1600,11 @@ zend_op_array *file_cache_compile_file(zend_file_handle *file_handle, int type)
 	    }
 	}
 
+	HANDLE_BLOCK_INTERRUPTIONS();
 	SHM_UNPROTECT();
 	persistent_script = zend_file_cache_script_load(file_handle);
 	SHM_PROTECT();
+	HANDLE_UNBLOCK_INTERRUPTIONS();
 	if (persistent_script) {
 		/* see bug #15471 (old BTS) */
 		if (persistent_script->script.filename) {
@@ -1716,11 +1724,13 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type)
 					persistent_script = (zend_persistent_script *)bucket->data;
 
 					if (key && !persistent_script->corrupted) {
+						HANDLE_BLOCK_INTERRUPTIONS();
 						SHM_UNPROTECT();
 						zend_shared_alloc_lock();
 						zend_accel_add_key(key, key_length, bucket);
 						zend_shared_alloc_unlock();
 						SHM_PROTECT();
+						HANDLE_UNBLOCK_INTERRUPTIONS();
 					}
 				}
 			}
@@ -1751,6 +1761,7 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type)
 		ZCG(counted) = 1;
 	}
 
+	HANDLE_BLOCK_INTERRUPTIONS();
 	SHM_UNPROTECT();
 
 	/* If script is found then validate_timestamps if option is enabled */
@@ -1815,6 +1826,7 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type)
 		/* No memory left. Behave like without the Accelerator */
 		if (ZSMMG(memory_exhausted) || ZCSG(restart_pending)) {
 			SHM_PROTECT();
+			HANDLE_UNBLOCK_INTERRUPTIONS();
 			return accelerator_orig_compile_file(file_handle, type);
 		}
 
@@ -1832,6 +1844,7 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type)
 		 */
 		if (!persistent_script) {
 			SHM_PROTECT();
+			HANDLE_UNBLOCK_INTERRUPTIONS();
 			return op_array;
 		}
 		if (from_shared_memory) {
@@ -1885,6 +1898,7 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type)
 	persistent_script->dynamic_members.last_used = ZCG(request_time);
 
 	SHM_PROTECT();
+	HANDLE_UNBLOCK_INTERRUPTIONS();
 
     /* Fetch jit auto globals used in the script before execution */
     if (persistent_script->ping_auto_globals_mask) {
@@ -1973,11 +1987,13 @@ static zend_string* persistent_zend_resolve_path(const char *filename, int filen
 					if (!persistent_script->corrupted) {
 						if (key) {
 							/* add another "key" for the same bucket */
+							HANDLE_BLOCK_INTERRUPTIONS();
 							SHM_UNPROTECT();
 							zend_shared_alloc_lock();
 							zend_accel_add_key(key, key_length, bucket);
 							zend_shared_alloc_unlock();
 							SHM_PROTECT();
+							HANDLE_UNBLOCK_INTERRUPTIONS();
 						} else {
 							ZCG(key_len) = 0;
 						}
@@ -2058,6 +2074,7 @@ static void accel_activate(void)
 	}
 #endif
 
+	HANDLE_BLOCK_INTERRUPTIONS();
 	SHM_UNPROTECT();
 
 	if (ZCG(counted)) {
@@ -2114,6 +2131,7 @@ static void accel_activate(void)
 	}
 
 	SHM_PROTECT();
+	HANDLE_UNBLOCK_INTERRUPTIONS();
 
 	if (ZCSG(last_restart_time) != ZCG(last_restart_time)) {
 		/* SHM was reinitialized. */
@@ -2755,6 +2773,7 @@ static int accel_startup(zend_extension *extension)
 		zend_shared_alloc_unlock();
 
 		SHM_PROTECT();
+		HANDLE_UNBLOCK_INTERRUPTIONS();
 #ifdef HAVE_OPCACHE_FILE_CACHE
 	} else if (!ZCG(accel_directives).file_cache) {
 		accel_startup_ok = 0;
@@ -2882,6 +2901,7 @@ void zend_accel_schedule_restart(zend_accel_restart_reason reason)
 	}
 	zend_accel_error(ACCEL_LOG_DEBUG, "Restart Scheduled!");
 
+	HANDLE_BLOCK_INTERRUPTIONS();
 	SHM_UNPROTECT();
 	ZCSG(restart_pending) = 1;
 	ZCSG(restart_reason) = reason;
@@ -2894,6 +2914,7 @@ void zend_accel_schedule_restart(zend_accel_restart_reason reason)
 		ZCSG(force_restart_time) = 0;
 	}
 	SHM_PROTECT();
+	HANDLE_UNBLOCK_INTERRUPTIONS();
 }
 
 /* this is needed because on WIN32 lock is not decreased unless ZCG(counted) is set */
diff --git a/ext/standard/array.c b/ext/standard/array.c
index 67aec057b8..40c093eff3 100644
--- a/ext/standard/array.c
+++ b/ext/standard/array.c
@@ -2395,7 +2395,6 @@ static void php_array_data_shuffle(zval *array) /* {{{ */
 			}
 		}
 	}
-	HANDLE_BLOCK_INTERRUPTIONS();
 	hash->nNumUsed = n_elems;
 	hash->nInternalPointer = 0;
 
@@ -2411,7 +2410,6 @@ static void php_array_data_shuffle(zval *array) /* {{{ */
 	if (!(hash->u.flags & HASH_FLAG_PACKED)) {
 		zend_hash_to_packed(hash);
 	}
-	HANDLE_UNBLOCK_INTERRUPTIONS();
 }
 /* }}} */
 
@@ -4994,7 +4992,6 @@ PHP_FUNCTION(array_multisort)
 	zend_qsort(indirect, array_size, sizeof(Bucket *), php_multisort_compare, (swap_func_t)array_bucket_p_sawp);
 
 	/* Restructure the arrays based on sorted indirect - this is mostly taken from zend_hash_sort() function. */
-	HANDLE_BLOCK_INTERRUPTIONS();
 	for (i = 0; i < num_arrays; i++) {
 		int repack;
 
@@ -5018,7 +5015,6 @@ PHP_FUNCTION(array_multisort)
 			zend_hash_rehash(hash);
 		}
 	}
-	HANDLE_UNBLOCK_INTERRUPTIONS();
 
 	/* Clean up. */
 	for (i = 0; i < array_size; i++) {
diff --git a/sapi/phpdbg/phpdbg.h b/sapi/phpdbg/phpdbg.h
index c77bc1c530..2f95a80f04 100644
--- a/sapi/phpdbg/phpdbg.h
+++ b/sapi/phpdbg/phpdbg.h
@@ -47,6 +47,9 @@
 #include "zend_stream.h"
 #ifndef _WIN32
 #	include "zend_signal.h"
+# if !defined(ZEND_SIGNALS) && defined(HAVE_SIGNAL_H)
+#  include <signal.h>
+# endif
 #endif
 #include "SAPI.h"
 #include <fcntl.h>