ZendAccelerator.c

/*
 +----------------------------------------------------------------------+
 | Zend OPcache |
 +----------------------------------------------------------------------+
 | Copyright (c) The PHP Group |
 +----------------------------------------------------------------------+
 | This source file is subject to version 3.01 of the PHP license, |
 | that is bundled with this package in the file LICENSE, and is |
 | available through the world-wide-web at the following url: |
 | https://www.php.net/license/3_01.txt |
 | If you did not receive a copy of the PHP license and are unable to |
 | obtain it through the world-wide-web, please send a note to |
 | license@php.net so we can mail you a copy immediately. |
 +----------------------------------------------------------------------+
 | Authors: Andi Gutmans <andi@php.net> |
 | Zeev Suraski <zeev@php.net> |
 | Stanislav Malyshev <stas@zend.com> |
 | Dmitry Stogov <dmitry@php.net> |
 +----------------------------------------------------------------------+
*/

#include"main/php.h"
#include"main/php_globals.h"
#include"zend.h"
#include"zend_extensions.h"
#include"zend_compile.h"
#include"ZendAccelerator.h"
#include"zend_persist.h"
#include"zend_shared_alloc.h"
#include"zend_accelerator_module.h"
#include"zend_accelerator_blacklist.h"
#include"zend_list.h"
#include"zend_execute.h"
#include"zend_vm.h"
#include"zend_inheritance.h"
#include"zend_exceptions.h"
#include"zend_mmap.h"
#include"zend_observer.h"
#include"main/php_main.h"
#include"main/SAPI.h"
#include"main/php_streams.h"
#include"main/php_open_temporary_file.h"
#include"zend_API.h"
#include"zend_ini.h"
#include"zend_virtual_cwd.h"
#include"zend_accelerator_util_funcs.h"
#include"zend_accelerator_hash.h"
#include"zend_file_cache.h"
#include"ext/pcre/php_pcre.h"
#include"ext/standard/basic_functions.h"

#ifdefZEND_WIN32
# include"ext/hash/php_hash.h"
# include"ext/standard/md5.h"
#endif

#ifdefHAVE_JIT
# include"jit/zend_jit.h"
#endif

#ifndefZEND_WIN32
#include<netdb.h>
#endif

#ifdefZEND_WIN32
typedefintuid_t;
typedefintgid_t;
#include<io.h>
#include<lmcons.h>
#endif

#ifndefZEND_WIN32
# include<sys/time.h>
#else
# include<process.h>
#endif

#ifdefHAVE_UNISTD_H
# include<unistd.h>
#endif
#include<fcntl.h>
#include<signal.h>
#include<time.h>

#ifndefZEND_WIN32
# include<sys/types.h>
# include<sys/wait.h>
# include<sys/ipc.h>
# include<pwd.h>
# include<grp.h>
#endif

#include<sys/stat.h>
#include<errno.h>

#ifdef__AVX__
#include<immintrin.h>
#endif

ZEND_EXTENSION();

#ifndefZTS
zend_accel_globalsaccel_globals;
#else
intaccel_globals_id;
#if defined(COMPILE_DL_OPCACHE)
ZEND_TSRMLS_CACHE_DEFINE()
#endif
#endif

/* Points to the structure shared across all PHP processes */
zend_accel_shared_globals*accel_shared_globals=NULL;

/* true globals, no need for thread safety */
#ifdefZEND_WIN32
characcel_uname_id[32];
#endif
boolaccel_startup_ok= false;
staticconstchar*zps_failure_reason=NULL;
constchar*zps_api_failure_reason=NULL;
boolfile_cache_only= false; /* process uses file cache only */
#ifENABLE_FILE_CACHE_FALLBACK
boolfallback_process= false; /* process uses file cache fallback */
#endif

staticzend_op_array*(*accelerator_orig_compile_file)(zend_file_handle*file_handle, inttype);
staticzend_class_entry* (*accelerator_orig_inheritance_cache_get)(zend_class_entry*ce, zend_class_entry*parent, zend_class_entry**traits_and_interfaces);
staticzend_class_entry* (*accelerator_orig_inheritance_cache_add)(zend_class_entry*ce, zend_class_entry*proto, zend_class_entry*parent, zend_class_entry**traits_and_interfaces, HashTable*dependencies);
staticzend_result (*accelerator_orig_zend_stream_open_function)(zend_file_handle*handle );
staticzend_string*(*accelerator_orig_zend_resolve_path)(zend_string*filename);
staticzif_handlerorig_chdir=NULL;
staticZEND_INI_MH((*orig_include_path_on_modify)) =NULL;
staticzend_result (*orig_post_startup_cb)(void);

