xcache
/
xcache
1
0
Fork 0
Code Releases Activity
XCache is a fast, stable PHP opcode cacher that has been proven and is now running on production servers under high load. https://xcache.lighttpd.net/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1180 Commits
9 Branches
44 Tags
1.5 MiB
 
 
 
 
 
 
Tree: f664f5a518
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'f664f5a518'
${ noResults }
xcache/xcache.c

1040 lines
29 KiB
Raw Blame History

/* {{{ macros */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include "xcache.h"
#ifdef HAVE_XCACHE_OPTIMIZER
# include "mod_optimizer/xc_optimizer.h"
#endif
#ifdef HAVE_XCACHE_CACHER
# include "mod_cacher/xc_cacher.h"
#endif
#ifdef HAVE_XCACHE_COVERAGER
# include "mod_coverager/xc_coverager.h"
#endif
#ifdef HAVE_XCACHE_DISASSEMBLER
# include "mod_disassembler/xc_disassembler.h"
#endif
#include "xcache_globals.h"
#include "xcache/xc_extension.h"
#include "xcache/xc_ini.h"
#include "xcache/xc_const_string.h"
#include "xcache/xc_opcode_spec.h"
#include "xcache/xc_utils.h"
#include "util/xc_vector.h"
#include "php.h"
#include "ext/standard/info.h"
#include "ext/standard/php_string.h"
#include "SAPI.h"
/* }}} */
/* {{{ globals */
static char *xc_coredump_dir = NULL;
#ifdef ZEND_WIN32
static zend_ulong xc_coredump_type = 0;
#endif
static zend_bool xc_disable_on_crash = 0;
static zend_compile_file_t *old_compile_file = NULL;
zend_bool xc_test = 0;
ZEND_DECLARE_MODULE_GLOBALS(xcache)
/* }}} */
static zend_op_array *xc_check_initial_compile_file(zend_file_handle *h, int type TSRMLS_DC) /* {{{ */
{
XG(initial_compile_file_called) = 1;
return old_compile_file(h, type TSRMLS_CC);
}
/* }}} */
/* devel helper function */
#if 0
static void xc_list_extensions() /* {{{ */
{
zend_llist_element *element;
zend_extension *ext;
fprintf(stderr, "extensions:\n");
for (element = zend_extensions.head; element; element = element->next) {
ext = (zend_extension *) element->data;
fprintf(stderr, " - %s\n", ext->name);
}
}
/* }}} */
#endif
/* module helper function */
static int xc_init_constant(int module_number TSRMLS_DC) /* {{{ */
{
typedef struct {
const char *prefix;
zend_uchar (*getsize)();
const char *(*get)(zend_uchar i);
} xc_nameinfo_t;
xc_nameinfo_t nameinfos[] = {
{ "", xc_get_op_type_count, xc_get_op_type },
{ "", xc_get_data_type_count, xc_get_data_type },
{ "", xc_get_opcode_count, xc_get_opcode },
{ "OPSPEC_", xc_get_op_spec_count, xc_get_op_spec },
{ NULL, NULL, NULL }
};
int undefdone = 0;
xc_nameinfo_t *p;
for (p = nameinfos; p->getsize; p ++) {
zend_uchar i, count;
char const_name[96];
int const_name_len;
count = p->getsize();
for (i = 0; i < count; i ++) {
const char *name = p->get(i);
if (!name) continue;
if (strcmp(name, "UNDEF") == 0) {
if (undefdone) continue;
undefdone = 1;
}
const_name_len = snprintf(const_name, sizeof(const_name), "XC_%s%s", p->prefix, name);
zend_register_long_constant(const_name, const_name_len+1, i, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);
}
}
zend_register_long_constant(XCACHE_STRS("XC_SIZEOF_TEMP_VARIABLE"), sizeof(temp_variable), CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);
zend_register_stringl_constant(XCACHE_STRS("XCACHE_VERSION"), XCACHE_STRL(XCACHE_VERSION), CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);
zend_register_stringl_constant(XCACHE_STRS("XCACHE_MODULES"), XCACHE_STRL(XCACHE_MODULES), CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);
return 0;
}
/* }}} */
/* {{{ PHP_GINIT_FUNCTION(xcache) */
#ifdef __GNUC__
#pragma GCC push_options
#pragma GCC diagnostic ignored "-Wshadow"
#endif
#ifdef PHP_GINIT_FUNCTION
static PHP_GINIT_FUNCTION(xcache)
#else
static void xc_init_globals(zend_xcache_globals* xcache_globals TSRMLS_DC)
#endif
{
#ifdef __GNUC__
#pragma GCC pop_options
#endif
memset(xcache_globals, 0, sizeof(zend_xcache_globals));
#ifdef HAVE_XCACHE_CONSTANT
zend_hash_init_ex(&xcache_globals->internal_constant_table, 1, NULL, (dtor_func_t) xc_zend_constant_dtor, 1, 0);
#endif
zend_hash_init_ex(&xcache_globals->internal_function_table, 1, NULL, NULL, 1, 0);
zend_hash_init_ex(&xcache_globals->internal_class_table, 1, NULL, NULL, 1, 0);
}
/* }}} */
/* {{{ PHP_GSHUTDOWN_FUNCTION(xcache) */
static
#ifdef PHP_GSHUTDOWN_FUNCTION
PHP_GSHUTDOWN_FUNCTION(xcache)
#else
void xc_shutdown_globals(zend_xcache_globals* xcache_globals TSRMLS_DC)
#endif
{
size_t i;
if (xcache_globals->php_holds != NULL) {
for (i = 0; i < xcache_globals->php_holds_size; i ++) {
xc_vector_destroy(&xcache_globals->php_holds[i]);
}
free(xcache_globals->php_holds);
xcache_globals->php_holds = NULL;
xcache_globals->php_holds_size = 0;
}
if (xcache_globals->var_holds != NULL) {
for (i = 0; i < xcache_globals->var_holds_size; i ++) {
xc_vector_destroy(&xcache_globals->var_holds[i]);
}
free(xcache_globals->var_holds);
xcache_globals->var_holds = NULL;
xcache_globals->var_holds_size = 0;
}
if (xcache_globals->internal_table_copied) {
#ifdef HAVE_XCACHE_CONSTANT
zend_hash_destroy(&xcache_globals->internal_constant_table);
#endif
zend_hash_destroy(&xcache_globals->internal_function_table);
zend_hash_destroy(&xcache_globals->internal_class_table);
}
}
/* }}} */
#ifdef HAVE_XCACHE_DPRINT
/* {{{ proto bool xcache_dprint(mixed value)
Prints internal struct of an zval (debug only) */
#include "xc_processor.h"
#ifdef ZEND_BEGIN_ARG_INFO_EX
ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_dprint, 0, 0, 1)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
#else
static unsigned char arginfo_xcache_dprint[] = { 1, BYREF_NONE };
#endif
PHP_FUNCTION(xcache_dprint)
{
zval *value;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &value) == FAILURE) {
return;
}
xc_dprint_zval(value, 0 TSRMLS_CC);
}
/* }}} */
#endif
#ifdef HAVE_XCACHE_ASSEMBLER
/* {{{ proto string xcache_asm(string filename)
*/
PHP_FUNCTION(xcache_asm)
{
}
/* }}} */
#endif
#ifdef HAVE_XCACHE_ENCODER
/* {{{ proto string xcache_encode(string filename)
Encode php file into XCache opcode encoded format */
PHP_FUNCTION(xcache_encode)
{
}
/* }}} */
#endif
#ifdef HAVE_XCACHE_DECODER
/* {{{ proto bool xcache_decode_file(string filename)
Decode(load) opcode from XCache encoded format file */
PHP_FUNCTION(xcache_decode_file)
{
}
/* }}} */
/* {{{ proto bool xcache_decode_string(string data)
Decode(load) opcode from XCache encoded format data */
PHP_FUNCTION(xcache_decode_string)
{
}
/* }}} */
#endif
/* {{{ xc_call_getter */
typedef const char *(xc_name_getter_t)(zend_uchar type);
static void xc_call_getter(xc_name_getter_t getter, int count, INTERNAL_FUNCTION_PARAMETERS)
{
long spec;
const char *name;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &spec) == FAILURE) {
return;
}
if (spec >= 0 && spec < count) {
name = getter((zend_uchar) spec);
if (name) {
/* RETURN_STRING */
int len = (int) strlen(name);
return_value->value.str.len = len;
return_value->value.str.val = estrndup(name, len);
return_value->type = IS_STRING;
return;
}
}
RETURN_NULL();
}
/* }}} */
/* {{{ proto string xcache_get_op_type(int op_type) */
#ifdef ZEND_BEGIN_ARG_INFO_EX
ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_get_op_type, 0, 0, 1)
ZEND_ARG_INFO(0, op_type)
ZEND_END_ARG_INFO()
#else
static unsigned char arginfo_xcache_get_op_type[] = { 1, BYREF_NONE };
#endif
PHP_FUNCTION(xcache_get_op_type)
{
xc_call_getter(xc_get_op_type, xc_get_op_type_count(), INTERNAL_FUNCTION_PARAM_PASSTHRU);
}
/* }}} */
/* {{{ proto string xcache_get_data_type(int type) */
#ifdef ZEND_BEGIN_ARG_INFO_EX
ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_get_data_type, 0, 0, 1)
ZEND_ARG_INFO(0, type)
ZEND_END_ARG_INFO()
#else
static unsigned char arginfo_xcache_get_data_type[] = { 1, BYREF_NONE };
#endif
PHP_FUNCTION(xcache_get_data_type)
{
xc_call_getter(xc_get_data_type, xc_get_data_type_count(), INTERNAL_FUNCTION_PARAM_PASSTHRU);
}
/* }}} */
/* {{{ proto string xcache_get_opcode(int opcode) */
#ifdef ZEND_BEGIN_ARG_INFO_EX
ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_get_opcode, 0, 0, 1)
ZEND_ARG_INFO(0, opcode)
ZEND_END_ARG_INFO()
#else
static unsigned char arginfo_xcache_get_opcode[] = { 1, BYREF_NONE };
#endif
PHP_FUNCTION(xcache_get_opcode)
{
xc_call_getter(xc_get_opcode, xc_get_opcode_count(), INTERNAL_FUNCTION_PARAM_PASSTHRU);
}
/* }}} */
/* {{{ proto string xcache_get_op_spec(int op_type) */
#ifdef ZEND_BEGIN_ARG_INFO_EX
ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_get_op_spec, 0, 0, 1)
ZEND_ARG_INFO(0, op_type)
ZEND_END_ARG_INFO()
#else
static unsigned char arginfo_xcache_get_op_spec[] = { 1, BYREF_NONE };
#endif
PHP_FUNCTION(xcache_get_op_spec)
{
xc_call_getter(xc_get_op_spec, xc_get_op_spec_count(), INTERNAL_FUNCTION_PARAM_PASSTHRU);
}
/* }}} */
/* {{{ proto string xcache_get_opcode_spec(int opcode) */
#ifdef ZEND_BEGIN_ARG_INFO_EX
ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_get_opcode_spec, 0, 0, 1)
ZEND_ARG_INFO(0, opcode)
ZEND_END_ARG_INFO()
#else
static unsigned char arginfo_xcache_get_opcode_spec[] = { 1, BYREF_NONE };
#endif
PHP_FUNCTION(xcache_get_opcode_spec)
{
long spec;
const xc_opcode_spec_t *opspec;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &spec) == FAILURE) {
return;
}
if ((zend_uchar) spec <= xc_get_opcode_spec_count()) {
opspec = xc_get_opcode_spec((zend_uchar) spec);
if (opspec) {
array_init(return_value);
add_assoc_long_ex(return_value, XCACHE_STRS("ext"), opspec->ext);
add_assoc_long_ex(return_value, XCACHE_STRS("op1"), opspec->op1);
add_assoc_long_ex(return_value, XCACHE_STRS("op2"), opspec->op2);
add_assoc_long_ex(return_value, XCACHE_STRS("res"), opspec->res);
return;
}
}
RETURN_NULL();
}
/* }}} */
/* {{{ proto mixed xcache_get_special_value(zval value)
XCache internal use only: For decompiler to get static value with type fixed */
#ifdef ZEND_BEGIN_ARG_INFO_EX
ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_get_special_value, 0, 0, 1)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
#else
static unsigned char arginfo_xcache_get_special_value[] = { 1, BYREF_NONE };
#endif
PHP_FUNCTION(xcache_get_special_value)
{
zval *value;
zval value_copied;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &value) == FAILURE) {
return;
}
value_copied = *value;
value = &value_copied;
switch ((Z_TYPE_P(value) & IS_CONSTANT_TYPE_MASK)) {
case IS_CONSTANT:
value->type = UNISW(IS_STRING, UG(unicode) ? IS_UNICODE : IS_STRING);
RETURN_ZVAL(value, 1, 0);
break;
#ifdef IS_CONSTANT_ARRAY
case IS_CONSTANT_ARRAY:
value->type = IS_ARRAY;
RETURN_ZVAL(value, 1, 0);
break;
#endif
#ifdef IS_CONSTANT_AST
case IS_CONSTANT_AST:
RETURN_NULL();
break;
#endif
default:
if ((Z_TYPE_P(value) & ~IS_CONSTANT_TYPE_MASK)) {
value->type &= IS_CONSTANT_TYPE_MASK;
RETURN_ZVAL(value, 1, 0);
}
else {
RETURN_NULL();
}
}
}
/* }}} */
/* {{{ proto int xcache_get_type(zval value)
XCache internal use only for disassembler to get variable type in engine level */
#ifdef ZEND_BEGIN_ARG_INFO_EX
ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_get_type, 0, 0, 1)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
#else
static unsigned char arginfo_xcache_get_type[] = { 1, BYREF_NONE };
#endif
PHP_FUNCTION(xcache_get_type)
{
zval *value;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &value) == FAILURE) {
return;
}
RETURN_LONG(Z_TYPE_P(value));
}
/* }}} */
/* {{{ proto string xcache_coredump() */
#ifdef ZEND_BEGIN_ARG_INFO_EX
ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_coredump, 0, 0, 0)
ZEND_END_ARG_INFO()
#else
static unsigned char arginfo_xcache_coredump[] = { 1, BYREF_NONE };
#endif
PHP_FUNCTION(xcache_coredump)
{
if (xc_test) {
char *null_ptr = NULL;
*null_ptr = 0;
raise(SIGSEGV);
}
else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "xcache.test must be enabled to test xcache_coredump()");
}
}
/* }}} */
/* {{{ proto string xcache_is_autoglobal(string name) */
#ifdef ZEND_BEGIN_ARG_INFO_EX
ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_is_autoglobal, 0, 0, 1)
ZEND_ARG_INFO(0, name)
ZEND_END_ARG_INFO()
#else
static unsigned char arginfo_xcache_is_autoglobal[] = { 1, BYREF_NONE };
#endif
PHP_FUNCTION(xcache_is_autoglobal)
{
zval *name;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &name) == FAILURE) {
return;
}
#ifdef IS_UNICODE
convert_to_unicode(name);
#else
convert_to_string(name);
#endif
RETURN_BOOL(zend_u_hash_exists(CG(auto_globals), UG(unicode), Z_STRVAL_P(name), Z_STRLEN_P(name) + 1));
}
/* }}} */
/* {{{ proto int xcache_get_refcount(mixed &variable)
XCache internal uses only: Get reference count of referenced variable */
#ifdef ZEND_BEGIN_ARG_INFO_EX
ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_get_refcount, 0, 0, 1)
ZEND_ARG_INFO(1, variable)
ZEND_END_ARG_INFO()
#else
static unsigned char arginfo_xcache_get_refcount[] = { 1, BYREF_FORCE };
#endif
PHP_FUNCTION(xcache_get_refcount)
{
zval *variable;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &variable) == FAILURE) {
RETURN_NULL();
}
RETURN_LONG(Z_REFCOUNT(*variable) - 1);
}
/* }}} */
/* {{{ proto int xcache_get_cowcount(mixed value)
XCache internal uses only: Get reference count of copy-on-write variable or data */
#ifdef ZEND_BEGIN_ARG_INFO_EX
ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_get_cowcount, 0, 0, 1)
ZEND_ARG_INFO(0, variable)
ZEND_END_ARG_INFO()
#else
static unsigned char arginfo_xcache_get_cowcount[] = { 1, BYREF_NONE };
#endif
PHP_FUNCTION(xcache_get_cowcount)
{
zval *variable;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &variable) == FAILURE) {
RETURN_NULL();
}
RETURN_LONG(Z_REFCOUNT(*variable) - 1);
}
/* }}} */
/* {{{ proto bool xcache_get_isref(mixed variable)
XCache internal uses only: Check if variable data is marked referenced */
#ifdef ZEND_BEGIN_ARG_INFO_EX
ZEND_BEGIN_ARG_INFO_EX(arginfo_xcache_get_isref, 0, 0, 1)
ZEND_ARG_INFO(1, variable)
ZEND_END_ARG_INFO()
#else
static unsigned char arginfo_xcache_get_isref[] = { 1, BYREF_FORCE };
#endif
PHP_FUNCTION(xcache_get_isref)
{
zval *variable;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &variable) == FAILURE) {
RETURN_NULL();
}
RETURN_BOOL(Z_ISREF(*variable) && Z_REFCOUNT(*variable) >= 3);
}
/* }}} */
static zend_function_entry xcache_functions[] = /* {{{ */
{
#ifdef HAVE_XCACHE_DPRINT
PHP_FE(xcache_dprint, arginfo_xcache_dprint)
#endif
#ifdef HAVE_XCACHE_ASSEMBLER
PHP_FE(xcache_asm, NULL)
#endif
#ifdef HAVE_XCACHE_ENCODER
PHP_FE(xcache_encode, NULL)
#endif
#ifdef HAVE_XCACHE_DECODER
PHP_FE(xcache_decode_file, NULL)
PHP_FE(xcache_decode_string, NULL)
#endif
PHP_FE(xcache_get_special_value, arginfo_xcache_get_special_value)
PHP_FE(xcache_get_type, arginfo_xcache_get_type)
PHP_FE(xcache_get_op_type, arginfo_xcache_get_op_type)
PHP_FE(xcache_get_data_type, arginfo_xcache_get_data_type)
PHP_FE(xcache_get_opcode, arginfo_xcache_get_opcode)
PHP_FE(xcache_get_opcode_spec, arginfo_xcache_get_opcode_spec)
PHP_FE(xcache_coredump, arginfo_xcache_coredump)
PHP_FE(xcache_is_autoglobal, arginfo_xcache_is_autoglobal)
PHP_FE(xcache_get_refcount, arginfo_xcache_get_refcount)
PHP_FE(xcache_get_cowcount, arginfo_xcache_get_cowcount)
PHP_FE(xcache_get_isref, arginfo_xcache_get_isref)
PHP_FE_END
};
/* }}} */
#ifdef ZEND_WIN32
#include "dbghelp.h"
typedef BOOL (WINAPI *MINIDUMPWRITEDUMP)(HANDLE hProcess, DWORD dwPid, HANDLE hFile, MINIDUMP_TYPE DumpType,
CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam
);
static PTOP_LEVEL_EXCEPTION_FILTER oldFilter = NULL;
static HMODULE dbghelpModule = NULL;
static char crash_dumpPath[_MAX_PATH] = { 0 };
static MINIDUMPWRITEDUMP dbghelp_MiniDumpWriteDump = NULL;
static LONG WINAPI miniDumperFilter(struct _EXCEPTION_POINTERS *pExceptionInfo) /* {{{ */
{
HANDLE fileHandle;
LONG ret = EXCEPTION_CONTINUE_SEARCH;
SetUnhandledExceptionFilter(oldFilter);
/* create the file */
fileHandle = CreateFile(crash_dumpPath, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (fileHandle != INVALID_HANDLE_VALUE) {
MINIDUMP_EXCEPTION_INFORMATION exceptionInformation;
MINIDUMP_TYPE type = xc_coredump_type ? xc_coredump_type : (MiniDumpNormal|MiniDumpWithDataSegs|MiniDumpWithIndirectlyReferencedMemory);
BOOL ok;
exceptionInformation.ThreadId = GetCurrentThreadId();
exceptionInformation.ExceptionPointers = pExceptionInfo;
exceptionInformation.ClientPointers = FALSE;
/* write the dump */
ok = dbghelp_MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), fileHandle, type, &exceptionInformation, NULL, NULL);
CloseHandle(fileHandle);
if (ok) {
zend_error(E_ERROR, "Saved dump file to '%s'", crash_dumpPath);
ret = EXCEPTION_EXECUTE_HANDLER;
}
else {
zend_error(E_ERROR, "Failed to save dump file to '%s' (error %d)", crash_dumpPath, GetLastError());
}
}
else {
zend_error(E_ERROR, "Failed to create dump file '%s' (error %d)", crash_dumpPath, GetLastError());
}
if (xc_disable_on_crash) {
xc_disable_on_crash = 0;
xc_cacher_disable();
}
return ret;
}
/* }}} */
static void xcache_restore_crash_handler() /* {{{ */
{
if (oldFilter) {
SetUnhandledExceptionFilter(oldFilter);
oldFilter = NULL;
}
}
/* }}} */
static void xcache_init_crash_handler() /* {{{ */
{
/* firstly see if dbghelp.dll is around and has the function we need
look next to the EXE first, as the one in System32 might be old
(e.g. Windows 2000) */
char dbghelpPath[_MAX_PATH];
if (GetModuleFileName(NULL, dbghelpPath, _MAX_PATH)) {
char *slash = strchr(dbghelpPath, '\\');
if (slash) {
strcpy(slash + 1, "DBGHELP.DLL");
dbghelpModule = LoadLibrary(dbghelpPath);
}
}
if (!dbghelpModule) {
/* load any version we can */
dbghelpModule = LoadLibrary("DBGHELP.DLL");
if (!dbghelpModule) {
zend_error(E_ERROR, "Unable to enable crash dump saver: %s", "DBGHELP.DLL not found");
return;
}
}
dbghelp_MiniDumpWriteDump = (MINIDUMPWRITEDUMP)GetProcAddress(dbghelpModule, "MiniDumpWriteDump");
if (!dbghelp_MiniDumpWriteDump) {
zend_error(E_ERROR, "Unable to enable crash dump saver: %s", "DBGHELP.DLL too old. Get updated dll and put it aside of php_xcache.dll");
return;
}
#ifdef XCACHE_VERSION_REVISION
#define REVISION "r" XCACHE_VERSION_REVISION
#else
#define REVISION ""
#endif
sprintf(crash_dumpPath, "%s\\php-%s-xcache-%s%s-%lu-%lu.dmp", xc_coredump_dir, zend_get_module_version("standard"), XCACHE_VERSION, REVISION, (unsigned long) time(NULL), (unsigned long) GetCurrentProcessId());
#undef REVISION
oldFilter = SetUnhandledExceptionFilter(&miniDumperFilter);
}
/* }}} */
#else
/* old signal handlers {{{ */
typedef void (*xc_sighandler_t)(int);
#define FOREACH_SIG(sig) static xc_sighandler_t old_##sig##_handler = NULL
#include "util/xc_foreachcoresig.h"
#undef FOREACH_SIG
/* }}} */
static void xcache_signal_handler(int sig);
static void xcache_restore_crash_handler() /* {{{ */
{
#define FOREACH_SIG(sig) do { \
if (old_##sig##_handler != xcache_signal_handler) { \
signal(sig, old_##sig##_handler); \
} \
else { \
signal(sig, SIG_DFL); \
} \
} while (0)
#include "util/xc_foreachcoresig.h"
#undef FOREACH_SIG
}
/* }}} */
static void xcache_init_crash_handler() /* {{{ */
{
#define FOREACH_SIG(sig) \
old_##sig##_handler = signal(sig, xcache_signal_handler)
#include "util/xc_foreachcoresig.h"
#undef FOREACH_SIG
}
/* }}} */
static void xcache_signal_handler(int sig) /* {{{ */
{
xcache_restore_crash_handler();
if (xc_coredump_dir && xc_coredump_dir[0]) {
if (chdir(xc_coredump_dir) != 0) {
/* error, but nothing can do about it
* and should'nt print anything which might SEGV again */
}
}
if (xc_disable_on_crash) {
xc_disable_on_crash = 0;
xc_cacher_disable();
}
if (0) {
}
#define FOREACH_SIG(forsig) \
else if (sig == forsig) \
write(2, XCACHE_STRL("Program received signal " #forsig ", Segmentation fault\n"))
#include "util/xc_foreachcoresig.h"
#undef FOREACH_SIG
write(2, XCACHE_STRL("If core dump is enabled it can be found at "));
write(2, xc_coredump_dir, strlen(xc_coredump_dir));
write(2, XCACHE_STRL("\n"));
raise(sig);
}
/* }}} */
#endif
/* {{{ incompatible zend extensions handling */
typedef struct {
const char *name;
startup_func_t old_startup;
} xc_incompatible_zend_extension_info_t;
static xc_incompatible_zend_extension_info_t xc_incompatible_zend_extensions[] = {
{ "Zend Extension Manager", NULL },
{ "Zend Optimizer", NULL },
{ "the ionCube PHP Loader", NULL }
};
static xc_incompatible_zend_extension_info_t *xc_get_incompatible_zend_extension_info(const char *name)
{
size_t i;
for (i = 0; i < sizeof(xc_incompatible_zend_extensions) / sizeof(xc_incompatible_zend_extensions[0]); ++i) {
xc_incompatible_zend_extension_info_t *incompatible_zend_extension_info = &xc_incompatible_zend_extensions[i];
if (strcmp(incompatible_zend_extension_info->name, name) == 0) {
return incompatible_zend_extension_info;
}
}
return NULL;
}
/* }}} */
static void xc_zend_llist_add_element(zend_llist *list, zend_llist_element *element) /* {{{ */
{
if (!zend_extensions.head) {
zend_extensions.head = zend_extensions.tail = element;
}
else {
zend_extensions.tail->next = element;
element->prev = zend_extensions.tail;
zend_extensions.tail = element;
}
}
/* }}} */
static int xc_incompatible_zend_extension_startup_hook(zend_extension *extension) /* {{{ */
{
xc_incompatible_zend_extension_info_t *incompatible_zend_extension_info = xc_get_incompatible_zend_extension_info(extension->name);
int status;
zend_bool catched = 0;
zend_llist saved_zend_extensions_container; /* without elements */
zend_llist_element **saved_zend_extensions_elments;
size_t new_zend_extensions_elments_count;
zend_llist_element **new_zend_extensions_elments;
zend_extension *ext;
size_t i;
zend_llist_element *element;
TSRMLS_FETCH();
/* restore startup hack */
extension->startup = incompatible_zend_extension_info->old_startup;
incompatible_zend_extension_info->old_startup = NULL;
assert(extension->startup);
/* save extensions list */
saved_zend_extensions_container = zend_extensions;
saved_zend_extensions_elments = malloc(sizeof(zend_llist_element *) * saved_zend_extensions_container.count);
for (i = 0, element = saved_zend_extensions_container.head; element; ++i, element = element->next) {
saved_zend_extensions_elments[i] = element;
}
/* hide all XCache extensions from it */
zend_extensions.head = NULL;
zend_extensions.tail = NULL;
zend_extensions.count = 0;
for (i = 0; i < saved_zend_extensions_container.count; ++i) {
element = saved_zend_extensions_elments[i];
element->next = element->prev = NULL;
ext = (zend_extension *) element->data;
if (!(strcmp(ext->name, XCACHE_NAME) == 0 || strncmp(ext->name, XCACHE_NAME " ", sizeof(XCACHE_NAME " ") - 1) == 0)) {
xc_zend_llist_add_element(&zend_extensions, element);
++zend_extensions.count;
}
}
assert(extension->startup != xc_incompatible_zend_extension_startup_hook);
zend_try {
status = extension->startup(extension);
} zend_catch {
catched = 1;
} zend_end_try();
/* save newly added extensions added by this extension*/
new_zend_extensions_elments_count = zend_extensions.count - 1;
new_zend_extensions_elments = NULL;
if (new_zend_extensions_elments_count) {
new_zend_extensions_elments = malloc(sizeof(zend_llist_element *) * new_zend_extensions_elments_count);
element = zend_extensions.head;
for (i = 0, element = element->next; element; ++i, element = element->next) {
new_zend_extensions_elments[i] = element;
}
}
/* restore original extension list*/
zend_extensions = saved_zend_extensions_container;
zend_extensions.head = NULL;
zend_extensions.tail = NULL;
zend_extensions.count = 0;
for (i = 0; i < saved_zend_extensions_container.count; ++i) {
element = saved_zend_extensions_elments[i];
element->next = element->prev = NULL;
xc_zend_llist_add_element(&zend_extensions, element);
++zend_extensions.count;
ext = (zend_extension *) element->data;
if (ext == extension && new_zend_extensions_elments_count) {
/* add new created extension */
size_t j;
for (j = 0; j < new_zend_extensions_elments_count; ++j) {
element = new_zend_extensions_elments[j];
element->next = element->prev = NULL;
xc_zend_llist_add_element(&zend_extensions, element);
++zend_extensions.count;
}
}
}
free(saved_zend_extensions_elments);
if (new_zend_extensions_elments) {
free(new_zend_extensions_elments);
}
if (catched) {
zend_bailout();
}
return status;
}
/* }}} */
static int xc_zend_startup(zend_extension *extension) /* {{{ */
{
zend_llist_position lpos;
zend_extension *ext;
ext = (zend_extension *) zend_extensions.head->data;
if (strcmp(ext->name, XCACHE_NAME) != 0) {
zend_error(E_WARNING, "XCache failed to load itself to before zend_extension=\"%s\". compatibility downgraded", ext->name);
}
for (ext = (zend_extension *) zend_llist_get_first_ex(&zend_extensions, &lpos);
ext;
ext = (zend_extension *) zend_llist_get_next_ex(&zend_extensions, &lpos)) {
xc_incompatible_zend_extension_info_t *incompatible_zend_extension_info = xc_get_incompatible_zend_extension_info(ext->name);
if (incompatible_zend_extension_info) {
assert(!incompatible_zend_extension_info->old_startup);
incompatible_zend_extension_info->old_startup = ext->startup;
ext->startup = xc_incompatible_zend_extension_startup_hook;
}
}
return SUCCESS;
}
/* }}} */
static void xc_zend_shutdown(zend_extension *extension) /* {{{ */
{
}
/* }}} */
/* {{{ zend extension definition structure */
static zend_extension xc_zend_extension_entry = {
XCACHE_NAME,
XCACHE_VERSION,
XCACHE_AUTHOR,
XCACHE_URL,
XCACHE_COPYRIGHT,
xc_zend_startup,
xc_zend_shutdown,
NULL, /* activate_func_t */
NULL, /* deactivate_func_t */
NULL, /* message_handler_func_t */
NULL, /* op_array_handler_func_t */
NULL, /* statement_handler_func_t */
NULL, /* fcall_begin_handler_func_t */
NULL, /* fcall_end_handler_func_t */
NULL, /* op_array_ctor_func_t */
NULL, /* op_array_dtor_func_t */
STANDARD_ZEND_EXTENSION_PROPERTIES
};
/* }}} */
/* {{{ PHP_INI */
PHP_INI_BEGIN()
PHP_INI_ENTRY1 ("xcache.coredump_directory", "", PHP_INI_SYSTEM, xcache_OnUpdateString, &xc_coredump_dir)
#ifdef ZEND_WIN32
PHP_INI_ENTRY1 ("xcache.coredump_type", "0", PHP_INI_SYSTEM, xcache_OnUpdateULong, &xc_coredump_type)
#endif
PHP_INI_ENTRY1_EX ("xcache.disable_on_crash", "0", PHP_INI_SYSTEM, xcache_OnUpdateBool, &xc_disable_on_crash, zend_ini_boolean_displayer_cb)
PHP_INI_ENTRY1_EX ("xcache.test", "0", PHP_INI_SYSTEM, xcache_OnUpdateBool, &xc_test, zend_ini_boolean_displayer_cb)
STD_PHP_INI_BOOLEAN("xcache.experimental", "0", PHP_INI_ALL, OnUpdateBool, experimental, zend_xcache_globals, xcache_globals)
PHP_INI_END()
/* }}} */
static PHP_MINFO_FUNCTION(xcache) /* {{{ */
{
php_info_print_table_start();
php_info_print_table_row(2, "XCache Version", XCACHE_VERSION);
#ifdef XCACHE_VERSION_REVISION
php_info_print_table_row(2, "Revision", "r" XCACHE_VERSION_REVISION);
#endif
php_info_print_table_row(2, "Modules Built", XCACHE_MODULES);
php_info_print_table_end();
DISPLAY_INI_ENTRIES();
}
/* }}} */
static PHP_MINIT_FUNCTION(xcache) /* {{{ */
{
#ifndef PHP_GINIT
ZEND_INIT_MODULE_GLOBALS(xcache, xc_init_globals, xc_shutdown_globals);
#endif
REGISTER_INI_ENTRIES();
if (xc_coredump_dir && xc_coredump_dir[0]) {
xcache_init_crash_handler();
}
if (strcmp(sapi_module.name, "cli") == 0) {
char *env;
if ((env = getenv("XCACHE_TEST")) != NULL) {
xc_test = (zend_bool) atoi(env);
}
}
xc_init_constant(module_number TSRMLS_CC);
xc_shm_init_modules();
/* must be the first */
xcache_zend_extension_add(&xc_zend_extension_entry, 1);
old_compile_file = zend_compile_file;
zend_compile_file = xc_check_initial_compile_file;
#ifdef HAVE_XCACHE_OPTIMIZER
xc_optimizer_startup_module();
#endif
#ifdef HAVE_XCACHE_CACHER
xc_cacher_startup_module();
#endif
#ifdef HAVE_XCACHE_COVERAGER
xc_coverager_startup_module();
#endif
#ifdef HAVE_XCACHE_DISASSEMBLER
xc_disassembler_startup_module();
#endif
return SUCCESS;
}
/* }}} */
static PHP_MSHUTDOWN_FUNCTION(xcache) /* {{{ */
{
if (old_compile_file && zend_compile_file == xc_check_initial_compile_file) {
zend_compile_file = old_compile_file;
old_compile_file = NULL;
}
if (xc_coredump_dir && xc_coredump_dir[0]) {
xcache_restore_crash_handler();
}
if (xc_coredump_dir) {
pefree(xc_coredump_dir, 1);
xc_coredump_dir = NULL;
}
#ifndef PHP_GINIT
# ifdef ZTS
ts_free_id(xcache_globals_id);
# else
xc_shutdown_globals(&xcache_globals TSRMLS_CC);
# endif
#endif
UNREGISTER_INI_ENTRIES();
xcache_zend_extension_remove(&xc_zend_extension_entry);
return SUCCESS;
}
/* }}} */
/* {{{ module dependencies */
#ifdef STANDARD_MODULE_HEADER_EX
static zend_module_dep xcache_module_deps[] = {
ZEND_MOD_REQUIRED("standard")
ZEND_MOD_CONFLICTS("apc")
ZEND_MOD_CONFLICTS("eAccelerator")
ZEND_MOD_CONFLICTS("Turck MMCache")
ZEND_MOD_END
};
#endif
/* }}} */
/* {{{ module definition structure */
zend_module_entry xcache_module_entry = {
#ifdef STANDARD_MODULE_HEADER_EX
STANDARD_MODULE_HEADER_EX,
NULL,
xcache_module_deps,
#else
STANDARD_MODULE_HEADER,
#endif
XCACHE_NAME,
xcache_functions,
PHP_MINIT(xcache),
PHP_MSHUTDOWN(xcache),
NULL, /* RINIT */
NULL, /* RSHUTDOWN */
PHP_MINFO(xcache),
XCACHE_VERSION,
#ifdef PHP_GINIT
PHP_MODULE_GLOBALS(xcache),
PHP_GINIT(xcache),
PHP_GSHUTDOWN(xcache),
#endif
#ifdef ZEND_ENGINE_2
NULL /* ZEND_MODULE_POST_ZEND_DEACTIVATE_N */,
#else
NULL,
NULL,
#endif
STANDARD_MODULE_PROPERTIES_EX
};
#ifdef COMPILE_DL_XCACHE
ZEND_GET_MODULE(xcache)
#endif
/* }}} */