PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/opcache - zend_accelerator_module.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 99 361 27.4 %
Date: 2016-08-28 Functions: 12 24 50.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | Zend OPcache                                                         |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1998-2016 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Andi Gutmans <andi@zend.com>                                |
      16             :    |          Zeev Suraski <zeev@zend.com>                                |
      17             :    |          Stanislav Malyshev <stas@zend.com>                          |
      18             :    |          Dmitry Stogov <dmitry@zend.com>                             |
      19             :    +----------------------------------------------------------------------+
      20             : */
      21             : 
      22             : #include <time.h>
      23             : 
      24             : #include "php.h"
      25             : #include "ZendAccelerator.h"
      26             : #include "zend_API.h"
      27             : #include "zend_shared_alloc.h"
      28             : #include "zend_accelerator_blacklist.h"
      29             : #include "php_ini.h"
      30             : #include "SAPI.h"
      31             : #include "zend_virtual_cwd.h"
      32             : #include "ext/standard/info.h"
      33             : #include "ext/standard/php_filestat.h"
      34             : 
      35             : #define STRING_NOT_NULL(s) (NULL == (s)?"":s)
      36             : #define MIN_ACCEL_FILES 200
      37             : #define MAX_ACCEL_FILES 1000000
      38             : #define TOKENTOSTR(X) #X
      39             : 
      40             : static void (*orig_file_exists)(INTERNAL_FUNCTION_PARAMETERS) = NULL;
      41             : static void (*orig_is_file)(INTERNAL_FUNCTION_PARAMETERS) = NULL;
      42             : static void (*orig_is_readable)(INTERNAL_FUNCTION_PARAMETERS) = NULL;
      43             : 
      44             : ZEND_BEGIN_ARG_INFO(arginfo_opcache_none, 0)
      45             : ZEND_END_ARG_INFO()
      46             : 
      47             : ZEND_BEGIN_ARG_INFO_EX(arginfo_opcache_get_status, 0, 0, 0)
      48             :         ZEND_ARG_INFO(0, fetch_scripts)
      49             : ZEND_END_ARG_INFO()
      50             : 
      51             : ZEND_BEGIN_ARG_INFO_EX(arginfo_opcache_compile_file, 0, 0, 1)
      52             :         ZEND_ARG_INFO(0, file)
      53             : ZEND_END_ARG_INFO()
      54             : 
      55             : ZEND_BEGIN_ARG_INFO_EX(arginfo_opcache_invalidate, 0, 0, 1)
      56             :         ZEND_ARG_INFO(0, script)
      57             :         ZEND_ARG_INFO(0, force)
      58             : ZEND_END_ARG_INFO()
      59             : 
      60             : ZEND_BEGIN_ARG_INFO_EX(arginfo_opcache_is_script_cached, 0, 0, 1)
      61             :         ZEND_ARG_INFO(0, script)
      62             : ZEND_END_ARG_INFO()
      63             : 
      64             : /* User functions */
      65             : static ZEND_FUNCTION(opcache_reset);
      66             : static ZEND_FUNCTION(opcache_invalidate);
      67             : static ZEND_FUNCTION(opcache_is_script_cached);
      68             : 
      69             : /* Private functions */
      70             : static ZEND_FUNCTION(opcache_get_status);
      71             : static ZEND_FUNCTION(opcache_compile_file);
      72             : static ZEND_FUNCTION(opcache_get_configuration);
      73             : 
      74             : static zend_function_entry accel_functions[] = {
      75             :         /* User functions */
      76             :         ZEND_FE(opcache_reset,                                  arginfo_opcache_none)
      77             :         ZEND_FE(opcache_invalidate,                             arginfo_opcache_invalidate)
      78             :         ZEND_FE(opcache_compile_file,                   arginfo_opcache_compile_file)
      79             :         ZEND_FE(opcache_is_script_cached,               arginfo_opcache_is_script_cached)
      80             :         /* Private functions */
      81             :         ZEND_FE(opcache_get_configuration,              arginfo_opcache_none)
      82             :         ZEND_FE(opcache_get_status,                             arginfo_opcache_get_status)
      83             :         ZEND_FE_END
      84             : };
      85             : 
      86           9 : static int validate_api_restriction(void)
      87             : {
      88           9 :         if (ZCG(accel_directives).restrict_api && *ZCG(accel_directives).restrict_api) {
      89           0 :                 size_t len = strlen(ZCG(accel_directives).restrict_api);
      90             : 
      91           0 :                 if (!SG(request_info).path_translated ||
      92           0 :                     strlen(SG(request_info).path_translated) < len ||
      93           0 :                     memcmp(SG(request_info).path_translated, ZCG(accel_directives).restrict_api, len) != 0) {
      94           0 :                         zend_error(E_WARNING, ACCELERATOR_PRODUCT_NAME " API is restricted by \"restrict_api\" configuration directive");
      95           0 :                         return 0;
      96             :                 }
      97             :         }
      98           9 :         return 1;
      99             : }
     100             : 
     101       23373 : static ZEND_INI_MH(OnUpdateMemoryConsumption)
     102             : {
     103             :         zend_long *p;
     104             :         zend_long memsize;
     105             : #ifndef ZTS
     106       23373 :         char *base = (char *) mh_arg2;
     107             : #else
     108             :         char *base = (char *) ts_resource(*((int *) mh_arg2));
     109             : #endif
     110             : 
     111             :         /* keep the compiler happy */
     112             :         (void)entry; (void)mh_arg2; (void)mh_arg3; (void)stage;
     113             : 
     114       23373 :         p = (zend_long *) (base + (size_t)mh_arg1);
     115       23373 :         memsize = atoi(ZSTR_VAL(new_value));
     116             :         /* sanity check we must use at least 8 MB */
     117       23373 :         if (memsize < 8) {
     118           0 :                 const char *new_new_value = "8";
     119             :                 zend_ini_entry *ini_entry;
     120             : 
     121           0 :                 memsize = 8;
     122           0 :                 zend_accel_error(ACCEL_LOG_WARNING, "opcache.memory_consumption is set below the required 8MB.\n");
     123           0 :                 zend_accel_error(ACCEL_LOG_WARNING, ACCELERATOR_PRODUCT_NAME " will use the minimal 8MB configuration.\n");
     124             : 
     125           0 :                 if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives),
     126             :                                         "opcache.memory_consumption",
     127             :                                         sizeof("opcache.memory_consumption")-1)) == NULL) {
     128           0 :                         return FAILURE;
     129             :                 }
     130             : 
     131           0 :                 ini_entry->value = zend_string_init(new_new_value, 1, 1);
     132             :         }
     133       23373 :         *p = memsize * (1024 * 1024);
     134       23373 :         return SUCCESS;
     135             : }
     136             : 
     137       23373 : static ZEND_INI_MH(OnUpdateMaxAcceleratedFiles)
     138             : {
     139             :         zend_long *p;
     140             :         zend_long size;
     141             : #ifndef ZTS
     142       23373 :         char *base = (char *) mh_arg2;
     143             : #else
     144             :         char *base = (char *) ts_resource(*((int *) mh_arg2));
     145             : #endif
     146             : 
     147             :         /* keep the compiler happy */
     148             :         (void)entry; (void)mh_arg2; (void)mh_arg3; (void)stage;
     149             : 
     150       23373 :         p = (zend_long *) (base + (size_t)mh_arg1);
     151       23373 :         size = atoi(ZSTR_VAL(new_value));
     152             :         /* sanity check we must use a value between MIN_ACCEL_FILES and MAX_ACCEL_FILES */
     153             : 
     154       23373 :         if (size < MIN_ACCEL_FILES || size > MAX_ACCEL_FILES) {
     155             :                 const char *new_new_value;
     156             :                 zend_ini_entry *ini_entry;
     157             : 
     158           0 :                 if (size < MIN_ACCEL_FILES) {
     159           0 :                         size = MIN_ACCEL_FILES;
     160           0 :                         new_new_value = TOKENTOSTR(MIN_ACCEL_FILES);
     161           0 :                         zend_accel_error(ACCEL_LOG_WARNING, "opcache.max_accelerated_files is set below the required minimum (%d).\n", MIN_ACCEL_FILES);
     162           0 :                         zend_accel_error(ACCEL_LOG_WARNING, ACCELERATOR_PRODUCT_NAME " will use the minimal configuration.\n");
     163             :                 }
     164           0 :                 if (size > MAX_ACCEL_FILES) {
     165           0 :                         size = MAX_ACCEL_FILES;
     166           0 :                         new_new_value = TOKENTOSTR(MAX_ACCEL_FILES);
     167           0 :                         zend_accel_error(ACCEL_LOG_WARNING, "opcache.max_accelerated_files is set above the limit (%d).\n", MAX_ACCEL_FILES);
     168           0 :                         zend_accel_error(ACCEL_LOG_WARNING, ACCELERATOR_PRODUCT_NAME " will use the maximal configuration.\n");
     169             :                 }
     170           0 :                 if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives),
     171             :                                         "opcache.max_accelerated_files",
     172             :                                         sizeof("opcache.max_accelerated_files")-1)) == NULL) {
     173           0 :                         return FAILURE;
     174             :                 }
     175           0 :                 ini_entry->value = zend_string_init(new_new_value, strlen(new_new_value), 1);
     176             :         }
     177       23373 :         *p = size;
     178       23373 :         return SUCCESS;
     179             : }
     180             : 
     181       23373 : static ZEND_INI_MH(OnUpdateMaxWastedPercentage)
     182             : {
     183             :         double *p;
     184             :         zend_long percentage;
     185             : #ifndef ZTS
     186       23373 :         char *base = (char *) mh_arg2;
     187             : #else
     188             :         char *base = (char *) ts_resource(*((int *) mh_arg2));
     189             : #endif
     190             : 
     191             :         /* keep the compiler happy */
     192             :         (void)entry; (void)mh_arg2; (void)mh_arg3; (void)stage;
     193             : 
     194       23373 :         p = (double *) (base + (size_t)mh_arg1);
     195       23373 :         percentage = atoi(ZSTR_VAL(new_value));
     196             : 
     197       23373 :         if (percentage <= 0 || percentage > 50) {
     198           0 :                 const char *new_new_value = "5";
     199             :                 zend_ini_entry *ini_entry;
     200             : 
     201           0 :                 percentage = 5;
     202           0 :                 zend_accel_error(ACCEL_LOG_WARNING, "opcache.max_wasted_percentage must be set between 1 and 50.\n");
     203           0 :                 zend_accel_error(ACCEL_LOG_WARNING, ACCELERATOR_PRODUCT_NAME " will use 5%%.\n");
     204           0 :                 if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives),
     205             :                                         "opcache.max_wasted_percentage",
     206             :                                         sizeof("opcache.max_wasted_percentage")-1)) == NULL) {
     207           0 :                         return FAILURE;
     208             :                 }
     209           0 :                 ini_entry->value = zend_string_init(new_new_value, strlen(new_new_value), 1);
     210             :         }
     211       23373 :         *p = (double)percentage / 100.0;
     212       23373 :         return SUCCESS;
     213             : }
     214             : 
     215       23373 : static ZEND_INI_MH(OnEnable)
     216             : {
     217       23373 :         if (stage == ZEND_INI_STAGE_STARTUP ||
     218             :             stage == ZEND_INI_STAGE_SHUTDOWN ||
     219             :             stage == ZEND_INI_STAGE_DEACTIVATE) {
     220       23373 :                 return OnUpdateBool(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
     221             :         } else {
     222             :                 /* It may be only temporary disabled */
     223             :                 zend_bool *p;
     224             : #ifndef ZTS
     225           0 :                 char *base = (char *) mh_arg2;
     226             : #else
     227             :                 char *base = (char *) ts_resource(*((int *) mh_arg2));
     228             : #endif
     229             : 
     230           0 :                 p = (zend_bool *) (base+(size_t) mh_arg1);
     231           0 :                 if ((ZSTR_LEN(new_value) == 2 && strcasecmp("on", ZSTR_VAL(new_value)) == 0) ||
     232           0 :                     (ZSTR_LEN(new_value) == 3 && strcasecmp("yes", ZSTR_VAL(new_value)) == 0) ||
     233           0 :                     (ZSTR_LEN(new_value) == 4 && strcasecmp("true", ZSTR_VAL(new_value)) == 0) ||
     234           0 :                         atoi(ZSTR_VAL(new_value)) != 0) {
     235           0 :                         zend_error(E_WARNING, ACCELERATOR_PRODUCT_NAME " can't be temporary enabled (it may be only disabled till the end of request)");
     236           0 :                         return FAILURE;
     237             :                 } else {
     238           0 :                         *p = 0;
     239           0 :                         return SUCCESS;
     240             :                 }
     241             :         }
     242             : }
     243             : 
     244             : #ifdef HAVE_OPCACHE_FILE_CACHE
     245       23373 : static ZEND_INI_MH(OnUpdateFileCache)
     246             : {
     247       23373 :         if (new_value) {
     248        9131 :                 if (!ZSTR_LEN(new_value)) {
     249        9131 :                         new_value = NULL;
     250             :                 } else {
     251             :                         zend_stat_t buf;
     252             : 
     253           0 :                     if (!IS_ABSOLUTE_PATH(ZSTR_VAL(new_value), ZSTR_LEN(new_value)) ||
     254           0 :                             zend_stat(ZSTR_VAL(new_value), &buf) != 0 ||
     255           0 :                             !S_ISDIR(buf.st_mode) ||
     256             : #ifndef ZEND_WIN32
     257           0 :                                 access(ZSTR_VAL(new_value), R_OK | W_OK | X_OK) != 0) {
     258             : #else
     259             :                                 _access(ZSTR_VAL(new_value), 06) != 0) {
     260             : #endif
     261           0 :                                 zend_accel_error(ACCEL_LOG_WARNING, "opcache.file_cache must be a full path of accessable directory.\n");
     262           0 :                                 new_value = NULL;
     263             :                         }
     264             :                 }
     265             :         }
     266       23373 :         OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
     267       23373 :         return SUCCESS;
     268             : }
     269             : #endif
     270             : 
     271             : ZEND_INI_BEGIN()
     272             :         STD_PHP_INI_BOOLEAN("opcache.enable"             , "1", PHP_INI_ALL,    OnEnable,     enabled                             , zend_accel_globals, accel_globals)
     273             :         STD_PHP_INI_BOOLEAN("opcache.use_cwd"            , "1", PHP_INI_SYSTEM, OnUpdateBool, accel_directives.use_cwd            , zend_accel_globals, accel_globals)
     274             :         STD_PHP_INI_BOOLEAN("opcache.validate_timestamps", "1", PHP_INI_ALL   , OnUpdateBool, accel_directives.validate_timestamps, zend_accel_globals, accel_globals)
     275             :         STD_PHP_INI_BOOLEAN("opcache.inherited_hack"     , "1", PHP_INI_SYSTEM, OnUpdateBool, accel_directives.inherited_hack     , zend_accel_globals, accel_globals)
     276             :         STD_PHP_INI_BOOLEAN("opcache.dups_fix"           , "0", PHP_INI_ALL   , OnUpdateBool, accel_directives.ignore_dups        , zend_accel_globals, accel_globals)
     277             :         STD_PHP_INI_BOOLEAN("opcache.revalidate_path"    , "0", PHP_INI_ALL   , OnUpdateBool, accel_directives.revalidate_path    , zend_accel_globals, accel_globals)
     278             : 
     279             :         STD_PHP_INI_ENTRY("opcache.log_verbosity_level"   , "1"   , PHP_INI_SYSTEM, OnUpdateLong, accel_directives.log_verbosity_level,       zend_accel_globals, accel_globals)
     280             :         STD_PHP_INI_ENTRY("opcache.memory_consumption"    , "64"  , PHP_INI_SYSTEM, OnUpdateMemoryConsumption,    accel_directives.memory_consumption,        zend_accel_globals, accel_globals)
     281             :         STD_PHP_INI_ENTRY("opcache.interned_strings_buffer", "4"  , PHP_INI_SYSTEM, OnUpdateLong,                 accel_directives.interned_strings_buffer,   zend_accel_globals, accel_globals)
     282             :         STD_PHP_INI_ENTRY("opcache.max_accelerated_files" , "2000", PHP_INI_SYSTEM, OnUpdateMaxAcceleratedFiles,     accel_directives.max_accelerated_files,     zend_accel_globals, accel_globals)
     283             :         STD_PHP_INI_ENTRY("opcache.max_wasted_percentage" , "5"   , PHP_INI_SYSTEM, OnUpdateMaxWastedPercentage,     accel_directives.max_wasted_percentage,     zend_accel_globals, accel_globals)
     284             :         STD_PHP_INI_ENTRY("opcache.consistency_checks"    , "0"   , PHP_INI_ALL   , OnUpdateLong,                accel_directives.consistency_checks,        zend_accel_globals, accel_globals)
     285             :         STD_PHP_INI_ENTRY("opcache.force_restart_timeout" , "180" , PHP_INI_SYSTEM, OnUpdateLong,                accel_directives.force_restart_timeout,     zend_accel_globals, accel_globals)
     286             :         STD_PHP_INI_ENTRY("opcache.revalidate_freq"       , "2"   , PHP_INI_ALL   , OnUpdateLong,                accel_directives.revalidate_freq,           zend_accel_globals, accel_globals)
     287             :         STD_PHP_INI_ENTRY("opcache.file_update_protection", "2"   , PHP_INI_ALL   , OnUpdateLong,                accel_directives.file_update_protection,    zend_accel_globals, accel_globals)
     288             :         STD_PHP_INI_ENTRY("opcache.preferred_memory_model", ""    , PHP_INI_SYSTEM, OnUpdateStringUnempty,       accel_directives.memory_model,              zend_accel_globals, accel_globals)
     289             :         STD_PHP_INI_ENTRY("opcache.blacklist_filename"    , ""    , PHP_INI_SYSTEM, OnUpdateString,              accel_directives.user_blacklist_filename,   zend_accel_globals, accel_globals)
     290             :         STD_PHP_INI_ENTRY("opcache.max_file_size"         , "0"   , PHP_INI_SYSTEM, OnUpdateLong,                accel_directives.max_file_size,             zend_accel_globals, accel_globals)
     291             : 
     292             :         STD_PHP_INI_ENTRY("opcache.protect_memory"        , "0"  , PHP_INI_SYSTEM, OnUpdateBool,                  accel_directives.protect_memory,            zend_accel_globals, accel_globals)
     293             :         STD_PHP_INI_ENTRY("opcache.save_comments"         , "1"  , PHP_INI_SYSTEM, OnUpdateBool,                  accel_directives.save_comments,             zend_accel_globals, accel_globals)
     294             :         STD_PHP_INI_ENTRY("opcache.fast_shutdown"         , "0"  , PHP_INI_SYSTEM, OnUpdateBool,                  accel_directives.fast_shutdown,             zend_accel_globals, accel_globals)
     295             : 
     296             :         STD_PHP_INI_ENTRY("opcache.optimization_level"    , DEFAULT_OPTIMIZATION_LEVEL , PHP_INI_SYSTEM, OnUpdateLong, accel_directives.optimization_level,   zend_accel_globals, accel_globals)
     297             :         STD_PHP_INI_ENTRY("opcache.opt_debug_level"       , "0"      , PHP_INI_SYSTEM, OnUpdateLong,             accel_directives.opt_debug_level,            zend_accel_globals, accel_globals)
     298             :         STD_PHP_INI_BOOLEAN("opcache.enable_file_override"    , "0"   , PHP_INI_SYSTEM, OnUpdateBool,              accel_directives.file_override_enabled,     zend_accel_globals, accel_globals)
     299             :         STD_PHP_INI_BOOLEAN("opcache.enable_cli"             , "0"   , PHP_INI_SYSTEM, OnUpdateBool,              accel_directives.enable_cli,                zend_accel_globals, accel_globals)
     300             :         STD_PHP_INI_ENTRY("opcache.error_log"                , ""    , PHP_INI_SYSTEM, OnUpdateString,               accel_directives.error_log,                 zend_accel_globals, accel_globals)
     301             :         STD_PHP_INI_ENTRY("opcache.restrict_api"             , ""    , PHP_INI_SYSTEM, OnUpdateString,               accel_directives.restrict_api,              zend_accel_globals, accel_globals)
     302             : 
     303             : #ifndef ZEND_WIN32
     304             :         STD_PHP_INI_ENTRY("opcache.lockfile_path"             , "/tmp"    , PHP_INI_SYSTEM, OnUpdateString,           accel_directives.lockfile_path,              zend_accel_globals, accel_globals)
     305             : #else
     306             :         STD_PHP_INI_ENTRY("opcache.mmap_base", NULL, PHP_INI_SYSTEM,  OnUpdateString,                              accel_directives.mmap_base,                 zend_accel_globals, accel_globals)
     307             : #endif
     308             : 
     309             : #ifdef HAVE_OPCACHE_FILE_CACHE
     310             :         STD_PHP_INI_ENTRY("opcache.file_cache"                    , NULL  , PHP_INI_SYSTEM, OnUpdateFileCache, accel_directives.file_cache,                    zend_accel_globals, accel_globals)
     311             :         STD_PHP_INI_ENTRY("opcache.file_cache_only"               , "0"   , PHP_INI_SYSTEM, OnUpdateBool,      accel_directives.file_cache_only,               zend_accel_globals, accel_globals)
     312             :         STD_PHP_INI_ENTRY("opcache.file_cache_consistency_checks" , "1"   , PHP_INI_SYSTEM, OnUpdateBool,      accel_directives.file_cache_consistency_checks, zend_accel_globals, accel_globals)
     313             : #endif
     314             : #if ENABLE_FILE_CACHE_FALLBACK
     315             :         STD_PHP_INI_ENTRY("opcache.file_cache_fallback"           , "1"   , PHP_INI_SYSTEM, OnUpdateBool,      accel_directives.file_cache_fallback,           zend_accel_globals, accel_globals)
     316             : #endif
     317             : #ifdef HAVE_HUGE_CODE_PAGES
     318             :         STD_PHP_INI_BOOLEAN("opcache.huge_code_pages"             , "0"   , PHP_INI_SYSTEM, OnUpdateBool,      accel_directives.huge_code_pages,               zend_accel_globals, accel_globals)
     319             : #endif
     320             : ZEND_INI_END()
     321             : 
     322           0 : static int filename_is_in_cache(zend_string *filename)
     323             : {
     324             :         char *key;
     325             :         int key_length;
     326             : 
     327           0 :         key = accel_make_persistent_key(ZSTR_VAL(filename), ZSTR_LEN(filename), &key_length);
     328           0 :         if (key != NULL) {
     329           0 :                 zend_persistent_script *persistent_script = zend_accel_hash_str_find(&ZCSG(hash), key, key_length);
     330           0 :                 if (persistent_script && !persistent_script->corrupted) {
     331           0 :                         zend_file_handle handle = {{0}, NULL, NULL, 0, 0};
     332             : 
     333           0 :                         handle.filename = ZSTR_VAL(filename);
     334           0 :                         handle.type = ZEND_HANDLE_FILENAME;
     335             : 
     336           0 :                         if (ZCG(accel_directives).validate_timestamps) {
     337           0 :                                 return validate_timestamp_and_record(persistent_script, &handle) == SUCCESS;
     338             :                         }
     339             : 
     340           0 :                         return 1;
     341             :                 }
     342             :         }
     343             : 
     344           0 :         return 0;
     345             : }
     346             : 
     347           0 : static int accel_file_in_cache(INTERNAL_FUNCTION_PARAMETERS)
     348             : {
     349             :         zval zfilename;
     350             : 
     351           0 :         if (ZEND_NUM_ARGS() != 1 ||
     352           0 :             zend_get_parameters_array_ex(1, &zfilename) == FAILURE ||
     353             :             Z_TYPE(zfilename) != IS_STRING ||
     354           0 :             Z_STRLEN(zfilename) == 0) {
     355           0 :                 return 0;
     356             :         }
     357           0 :         return filename_is_in_cache(Z_STR(zfilename));
     358             : }
     359             : 
     360           0 : static void accel_file_exists(INTERNAL_FUNCTION_PARAMETERS)
     361             : {
     362           0 :         if (accel_file_in_cache(INTERNAL_FUNCTION_PARAM_PASSTHRU)) {
     363           0 :                 RETURN_TRUE;
     364             :         } else {
     365           0 :                 orig_file_exists(INTERNAL_FUNCTION_PARAM_PASSTHRU);
     366             :         }
     367             : }
     368             : 
     369           0 : static void accel_is_file(INTERNAL_FUNCTION_PARAMETERS)
     370             : {
     371           0 :         if (accel_file_in_cache(INTERNAL_FUNCTION_PARAM_PASSTHRU)) {
     372           0 :                 RETURN_TRUE;
     373             :         } else {
     374           0 :                 orig_is_file(INTERNAL_FUNCTION_PARAM_PASSTHRU);
     375             :         }
     376             : }
     377             : 
     378           0 : static void accel_is_readable(INTERNAL_FUNCTION_PARAMETERS)
     379             : {
     380           0 :         if (accel_file_in_cache(INTERNAL_FUNCTION_PARAM_PASSTHRU)) {
     381           0 :                 RETURN_TRUE;
     382             :         } else {
     383           0 :                 orig_is_readable(INTERNAL_FUNCTION_PARAM_PASSTHRU);
     384             :         }
     385             : }
     386             : 
     387       23373 : static ZEND_MINIT_FUNCTION(zend_accelerator)
     388             : {
     389             :         (void)type; /* keep the compiler happy */
     390             : 
     391       23373 :         REGISTER_INI_ENTRIES();
     392             : 
     393       23373 :         return SUCCESS;
     394             : }
     395             : 
     396         380 : void zend_accel_override_file_functions(void)
     397             : {
     398             :         zend_function *old_function;
     399         380 :         if (ZCG(enabled) && accel_startup_ok && ZCG(accel_directives).file_override_enabled) {
     400             : #ifdef HAVE_OPCACHE_FILE_CACHE
     401           0 :                 if (ZCG(accel_directives).file_cache_only) {
     402           0 :                         zend_accel_error(ACCEL_LOG_WARNING, "file_override_enabled has no effect when file_cache_only is set");
     403           0 :                         return;
     404             :                 }
     405             : #endif
     406             :                 /* override file_exists */
     407           0 :                 if ((old_function = zend_hash_str_find_ptr(CG(function_table), "file_exists", sizeof("file_exists")-1)) != NULL) {
     408           0 :                         orig_file_exists = old_function->internal_function.handler;
     409           0 :                         old_function->internal_function.handler = accel_file_exists;
     410             :                 }
     411           0 :                 if ((old_function = zend_hash_str_find_ptr(CG(function_table), "is_file", sizeof("is_file")-1)) != NULL) {
     412           0 :                         orig_is_file = old_function->internal_function.handler;
     413           0 :                         old_function->internal_function.handler = accel_is_file;
     414             :                 }
     415           0 :                 if ((old_function = zend_hash_str_find_ptr(CG(function_table), "is_readable", sizeof("is_readable")-1)) != NULL) {
     416           0 :                         orig_is_readable = old_function->internal_function.handler;
     417           0 :                         old_function->internal_function.handler = accel_is_readable;
     418             :                 }
     419             :         }
     420             : }
     421             : 
     422       23371 : static ZEND_MSHUTDOWN_FUNCTION(zend_accelerator)
     423             : {
     424             :         (void)type; /* keep the compiler happy */
     425             : 
     426       23371 :         UNREGISTER_INI_ENTRIES();
     427       23371 :         accel_shutdown();
     428       23371 :         return SUCCESS;
     429             : }
     430             : 
     431         149 : void zend_accel_info(ZEND_MODULE_INFO_FUNC_ARGS)
     432             : {
     433         149 :         php_info_print_table_start();
     434             : 
     435         151 :         if (ZCG(enabled) && accel_startup_ok &&
     436             : #ifdef HAVE_OPCACHE_FILE_CACHE
     437           1 :                 ((ZCG(counted) || ZCSG(accelerator_enabled)) || ZCG(accel_directives).file_cache_only)
     438             : #else
     439             :                 (ZCG(counted) || ZCSG(accelerator_enabled))
     440             : #endif
     441             :         ) {
     442           1 :                 php_info_print_table_row(2, "Opcode Caching", "Up and Running");
     443             :         } else {
     444         148 :                 php_info_print_table_row(2, "Opcode Caching", "Disabled");
     445             :         }
     446         150 :         if (ZCG(enabled) && accel_startup_ok && ZCG(accel_directives).optimization_level) {
     447           1 :                 php_info_print_table_row(2, "Optimization", "Enabled");
     448             :         } else {
     449         148 :                 php_info_print_table_row(2, "Optimization", "Disabled");
     450             :         }
     451             : #ifdef HAVE_OPCACHE_FILE_CACHE
     452         149 :         if (!ZCG(accel_directives).file_cache_only) {
     453         149 :                 php_info_print_table_row(2, "SHM Cache", "Enabled");
     454             :         } else {
     455           0 :                 php_info_print_table_row(2, "SHM Cache", "Disabled");
     456             :         }
     457         149 :         if (ZCG(accel_directives).file_cache) {
     458           0 :                 php_info_print_table_row(2, "File Cache", "Enabled");
     459             :         } else {
     460         149 :                 php_info_print_table_row(2, "File Cache", "Disabled");
     461             :         }
     462         149 :         if (ZCG(accel_directives).file_cache_only) {
     463           0 :                 if (!accel_startup_ok || zps_api_failure_reason) {
     464           0 :                         php_info_print_table_row(2, "Startup Failed", zps_api_failure_reason);
     465             :                 } else {
     466           0 :                         php_info_print_table_row(2, "Startup", "OK");
     467             :                 }
     468             :         } else
     469             : #endif
     470         149 :         if (ZCG(enabled)) {
     471         297 :                 if (!accel_startup_ok || zps_api_failure_reason) {
     472         148 :                         php_info_print_table_row(2, "Startup Failed", zps_api_failure_reason);
     473             :                 } else {
     474             :                         char buf[32];
     475           1 :                         php_info_print_table_row(2, "Startup", "OK");
     476           1 :                         php_info_print_table_row(2, "Shared memory model", zend_accel_get_shared_model());
     477           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, (zend_ulong)ZCSG(hits));
     478           1 :                         php_info_print_table_row(2, "Cache hits", buf);
     479           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZSMMG(memory_exhausted)?ZCSG(misses):ZCSG(misses)-ZCSG(blacklist_misses));
     480           1 :                         php_info_print_table_row(2, "Cache misses", buf);
     481           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZCG(accel_directives).memory_consumption-zend_shared_alloc_get_free_memory()-ZSMMG(wasted_shared_memory));
     482           1 :                         php_info_print_table_row(2, "Used memory", buf);
     483           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, zend_shared_alloc_get_free_memory());
     484           1 :                         php_info_print_table_row(2, "Free memory", buf);
     485           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZSMMG(wasted_shared_memory));
     486           1 :                         php_info_print_table_row(2, "Wasted memory", buf);
     487           1 :                         if (ZCSG(interned_strings_start) && ZCSG(interned_strings_end) && ZCSG(interned_strings_top)) {
     488           1 :                                 snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZCSG(interned_strings_top) - ZCSG(interned_strings_start));
     489           1 :                                 php_info_print_table_row(2, "Interned Strings Used memory", buf);
     490           1 :                                 snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZCSG(interned_strings_end) - ZCSG(interned_strings_top));
     491           1 :                                 php_info_print_table_row(2, "Interned Strings Free memory", buf);
     492             :                         }
     493           1 :                         snprintf(buf, sizeof(buf), "%d", ZCSG(hash).num_direct_entries);
     494           1 :                         php_info_print_table_row(2, "Cached scripts", buf);
     495           1 :                         snprintf(buf, sizeof(buf), "%d", ZCSG(hash).num_entries);
     496           1 :                         php_info_print_table_row(2, "Cached keys", buf);
     497           1 :                         snprintf(buf, sizeof(buf), "%d", ZCSG(hash).max_num_entries);
     498           1 :                         php_info_print_table_row(2, "Max keys", buf);
     499           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZCSG(oom_restarts));
     500           1 :                         php_info_print_table_row(2, "OOM restarts", buf);
     501           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZCSG(hash_restarts));
     502           1 :                         php_info_print_table_row(2, "Hash keys restarts", buf);
     503           1 :                         snprintf(buf, sizeof(buf), ZEND_LONG_FMT, ZCSG(manual_restarts));
     504           1 :                         php_info_print_table_row(2, "Manual restarts", buf);
     505             :                 }
     506             :         }
     507             : 
     508         149 :         php_info_print_table_end();
     509         149 :         DISPLAY_INI_ENTRIES();
     510         149 : }
     511             : 
     512             : static zend_module_entry accel_module_entry = {
     513             :         STANDARD_MODULE_HEADER,
     514             :         ACCELERATOR_PRODUCT_NAME,
     515             :         accel_functions,
     516             :         ZEND_MINIT(zend_accelerator),
     517             :         ZEND_MSHUTDOWN(zend_accelerator),
     518             :         NULL,
     519             :         NULL,
     520             :         zend_accel_info,
     521             :         PHP_VERSION,
     522             :         NO_MODULE_GLOBALS,
     523             :         accel_post_deactivate,
     524             :         STANDARD_MODULE_PROPERTIES_EX
     525             : };
     526             : 
     527       23373 : int start_accel_module(void)
     528             : {
     529       23373 :         return zend_startup_module(&accel_module_entry);
     530             : }
     531             : 
     532             : /* {{{ proto array accelerator_get_scripts()
     533             :    Get the scripts which are accelerated by ZendAccelerator */
     534           0 : static int accelerator_get_scripts(zval *return_value)
     535             : {
     536             :         uint i;
     537             :         zval persistent_script_report;
     538             :         zend_accel_hash_entry *cache_entry;
     539             :         struct tm *ta;
     540             :         struct timeval exec_time;
     541             :         struct timeval fetch_time;
     542             : 
     543           0 :         if (!ZCG(enabled) || !accel_startup_ok || !ZCSG(accelerator_enabled) || accelerator_shm_read_lock() != SUCCESS) {
     544           0 :                 return 0;
     545             :         }
     546             : 
     547           0 :         array_init(return_value);
     548           0 :         for (i = 0; i<ZCSG(hash).max_num_entries; i++) {
     549           0 :                 for (cache_entry = ZCSG(hash).hash_table[i]; cache_entry; cache_entry = cache_entry->next) {
     550             :                         zend_persistent_script *script;
     551             :                         char *str;
     552             :                         size_t len;
     553             : 
     554           0 :                         if (cache_entry->indirect) continue;
     555             : 
     556           0 :                         script = (zend_persistent_script *)cache_entry->data;
     557             : 
     558           0 :                         array_init(&persistent_script_report);
     559           0 :                         add_assoc_str(&persistent_script_report, "full_path", zend_string_dup(script->script.filename, 0));
     560           0 :                         add_assoc_long(&persistent_script_report, "hits", (zend_long)script->dynamic_members.hits);
     561           0 :                         add_assoc_long(&persistent_script_report, "memory_consumption", script->dynamic_members.memory_consumption);
     562           0 :                         ta = localtime(&script->dynamic_members.last_used);
     563           0 :                         str = asctime(ta);
     564           0 :                         len = strlen(str);
     565           0 :                         if (len > 0 && str[len - 1] == '\n') len--;
     566           0 :                         add_assoc_stringl(&persistent_script_report, "last_used", str, len);
     567           0 :                         add_assoc_long(&persistent_script_report, "last_used_timestamp", script->dynamic_members.last_used);
     568           0 :                         if (ZCG(accel_directives).validate_timestamps) {
     569           0 :                                 add_assoc_long(&persistent_script_report, "timestamp", (zend_long)script->timestamp);
     570             :                         }
     571           0 :                         timerclear(&exec_time);
     572           0 :                         timerclear(&fetch_time);
     573             : 
     574           0 :                         zend_hash_str_update(Z_ARRVAL_P(return_value), cache_entry->key, cache_entry->key_length, &persistent_script_report);
     575             :                 }
     576             :         }
     577           0 :         accelerator_shm_read_unlock();
     578             : 
     579           0 :         return 1;
     580             : }
     581             : 
     582             : /* {{{ proto array accelerator_get_status([bool fetch_scripts])
     583             :    Obtain statistics information regarding code acceleration */
     584           9 : static ZEND_FUNCTION(opcache_get_status)
     585             : {
     586             :         zend_long reqs;
     587             :         zval memory_usage, statistics, scripts;
     588           9 :         zend_bool fetch_scripts = 1;
     589             : 
     590           9 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &fetch_scripts) == FAILURE) {
     591           0 :                 return;
     592             :         }
     593             : 
     594           9 :         if (!validate_api_restriction()) {
     595           0 :                 RETURN_FALSE;
     596             :         }
     597             : 
     598           9 :         if (!accel_startup_ok) {
     599           9 :                 RETURN_FALSE;
     600             :         }
     601             : 
     602           0 :         array_init(return_value);
     603             : 
     604             :         /* Trivia */
     605           0 :         add_assoc_bool(return_value, "opcache_enabled", ZCG(enabled) && (ZCG(counted) || ZCSG(accelerator_enabled)));
     606             : 
     607             : #ifdef HAVE_OPCACHE_FILE_CACHE
     608           0 :         if (ZCG(accel_directives).file_cache) {
     609           0 :                 add_assoc_string(return_value, "file_cache", ZCG(accel_directives).file_cache);
     610             :         }
     611           0 :         if (ZCG(accel_directives).file_cache_only) {
     612           0 :                 add_assoc_bool(return_value, "file_cache_only", 1);
     613           0 :                 return;
     614             :         }
     615             : #endif
     616             : 
     617           0 :         add_assoc_bool(return_value, "cache_full", ZSMMG(memory_exhausted));
     618           0 :         add_assoc_bool(return_value, "restart_pending", ZCSG(restart_pending));
     619           0 :         add_assoc_bool(return_value, "restart_in_progress", ZCSG(restart_in_progress));
     620             : 
     621             :         /* Memory usage statistics */
     622           0 :         array_init(&memory_usage);
     623           0 :         add_assoc_long(&memory_usage, "used_memory", ZCG(accel_directives).memory_consumption-zend_shared_alloc_get_free_memory()-ZSMMG(wasted_shared_memory));
     624           0 :         add_assoc_long(&memory_usage, "free_memory", zend_shared_alloc_get_free_memory());
     625           0 :         add_assoc_long(&memory_usage, "wasted_memory", ZSMMG(wasted_shared_memory));
     626           0 :         add_assoc_double(&memory_usage, "current_wasted_percentage", (((double) ZSMMG(wasted_shared_memory))/ZCG(accel_directives).memory_consumption)*100.0);
     627           0 :         add_assoc_zval(return_value, "memory_usage", &memory_usage);
     628             : 
     629           0 :         if (ZCSG(interned_strings_start) && ZCSG(interned_strings_end) && ZCSG(interned_strings_top)) {
     630             :                 zval interned_strings_usage;
     631             : 
     632           0 :                 array_init(&interned_strings_usage);
     633           0 :                 add_assoc_long(&interned_strings_usage, "buffer_size", ZCSG(interned_strings_end) - ZCSG(interned_strings_start));
     634           0 :                 add_assoc_long(&interned_strings_usage, "used_memory", ZCSG(interned_strings_top) - ZCSG(interned_strings_start));
     635           0 :                 add_assoc_long(&interned_strings_usage, "free_memory", ZCSG(interned_strings_end) - ZCSG(interned_strings_top));
     636           0 :                 add_assoc_long(&interned_strings_usage, "number_of_strings", ZCSG(interned_strings).nNumOfElements);
     637           0 :                 add_assoc_zval(return_value, "interned_strings_usage", &interned_strings_usage);
     638             :         }
     639             : 
     640             :         /* Accelerator statistics */
     641           0 :         array_init(&statistics);
     642           0 :         add_assoc_long(&statistics, "num_cached_scripts", ZCSG(hash).num_direct_entries);
     643           0 :         add_assoc_long(&statistics, "num_cached_keys",    ZCSG(hash).num_entries);
     644           0 :         add_assoc_long(&statistics, "max_cached_keys",    ZCSG(hash).max_num_entries);
     645           0 :         add_assoc_long(&statistics, "hits", (zend_long)ZCSG(hits));
     646           0 :         add_assoc_long(&statistics, "start_time", ZCSG(start_time));
     647           0 :         add_assoc_long(&statistics, "last_restart_time", ZCSG(last_restart_time));
     648           0 :         add_assoc_long(&statistics, "oom_restarts", ZCSG(oom_restarts));
     649           0 :         add_assoc_long(&statistics, "hash_restarts", ZCSG(hash_restarts));
     650           0 :         add_assoc_long(&statistics, "manual_restarts", ZCSG(manual_restarts));
     651           0 :         add_assoc_long(&statistics, "misses", ZSMMG(memory_exhausted)?ZCSG(misses):ZCSG(misses)-ZCSG(blacklist_misses));
     652           0 :         add_assoc_long(&statistics, "blacklist_misses", ZCSG(blacklist_misses));
     653           0 :         reqs = ZCSG(hits)+ZCSG(misses);
     654           0 :         add_assoc_double(&statistics, "blacklist_miss_ratio", reqs?(((double) ZCSG(blacklist_misses))/reqs)*100.0:0);
     655           0 :         add_assoc_double(&statistics, "opcache_hit_rate", reqs?(((double) ZCSG(hits))/reqs)*100.0:0);
     656           0 :         add_assoc_zval(return_value, "opcache_statistics", &statistics);
     657             : 
     658           0 :         if (fetch_scripts) {
     659             :                 /* accelerated scripts */
     660           0 :                 if (accelerator_get_scripts(&scripts)) {
     661           0 :                         add_assoc_zval(return_value, "scripts", &scripts);
     662             :                 }
     663             :         }
     664             : }
     665             : 
     666           0 : static int add_blacklist_path(zend_blacklist_entry *p, zval *return_value)
     667             : {
     668           0 :         add_next_index_stringl(return_value, p->path, p->path_length);
     669           0 :         return 0;
     670             : }
     671             : 
     672             : /* {{{ proto array accelerator_get_configuration()
     673             :    Obtain configuration information */
     674           0 : static ZEND_FUNCTION(opcache_get_configuration)
     675             : {
     676             :         zval directives, version, blacklist;
     677             : 
     678           0 :         if (zend_parse_parameters_none() == FAILURE) {
     679           0 :                 RETURN_FALSE;
     680             :         }
     681             : 
     682           0 :         if (!validate_api_restriction()) {
     683           0 :                 RETURN_FALSE;
     684             :         }
     685             : 
     686           0 :         array_init(return_value);
     687             : 
     688             :         /* directives */
     689           0 :         array_init(&directives);
     690           0 :         add_assoc_bool(&directives, "opcache.enable",              ZCG(enabled));
     691           0 :         add_assoc_bool(&directives, "opcache.enable_cli",          ZCG(accel_directives).enable_cli);
     692           0 :         add_assoc_bool(&directives, "opcache.use_cwd",             ZCG(accel_directives).use_cwd);
     693           0 :         add_assoc_bool(&directives, "opcache.validate_timestamps", ZCG(accel_directives).validate_timestamps);
     694           0 :         add_assoc_bool(&directives, "opcache.inherited_hack",      ZCG(accel_directives).inherited_hack);
     695           0 :         add_assoc_bool(&directives, "opcache.dups_fix",            ZCG(accel_directives).ignore_dups);
     696           0 :         add_assoc_bool(&directives, "opcache.revalidate_path",     ZCG(accel_directives).revalidate_path);
     697             : 
     698           0 :         add_assoc_long(&directives,   "opcache.log_verbosity_level",    ZCG(accel_directives).log_verbosity_level);
     699           0 :         add_assoc_long(&directives,  "opcache.memory_consumption",     ZCG(accel_directives).memory_consumption);
     700           0 :         add_assoc_long(&directives,  "opcache.interned_strings_buffer",ZCG(accel_directives).interned_strings_buffer);
     701           0 :         add_assoc_long(&directives,          "opcache.max_accelerated_files",  ZCG(accel_directives).max_accelerated_files);
     702           0 :         add_assoc_double(&directives, "opcache.max_wasted_percentage",  ZCG(accel_directives).max_wasted_percentage);
     703           0 :         add_assoc_long(&directives,          "opcache.consistency_checks",     ZCG(accel_directives).consistency_checks);
     704           0 :         add_assoc_long(&directives,          "opcache.force_restart_timeout",  ZCG(accel_directives).force_restart_timeout);
     705           0 :         add_assoc_long(&directives,          "opcache.revalidate_freq",        ZCG(accel_directives).revalidate_freq);
     706           0 :         add_assoc_string(&directives, "opcache.preferred_memory_model", STRING_NOT_NULL(ZCG(accel_directives).memory_model));
     707           0 :         add_assoc_string(&directives, "opcache.blacklist_filename",     STRING_NOT_NULL(ZCG(accel_directives).user_blacklist_filename));
     708           0 :         add_assoc_long(&directives,   "opcache.max_file_size",          ZCG(accel_directives).max_file_size);
     709           0 :         add_assoc_string(&directives, "opcache.error_log",              STRING_NOT_NULL(ZCG(accel_directives).error_log));
     710             : 
     711           0 :         add_assoc_bool(&directives,   "opcache.protect_memory",         ZCG(accel_directives).protect_memory);
     712           0 :         add_assoc_bool(&directives,   "opcache.save_comments",          ZCG(accel_directives).save_comments);
     713           0 :         add_assoc_bool(&directives,   "opcache.fast_shutdown",          ZCG(accel_directives).fast_shutdown);
     714           0 :         add_assoc_bool(&directives,   "opcache.enable_file_override",   ZCG(accel_directives).file_override_enabled);
     715           0 :         add_assoc_long(&directives,          "opcache.optimization_level",     ZCG(accel_directives).optimization_level);
     716             : 
     717             : #ifndef ZEND_WIN32
     718           0 :         add_assoc_string(&directives, "opcache.lockfile_path",          STRING_NOT_NULL(ZCG(accel_directives).lockfile_path));
     719             : #endif
     720             : 
     721             : #ifdef HAVE_OPCACHE_FILE_CACHE
     722           0 :         add_assoc_string(&directives, "opcache.file_cache",                    ZCG(accel_directives).file_cache ? ZCG(accel_directives).file_cache : "");
     723           0 :         add_assoc_bool(&directives,   "opcache.file_cache_only",               ZCG(accel_directives).file_cache_only);
     724           0 :         add_assoc_bool(&directives,   "opcache.file_cache_consistency_checks", ZCG(accel_directives).file_cache_consistency_checks);
     725             : #endif
     726             : 
     727           0 :         add_assoc_zval(return_value, "directives", &directives);
     728             : 
     729             :         /*version */
     730           0 :         array_init(&version);
     731           0 :         add_assoc_string(&version, "version", PHP_VERSION);
     732           0 :         add_assoc_string(&version, "opcache_product_name", ACCELERATOR_PRODUCT_NAME);
     733           0 :         add_assoc_zval(return_value, "version", &version);
     734             : 
     735             :         /* blacklist */
     736           0 :         array_init(&blacklist);
     737           0 :         zend_accel_blacklist_apply(&accel_blacklist, add_blacklist_path, &blacklist);
     738           0 :         add_assoc_zval(return_value, "blacklist", &blacklist);
     739             : }
     740             : 
     741             : /* {{{ proto void accelerator_reset()
     742             :    Request that the contents of the opcode cache to be reset */
     743           0 : static ZEND_FUNCTION(opcache_reset)
     744             : {
     745           0 :         if (zend_parse_parameters_none() == FAILURE) {
     746           0 :                 RETURN_FALSE;
     747             :         }
     748             : 
     749           0 :         if (!validate_api_restriction()) {
     750           0 :                 RETURN_FALSE;
     751             :         }
     752             : 
     753           0 :         if ((!ZCG(enabled) || !accel_startup_ok || !ZCSG(accelerator_enabled))
     754             : #if ENABLE_FILE_CACHE_FALLBACK
     755             :         && !fallback_process
     756             : #endif
     757             :         ) {
     758           0 :                 RETURN_FALSE;
     759             :         }
     760             : 
     761           0 :         zend_accel_schedule_restart(ACCEL_RESTART_USER);
     762           0 :         RETURN_TRUE;
     763             : }
     764             : 
     765             : /* {{{ proto void opcache_invalidate(string $script [, bool $force = false])
     766             :    Invalidates cached script (in necessary or forced) */
     767           0 : static ZEND_FUNCTION(opcache_invalidate)
     768             : {
     769             :         char *script_name;
     770             :         size_t script_name_len;
     771           0 :         zend_bool force = 0;
     772             : 
     773           0 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|b", &script_name, &script_name_len, &force) == FAILURE) {
     774           0 :                 return;
     775             :         }
     776             : 
     777           0 :         if (!validate_api_restriction()) {
     778           0 :                 RETURN_FALSE;
     779             :         }
     780             : 
     781           0 :         if (zend_accel_invalidate(script_name, script_name_len, force) == SUCCESS) {
     782           0 :                 RETURN_TRUE;
     783             :         } else {
     784           0 :                 RETURN_FALSE;
     785             :         }
     786             : }
     787             : 
     788           0 : static ZEND_FUNCTION(opcache_compile_file)
     789             : {
     790             :         char *script_name;
     791             :         size_t script_name_len;
     792             :         zend_file_handle handle;
     793           0 :         zend_op_array *op_array = NULL;
     794           0 :         zend_execute_data *orig_execute_data = NULL;
     795             : 
     796           0 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &script_name, &script_name_len) == FAILURE) {
     797           0 :                 return;
     798             :         }
     799             : 
     800           0 :         if (!ZCG(enabled) || !accel_startup_ok || !ZCSG(accelerator_enabled)) {
     801           0 :                 zend_error(E_NOTICE, ACCELERATOR_PRODUCT_NAME " seems to be disabled, can't compile file");
     802           0 :                 RETURN_FALSE;
     803             :         }
     804             : 
     805           0 :         handle.filename = script_name;
     806           0 :         handle.free_filename = 0;
     807           0 :         handle.opened_path = NULL;
     808           0 :         handle.type = ZEND_HANDLE_FILENAME;
     809             : 
     810           0 :         orig_execute_data = EG(current_execute_data);
     811             : 
     812           0 :         zend_try {
     813           0 :                 op_array = persistent_compile_file(&handle, ZEND_INCLUDE);
     814           0 :         } zend_catch {
     815           0 :                 EG(current_execute_data) = orig_execute_data;
     816           0 :                 zend_error(E_WARNING, ACCELERATOR_PRODUCT_NAME " could not compile file %s", handle.filename);
     817           0 :         } zend_end_try();
     818             : 
     819           0 :         if(op_array != NULL) {
     820           0 :                 destroy_op_array(op_array);
     821           0 :                 efree(op_array);
     822           0 :                 RETVAL_TRUE;
     823             :         } else {
     824           0 :                 RETVAL_FALSE;
     825             :         }
     826           0 :         zend_destroy_file_handle(&handle);
     827             : }
     828             : 
     829             : /* {{{ proto bool opcache_is_script_cached(string $script)
     830             :    Return true if the script is cached in OPCache, false if it is not cached or if OPCache is not running. */
     831           0 : static ZEND_FUNCTION(opcache_is_script_cached)
     832             : {
     833             :         zend_string *script_name;
     834             : 
     835           0 :         if (!validate_api_restriction()) {
     836           0 :                 RETURN_FALSE;
     837             :         }
     838             : 
     839           0 :         if (!ZCG(enabled) || !accel_startup_ok || !ZCSG(accelerator_enabled)) {
     840           0 :                 RETURN_FALSE;
     841             :         }
     842             : 
     843           0 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &script_name) == FAILURE) {
     844           0 :                 return;
     845             :         }
     846             : 
     847           0 :         RETURN_BOOL(filename_is_in_cache(script_name));
     848             : }

Generated by: LCOV version 1.10

Generated at Sun, 28 Aug 2016 17:10:05 +0000 (15 hours ago)

Copyright © 2005-2016 The PHP Group
All rights reserved.