staticzend_resultaccel_post_startup(void);
staticzend_resultaccel_finish_startup(void);

staticvoidpreload_shutdown(void);
staticvoidpreload_activate(void);
staticvoidpreload_restart(void);

#ifdefZEND_WIN32
# defineINCREMENT(v) InterlockedIncrement64(&ZCSG(v))
# defineDECREMENT(v) InterlockedDecrement64(&ZCSG(v))
# defineLOCKVAL(v) (ZCSG(v))
#endif

/**
 * Clear AVX/SSE2-aligned memory.
 */
staticvoidbzero_aligned(void*mem, size_tsize)
{
#if defined(__x86_64__)
memset(mem, 0, size);
#elif defined(__AVX__)
char*p= (char*)mem;
char*end=p+size;
__m256iymm0=_mm256_setzero_si256();

while (p<end) {
_mm256_store_si256((__m256i*)p, ymm0);
_mm256_store_si256((__m256i*)(p+32), ymm0);
p+=64;
 }
#elif defined(__SSE2__)
char*p= (char*)mem;
char*end=p+size;
__m128ixmm0=_mm_setzero_si128();

while (p<end) {
_mm_store_si128((__m128i*)p, xmm0);
_mm_store_si128((__m128i*)(p+16), xmm0);
_mm_store_si128((__m128i*)(p+32), xmm0);
_mm_store_si128((__m128i*)(p+48), xmm0);
p+=64;
 }
#else
memset(mem, 0, size);
#endif
}

#ifdefZEND_WIN32
statictime_tzend_accel_get_time(void)
{
FILETIMEnow;
GetSystemTimeAsFileTime(&now);

return (time_t) ((((((__int64)now.dwHighDateTime) << 32)|now.dwLowDateTime) -116444736000000000L)/10000000);
}
#else
# definezend_accel_get_time() time(NULL)
#endif

staticinlineboolis_cacheable_stream_path(constchar*filename)
{
returnmemcmp(filename, "file://", sizeof("file://") -1) ==0||
memcmp(filename, "phar://", sizeof("phar://") -1) ==0;
}

/* O+ overrides PHP chdir() function and remembers the current working directory
 * in ZCG(cwd) and ZCG(cwd_len). Later accel_getcwd() can use stored value and
 * avoid getcwd() call.
 */
staticZEND_FUNCTION(accel_chdir)
{
charcwd[MAXPATHLEN];

orig_chdir(INTERNAL_FUNCTION_PARAM_PASSTHRU);
if (VCWD_GETCWD(cwd, MAXPATHLEN)) {
if (ZCG(cwd)) {
zend_string_release_ex(ZCG(cwd), 0);
 }
ZCG(cwd) =zend_string_init(cwd, strlen(cwd), 0);
 } else {
if (ZCG(cwd)) {
zend_string_release_ex(ZCG(cwd), 0);
ZCG(cwd) =NULL;
 }
 }
ZCG(cwd_key_len) =0;
ZCG(cwd_check) = true;
}

staticinlinezend_string*accel_getcwd(void)
{
if (ZCG(cwd)) {
returnZCG(cwd);
 } else {
charcwd[MAXPATHLEN+1];

if (!VCWD_GETCWD(cwd, MAXPATHLEN)) {
returnNULL;
 }
ZCG(cwd) =zend_string_init(cwd, strlen(cwd), 0);
ZCG(cwd_key_len) =0;
ZCG(cwd_check) = true;
returnZCG(cwd);
 }
}

voidzend_accel_schedule_restart_if_necessary(zend_accel_restart_reasonreason)
{
if ((((double) ZSMMG(wasted_shared_memory)) / ZCG(accel_directives).memory_consumption) >= ZCG(accel_directives).max_wasted_percentage) {
zend_accel_schedule_restart(reason);
 }
}

/* O+ tracks changes of "include_path" directive. It stores all the requested
 * values in ZCG(include_paths) shared hash table, current value in
 * ZCG(include_path)/ZCG(include_path_len) and one letter "path key" in
 * ZCG(include_path_key).
 */
staticZEND_INI_MH(accel_include_path_on_modify)
{
intret=orig_include_path_on_modify(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);

if (ret==SUCCESS) {
ZCG(include_path) =new_value;
ZCG(include_path_key_len) =0;
ZCG(include_path_check) = true;
 }
returnret;
}

