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