staticinlinevoidaccel_restart_enter(void)
{
#ifdefZEND_WIN32
INCREMENT(restart_in);
#else
structflockrestart_in_progress;

restart_in_progress.l_type=F_WRLCK;
restart_in_progress.l_whence=SEEK_SET;
restart_in_progress.l_start=2;
restart_in_progress.l_len=1;

if (fcntl(lock_file, F_SETLK, &restart_in_progress) ==-1) {
zend_accel_error(ACCEL_LOG_DEBUG, "RestartC(+1): %s (%d)", strerror(errno), errno);
 }
#endif
ZCSG(restart_in_progress) = true;
}

staticinlinevoidaccel_restart_leave(void)
{
#ifdefZEND_WIN32
ZCSG(restart_in_progress) = false;
DECREMENT(restart_in);
#else
structflockrestart_finished;

restart_finished.l_type=F_UNLCK;
restart_finished.l_whence=SEEK_SET;
restart_finished.l_start=2;
restart_finished.l_len=1;

ZCSG(restart_in_progress) = false;
if (fcntl(lock_file, F_SETLK, &restart_finished) ==-1) {
zend_accel_error(ACCEL_LOG_DEBUG, "RestartC(-1): %s (%d)", strerror(errno), errno);
 }
#endif
}

staticinlineintaccel_restart_is_active(void)
{
if (ZCSG(restart_in_progress)) {
#ifndefZEND_WIN32
structflockrestart_check;

restart_check.l_type=F_WRLCK;
restart_check.l_whence=SEEK_SET;
restart_check.l_start=2;
restart_check.l_len=1;

if (fcntl(lock_file, F_GETLK, &restart_check) ==-1) {
zend_accel_error(ACCEL_LOG_DEBUG, "RestartC: %s (%d)", strerror(errno), errno);
returnFAILURE;
 }
if (restart_check.l_type==F_UNLCK) {
ZCSG(restart_in_progress) = false;
return0;
 } else {
return1;
 }
#else
returnLOCKVAL(restart_in) !=0;
#endif
 }
return0;
}

/* Creates a read lock for SHM access */
staticinlinezend_resultaccel_activate_add(void)
{
#ifdefZEND_WIN32
SHM_UNPROTECT();
INCREMENT(mem_usage);
SHM_PROTECT();
#else
structflockmem_usage_lock;

mem_usage_lock.l_type=F_RDLCK;
mem_usage_lock.l_whence=SEEK_SET;
mem_usage_lock.l_start=1;
mem_usage_lock.l_len=1;

if (fcntl(lock_file, F_SETLK, &mem_usage_lock) ==-1) {
zend_accel_error(ACCEL_LOG_DEBUG, "UpdateC(+1): %s (%d)", strerror(errno), errno);
returnFAILURE;
 }
#endif
returnSUCCESS;
}

/* Releases a lock for SHM access */
staticinlinevoidaccel_deactivate_sub(void)
{
#ifdefZEND_WIN32
if (ZCG(counted)) {
SHM_UNPROTECT();
DECREMENT(mem_usage);
ZCG(counted) = false;
SHM_PROTECT();
 }
#else
structflockmem_usage_unlock;

mem_usage_unlock.l_type=F_UNLCK;
mem_usage_unlock.l_whence=SEEK_SET;
mem_usage_unlock.l_start=1;
mem_usage_unlock.l_len=1;

if (fcntl(lock_file, F_SETLK, &mem_usage_unlock) ==-1) {
zend_accel_error(ACCEL_LOG_DEBUG, "UpdateC(-1): %s (%d)", strerror(errno), errno);
 }
#endif
}

staticinlinevoidaccel_unlock_all(void)
{
#ifdefZEND_WIN32
accel_deactivate_sub();
#else
if (lock_file==-1) {
return;
 }

structflockmem_usage_unlock_all;

mem_usage_unlock_all.l_type=F_UNLCK;
mem_usage_unlock_all.l_whence=SEEK_SET;
mem_usage_unlock_all.l_start=0;
mem_usage_unlock_all.l_len=0;

if (fcntl(lock_file, F_SETLK, &mem_usage_unlock_all) ==-1) {
zend_accel_error(ACCEL_LOG_DEBUG, "UnlockAll: %s (%d)", strerror(errno), errno);
 }
#endif
}

/* Interned strings support */

/* O+ disables creation of interned strings by regular PHP compiler, instead,
 * it creates interned strings in shared memory when saves a script.
 * Such interned strings are shared across all PHP processes
 */

#defineSTRTAB_INVALID_POS 0

#defineSTRTAB_HASH_TO_SLOT(tab, h) \
 ((zend_string_table_pos_t*)((char*)(tab) + sizeof(*(tab)) + ((h) & (tab)->nTableMask)))
#defineSTRTAB_STR_TO_POS(tab, s) \
 ((zend_string_table_pos_t)(((char*)s - (char*)(tab)) / ZEND_STRING_TABLE_POS_ALIGNMENT))
#defineSTRTAB_POS_TO_STR(tab, pos) \
 ((zend_string*)((char*)(tab) + ((uintptr_t)(pos) * ZEND_STRING_TABLE_POS_ALIGNMENT)))
#defineSTRTAB_COLLISION(s) \
 (*((zend_string_table_pos_t*)((char*)s - sizeof(zend_string_table_pos_t))))
#defineSTRTAB_STR_SIZE(s) \
 ZEND_MM_ALIGNED_SIZE_EX(_ZSTR_STRUCT_SIZE(ZSTR_LEN(s)) + sizeof(zend_string_table_pos_t), ZEND_STRING_TABLE_POS_ALIGNMENT)
#defineSTRTAB_NEXT(s) \
 ((zend_string*)((char*)(s) + STRTAB_STR_SIZE(s)))

staticvoidaccel_interned_strings_restore_state(void)
{
zend_string*s, *top;
zend_string_table_pos_t*hash_slot, n;

/* clear removed content */
memset(ZCSG(interned_strings).saved_top,
0, (char*)ZCSG(interned_strings).top- (char*)ZCSG(interned_strings).saved_top);

/* Reset "top" */
ZCSG(interned_strings).top=ZCSG(interned_strings).saved_top;

/* rehash */
memset((char*)&ZCSG(interned_strings) +sizeof(zend_string_table),
STRTAB_INVALID_POS,
 (char*)ZCSG(interned_strings).start-
 ((char*)&ZCSG(interned_strings) +sizeof(zend_string_table)));
s=ZCSG(interned_strings).start;
top=ZCSG(interned_strings).top;
n=0;
if (EXPECTED(s<top)) {
do {
if (ZSTR_HAS_CE_CACHE(s)) {
/* Discard non-global CE_CACHE slots on reset. */
uintptr_tidx= (GC_REFCOUNT(s) -1) / sizeof(void*);
if (idx >= ZCSG(map_ptr_last)) {
GC_SET_REFCOUNT(s, 2);
GC_DEL_FLAGS(s, IS_STR_CLASS_NAME_MAP_PTR);
 }
 }

hash_slot=STRTAB_HASH_TO_SLOT(&ZCSG(interned_strings), ZSTR_H(s));
STRTAB_COLLISION(s) =*hash_slot;
*hash_slot=STRTAB_STR_TO_POS(&ZCSG(interned_strings), s);
s=STRTAB_NEXT(s);
n++;
 } while (s<top);
 }
ZCSG(interned_strings).nNumOfElements=n;
}

staticvoidaccel_interned_strings_save_state(void)
{
ZCSG(interned_strings).saved_top=ZCSG(interned_strings).top;
}

staticzend_always_inlinezend_string*accel_find_interned_string(zend_string*str)
{
zend_ulongh;
zend_string_table_pos_tpos;
zend_string*s;

if (IS_ACCEL_INTERNED(str)) {
/* this is already an interned string */
returnstr;
 }

if (!ZCG(counted)) {
if (!ZCG(accelerator_enabled) ||accel_activate_add() ==FAILURE) {
returnNULL;
 }
ZCG(counted) = true;
 }

h=zend_string_hash_val(str);

/* check for existing interned string */
pos=*STRTAB_HASH_TO_SLOT(&ZCSG(interned_strings), h);
if (EXPECTED(pos!=STRTAB_INVALID_POS)) {
do {
s=STRTAB_POS_TO_STR(&ZCSG(interned_strings), pos);
if (EXPECTED(ZSTR_H(s) ==h) &&zend_string_equal_content(s, str)) {
returns;
 }
pos=STRTAB_COLLISION(s);
 } while (pos!=STRTAB_INVALID_POS);
 }

returnNULL;
}

zend_string*ZEND_FASTCALLaccel_new_interned_string(zend_string*str)
{
zend_ulongh;
zend_string_table_pos_tpos, *hash_slot;
zend_string*s;

if (UNEXPECTED(file_cache_only)) {
returnstr;
 }

if (IS_ACCEL_INTERNED(str)) {
/* this is already an interned string */
returnstr;
 }

h=zend_string_hash_val(str);

/* check for existing interned string */
hash_slot=STRTAB_HASH_TO_SLOT(&ZCSG(interned_strings), h);
pos=*hash_slot;
if (EXPECTED(pos!=STRTAB_INVALID_POS)) {
do {
s=STRTAB_POS_TO_STR(&ZCSG(interned_strings), pos);
if (EXPECTED(ZSTR_H(s) ==h) &&zend_string_equal_content(s, str)) {
 goto finish;
 }
pos=STRTAB_COLLISION(s);
 } while (pos!=STRTAB_INVALID_POS);
 }

if (UNEXPECTED((char*)ZCSG(interned_strings).end- (char*)ZCSG(interned_strings).top<STRTAB_STR_SIZE(str))) {
/* no memory, return the same non-interned string */
zend_accel_error(ACCEL_LOG_WARNING, "Interned string buffer overflow");
returnstr;
 }

/* create new interning string in shared interned strings buffer */
ZCSG(interned_strings).nNumOfElements++;
s=ZCSG(interned_strings).top;
hash_slot=STRTAB_HASH_TO_SLOT(&ZCSG(interned_strings), h);
STRTAB_COLLISION(s) =*hash_slot;
*hash_slot=STRTAB_STR_TO_POS(&ZCSG(interned_strings), s);
GC_SET_REFCOUNT(s, 2);
GC_TYPE_INFO(s) =GC_STRING | ((IS_STR_INTERNED | IS_STR_PERMANENT) << GC_FLAGS_SHIFT)| (ZSTR_IS_VALID_UTF8(str) ? IS_STR_VALID_UTF8 : 0);
ZSTR_H(s) =h;
ZSTR_LEN(s) =ZSTR_LEN(str);
memcpy(ZSTR_VAL(s), ZSTR_VAL(str), ZSTR_LEN(s) +1);
ZCSG(interned_strings).top=STRTAB_NEXT(s);

finish:
/* Transfer CE_CACHE map ptr slot to new interned string.
 * Should only happen for permanent interned strings with permanent map_ptr slot. */
if (ZSTR_HAS_CE_CACHE(str) && !ZSTR_HAS_CE_CACHE(s)) {
ZEND_ASSERT(GC_FLAGS(str) &IS_STR_PERMANENT);
GC_SET_REFCOUNT(s, GC_REFCOUNT(str));
GC_ADD_FLAGS(s, IS_STR_CLASS_NAME_MAP_PTR);
 }

zend_string_release(str);
returns;
}

staticzend_string*ZEND_FASTCALLaccel_new_interned_string_for_php(zend_string*str)
{
zend_string_hash_val(str);
if (ZCG(counted)) {
zend_string*ret=accel_find_interned_string(str);

if (ret) {
zend_string_release(str);
returnret;
 }
 }
returnstr;
}

staticzend_always_inlinezend_string*accel_find_interned_string_ex(zend_ulongh, constchar*str, size_tsize)
{
zend_string_table_pos_tpos;
zend_string*s;

/* check for existing interned string */
pos=*STRTAB_HASH_TO_SLOT(&ZCSG(interned_strings), h);
if (EXPECTED(pos!=STRTAB_INVALID_POS)) {
do {
s=STRTAB_POS_TO_STR(&ZCSG(interned_strings), pos);
if (EXPECTED(ZSTR_H(s) ==h) &&zend_string_equals_cstr(s, str, size)) {
returns;
 }
pos=STRTAB_COLLISION(s);
 } while (pos!=STRTAB_INVALID_POS);
 }
returnNULL;
}

staticzend_string*ZEND_FASTCALLaccel_init_interned_string_for_php(constchar*str, size_tsize, boolpermanent)
{
if (ZCG(counted)) {
zend_ulongh=zend_inline_hash_func(str, size);
zend_string*ret=accel_find_interned_string_ex(h, str, size);

if (!ret) {
ret=zend_string_init(str, size, permanent);
ZSTR_H(ret) =h;
 }

returnret;
 }

returnzend_string_init(str, size, permanent);
}

staticinlinevoidaccel_copy_permanent_list_types(
zend_new_interned_string_func_tnew_interned_string, zend_typetype)
{
zend_type*single_type;
ZEND_TYPE_FOREACH(type, single_type) {
if (ZEND_TYPE_HAS_LIST(*single_type)) {
ZEND_ASSERT(ZEND_TYPE_IS_INTERSECTION(*single_type));
accel_copy_permanent_list_types(new_interned_string, *single_type);
 }
if (ZEND_TYPE_HAS_NAME(*single_type)) {
ZEND_TYPE_SET_PTR(*single_type, new_interned_string(ZEND_TYPE_NAME(*single_type)));
 }
 } ZEND_TYPE_FOREACH_END();
}

/* Copy PHP interned strings from PHP process memory into the shared memory */
staticvoidaccel_copy_permanent_strings(zend_new_interned_string_func_tnew_interned_string)
{
uint32_tj;
Bucket*p, *q;
HashTable*ht;

/* empty string */
zend_empty_string=new_interned_string(zend_empty_string);
for (j=0; j<256; j++) {
zend_one_char_string[j] =new_interned_string(ZSTR_CHAR(j));
 }
for (j=0; j<ZEND_STR_LAST_KNOWN; j++) {
zend_known_strings[j] =new_interned_string(zend_known_strings[j]);
 }

/* function table hash keys */
ZEND_HASH_MAP_FOREACH_BUCKET(CG(function_table), p) {
if (p->key) {
p->key=new_interned_string(p->key);
 }
if (Z_FUNC(p->val)->common.function_name) {
Z_FUNC(p->val)->common.function_name=new_interned_string(Z_FUNC(p->val)->common.function_name);
 }
if (Z_FUNC(p->val)->common.arg_info&&
 (Z_FUNC(p->val)->common.fn_flags& (ZEND_ACC_HAS_RETURN_TYPE|ZEND_ACC_HAS_TYPE_HINTS))) {
uint32_ti;
uint32_tnum_args=Z_FUNC(p->val)->common.num_args+1;
zend_arg_info*arg_info=Z_FUNC(p->val)->common.arg_info-1;

if (Z_FUNC(p->val)->common.fn_flags&ZEND_ACC_VARIADIC) {
num_args++;
 }
for (i=0 ; i<num_args; i++) {
accel_copy_permanent_list_types(new_interned_string, arg_info[i].type);
 }
 }
 } ZEND_HASH_FOREACH_END();

/* class table hash keys, class names, properties, methods, constants, etc */
ZEND_HASH_MAP_FOREACH_BUCKET(CG(class_table), p) {
zend_class_entry*ce;

ce= (zend_class_entry*)Z_PTR(p->val);

if (p->key) {
p->key=new_interned_string(p->key);
 }

if (ce->name) {
ce->name=new_interned_string(ce->name);
ZEND_ASSERT(ZSTR_HAS_CE_CACHE(ce->name));
 }

ZEND_HASH_MAP_FOREACH_BUCKET(&ce->properties_info, q) {
zend_property_info*info;

info= (zend_property_info*)Z_PTR(q->val);

if (q->key) {
q->key=new_interned_string(q->key);
 }

if (info->name) {
info->name=new_interned_string(info->name);
 }
 } ZEND_HASH_FOREACH_END();

ZEND_HASH_MAP_FOREACH_BUCKET(&ce->function_table, q) {
if (q->key) {
q->key=new_interned_string(q->key);
 }
if (Z_FUNC(q->val)->common.function_name) {
Z_FUNC(q->val)->common.function_name=new_interned_string(Z_FUNC(q->val)->common.function_name);
 }
 } ZEND_HASH_FOREACH_END();

ZEND_HASH_MAP_FOREACH_BUCKET(&ce->constants_table, q) {
zend_class_constant*c;

if (q->key) {
q->key=new_interned_string(q->key);
 }
c= (zend_class_constant*)Z_PTR(q->val);
if (Z_TYPE(c->value) ==IS_STRING) {
ZVAL_STR(&c->value, new_interned_string(Z_STR(c->value)));
 }
 } ZEND_HASH_FOREACH_END();
 } ZEND_HASH_FOREACH_END();

/* constant hash keys */
ZEND_HASH_MAP_FOREACH_BUCKET(EG(zend_constants), p) {
zend_constant*c;

if (p->key) {
p->key=new_interned_string(p->key);
 }
c= (zend_constant*)Z_PTR(p->val);
if (c->name) {
c->name=new_interned_string(c->name);
 }
if (Z_TYPE(c->value) ==IS_STRING) {
ZVAL_STR(&c->value, new_interned_string(Z_STR(c->value)));
 }
 } ZEND_HASH_FOREACH_END();

/* auto globals hash keys and names */
ZEND_HASH_MAP_FOREACH_BUCKET(CG(auto_globals), p) {
zend_auto_global*auto_global;

auto_global= (zend_auto_global*)Z_PTR(p->val);

zend_string_addref(auto_global->name);
auto_global->name=new_interned_string(auto_global->name);
if (p->key) {
p->key=new_interned_string(p->key);
 }
 } ZEND_HASH_FOREACH_END();

ZEND_HASH_MAP_FOREACH_BUCKET(&module_registry, p) {
if (p->key) {
p->key=new_interned_string(p->key);
 }
 } ZEND_HASH_FOREACH_END();

ZEND_HASH_MAP_FOREACH_BUCKET(EG(ini_directives), p) {
zend_ini_entry*entry= (zend_ini_entry*)Z_PTR(p->val);

if (p->key) {
p->key=new_interned_string(p->key);
 }
if (entry->name) {
entry->name=new_interned_string(entry->name);
 }
if (entry->value) {
entry->value=new_interned_string(entry->value);
 }
if (entry->orig_value) {
entry->orig_value=new_interned_string(entry->orig_value);
 }
 } ZEND_HASH_FOREACH_END();

ht=php_get_stream_filters_hash_global();
ZEND_HASH_MAP_FOREACH_BUCKET(ht, p) {
if (p->key) {
p->key=new_interned_string(p->key);
 }
 } ZEND_HASH_FOREACH_END();

ht=php_stream_get_url_stream_wrappers_hash_global();
ZEND_HASH_MAP_FOREACH_BUCKET(ht, p) {
if (p->key) {
p->key=new_interned_string(p->key);
 }
 } ZEND_HASH_FOREACH_END();

ht=php_stream_xport_get_hash();
ZEND_HASH_MAP_FOREACH_BUCKET(ht, p) {
if (p->key) {
p->key=new_interned_string(p->key);
 }
 } ZEND_HASH_FOREACH_END();
}

staticzend_string*ZEND_FASTCALLaccel_replace_string_by_shm_permanent(zend_string*str)
{
zend_string*ret=accel_find_interned_string(str);

if (ret) {
zend_string_release(str);
returnret;
 }
returnstr;
}

staticvoidaccel_use_shm_interned_strings(void)
{
HANDLE_BLOCK_INTERRUPTIONS();
SHM_UNPROTECT();
zend_shared_alloc_lock();

if (ZCSG(interned_strings).saved_top==NULL) {
accel_copy_permanent_strings(accel_new_interned_string);
 } else {
ZCG(counted) = true;
accel_copy_permanent_strings(accel_replace_string_by_shm_permanent);
ZCG(counted) = false;
 }
accel_interned_strings_save_state();

zend_shared_alloc_unlock();
SHM_PROTECT();
HANDLE_UNBLOCK_INTERRUPTIONS();
}

#ifndefZEND_WIN32
staticinlinevoidkill_all_lockers(structflock*mem_usage_check)
{
inttries;
/* so that other process won't try to force while we are busy cleaning up */
ZCSG(force_restart_time) =0;
while (mem_usage_check->l_pid>0) {
/* Try SIGTERM first, switch to SIGKILL if not successful. */
intsignal=SIGTERM;
errno=0;
boolsuccess= false;
tries=10;

while (tries--) {
zend_accel_error(ACCEL_LOG_WARNING, "Attempting to kill locker %d", mem_usage_check->l_pid);
if (kill(mem_usage_check->l_pid, signal)) {
if (errno==ESRCH) {
/* Process died before the signal was sent */
success= true;
zend_accel_error(ACCEL_LOG_WARNING, "Process %d died before SIGKILL was sent", mem_usage_check->l_pid);
 } elseif (errno!=0) {
zend_accel_error(ACCEL_LOG_WARNING, "Failed to send SIGKILL to locker %d: %s", mem_usage_check->l_pid, strerror(errno));
 }
break;
 }
/* give it a chance to die */
usleep(20000);
if (kill(mem_usage_check->l_pid, 0)) {
if (errno==ESRCH) {
/* successfully killed locker, process no longer exists */
success= true;
zend_accel_error(ACCEL_LOG_WARNING, "Killed locker %d", mem_usage_check->l_pid);
 } elseif (errno!=0) {
zend_accel_error(ACCEL_LOG_WARNING, "Failed to check locker %d: %s", mem_usage_check->l_pid, strerror(errno));
 }
break;
 }
usleep(10000);
/* If SIGTERM was not sufficient, use SIGKILL. */
signal=SIGKILL;
 }
if (!success) {
/* errno is not ESRCH or we ran out of tries to kill the locker */
ZCSG(force_restart_time) =time(NULL); /* restore forced restart request */
/* cannot kill the locker, bail out with error */
zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Cannot kill process %d!", mem_usage_check->l_pid);
 }

mem_usage_check->l_type=F_WRLCK;
mem_usage_check->l_whence=SEEK_SET;
mem_usage_check->l_start=1;
mem_usage_check->l_len=1;
mem_usage_check->l_pid=-1;
if (fcntl(lock_file, F_GETLK, mem_usage_check) ==-1) {
zend_accel_error(ACCEL_LOG_DEBUG, "KLockers: %s (%d)", strerror(errno), errno);
break;
 }

if (mem_usage_check->l_type==F_UNLCK||mem_usage_check->l_pid <= 0) {
break;
 }
 }
}
#endif

staticinlineboolaccel_is_inactive(void)
{
#ifdefZEND_WIN32
/* on Windows, we don't need kill_all_lockers() because SAPIs
 that work on Windows don't manage child processes (and we
 can't do anything about hanging threads anyway); therefore
 on Windows, we can simply manage this counter with atomics
 instead of flocks (atomics are much faster but they don't
 provide us with the PID of locker processes) */

if (LOCKVAL(mem_usage) ==0) {
return true;
 }
#else
structflockmem_usage_check;

mem_usage_check.l_type=F_WRLCK;
mem_usage_check.l_whence=SEEK_SET;
mem_usage_check.l_start=1;
mem_usage_check.l_len=1;
mem_usage_check.l_pid=-1;
if (fcntl(lock_file, F_GETLK, &mem_usage_check) ==-1) {
zend_accel_error(ACCEL_LOG_DEBUG, "UpdateC: %s (%d)", strerror(errno), errno);
return false;
 }
if (mem_usage_check.l_type==F_UNLCK) {
return true;
 }

if (ZCG(accel_directives).force_restart_timeout
&&ZCSG(force_restart_time)
&&time(NULL) >= ZCSG(force_restart_time)) {
zend_accel_error(ACCEL_LOG_WARNING, "Forced restart at %ld (after "ZEND_LONG_FMT" seconds), locked by %d", (long)time(NULL), ZCG(accel_directives).force_restart_timeout, mem_usage_check.l_pid);
kill_all_lockers(&mem_usage_check);

return false; /* next request should be able to restart it */
 }
#endif

return false;
}

staticintzend_get_stream_timestamp(constchar*filename, zend_stat_t*statbuf)
{
php_stream_wrapper*wrapper;
php_stream_statbufstream_statbuf;
intret, er;

if (!filename) {
returnFAILURE;
 }

wrapper=php_stream_locate_url_wrapper(filename, NULL, STREAM_LOCATE_WRAPPERS_ONLY);
if (!wrapper) {
returnFAILURE;
 }
if (!wrapper->wops|| !wrapper->wops->url_stat) {
statbuf->st_mtime=1;
returnSUCCESS; /* anything other than 0 is considered to be a valid timestamp */
 }

er=EG(error_reporting);
EG(error_reporting) =0;
zend_try {
ret=wrapper->wops->url_stat(wrapper, (char*)filename, PHP_STREAM_URL_STAT_QUIET, &stream_statbuf, NULL);
 } zend_catch {
ret=-1;
 } zend_end_try();
EG(error_reporting) =er;

if (ret!=0) {
returnFAILURE;
 }

*statbuf=stream_statbuf.sb;
returnSUCCESS;
}

#ifdefZEND_WIN32
staticaccel_time_tzend_get_file_handle_timestamp_win(zend_file_handle*file_handle, size_t*size)
{
staticunsigned __int64utc_base=0;
staticFILETIMEutc_base_ft;
WIN32_FILE_ATTRIBUTE_DATAfdata;

if (!file_handle->opened_path) {
return0;
 }

if (!utc_base) {
SYSTEMTIMEst;

st.wYear=1970;
st.wMonth=1;
st.wDay=1;
st.wHour=0;
st.wMinute=0;
st.wSecond=0;
st.wMilliseconds=0;

SystemTimeToFileTime (&st, &utc_base_ft);
utc_base= (((unsigned __int64)utc_base_ft.dwHighDateTime) << 32) +utc_base_ft.dwLowDateTime;
 }

if (file_handle->opened_path&&GetFileAttributesEx(file_handle->opened_path->val, GetFileExInfoStandard, &fdata) !=0) {
unsigned __int64ftime;

if (CompareFileTime (&fdata.ftLastWriteTime, &utc_base_ft) <0) {
return0;
 }