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 | https://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 <errno.h>
23 #include "ZendAccelerator.h"
24 #include "zend_shared_alloc.h"
25 #ifdef HAVE_UNISTD_H
26 # include <unistd.h>
27 #endif
28 #include <fcntl.h>
29 #ifndef ZEND_WIN32
30 # include <sys/types.h>
31 # include <signal.h>
32 # include <sys/stat.h>
33 # include <stdio.h>
34 #endif
35
36 #ifdef HAVE_MPROTECT
37 # include "sys/mman.h"
38 #endif
39
40 #define SEM_FILENAME_PREFIX ".ZendSem."
41 #define S_H(s) g_shared_alloc_handler->s
42
43 /* True globals */
44 /* old/new mapping. We can use true global even for ZTS because its usage
45 is wrapped with exclusive lock anyway */
46 static const zend_shared_memory_handlers *g_shared_alloc_handler = NULL;
47 static const char *g_shared_model;
48 /* pointer to globals allocated in SHM and shared across processes */
49 zend_smm_shared_globals *smm_shared_globals;
50
51 #ifndef ZEND_WIN32
52 #ifdef ZTS
53 static MUTEX_T zts_lock;
54 #endif
55 int lock_file = -1;
56 static char lockfile_name[MAXPATHLEN];
57 #endif
58
59 static const zend_shared_memory_handler_entry handler_table[] = {
60 #ifdef USE_MMAP
61 { "mmap", &zend_alloc_mmap_handlers },
62 #endif
63 #ifdef USE_SHM
64 { "shm", &zend_alloc_shm_handlers },
65 #endif
66 #ifdef USE_SHM_OPEN
67 { "posix", &zend_alloc_posix_handlers },
68 #endif
69 #ifdef ZEND_WIN32
70 { "win32", &zend_alloc_win32_handlers },
71 #endif
72 { NULL, NULL}
73 };
74
75 #ifndef ZEND_WIN32
zend_shared_alloc_create_lock(char * lockfile_path)76 void zend_shared_alloc_create_lock(char *lockfile_path)
77 {
78 int val;
79
80 #ifdef ZTS
81 zts_lock = tsrm_mutex_alloc();
82 #endif
83
84 snprintf(lockfile_name, sizeof(lockfile_name), "%s/%sXXXXXX", lockfile_path, SEM_FILENAME_PREFIX);
85 lock_file = mkstemp(lockfile_name);
86 fchmod(lock_file, 0666);
87
88 if (lock_file == -1) {
89 zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Unable to create lock file: %s (%d)", strerror(errno), errno);
90 }
91 val = fcntl(lock_file, F_GETFD, 0);
92 val |= FD_CLOEXEC;
93 fcntl(lock_file, F_SETFD, val);
94
95 unlink(lockfile_name);
96 }
97 #endif
98
no_memory_bailout(size_t allocate_size,char * error)99 static void no_memory_bailout(size_t allocate_size, char *error)
100 {
101 zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Unable to allocate shared memory segment of %zu bytes: %s: %s (%d)", allocate_size, error?error:"unknown", strerror(errno), errno );
102 }
103
copy_shared_segments(void * to,void * from,int count,int size)104 static void copy_shared_segments(void *to, void *from, int count, int size)
105 {
106 zend_shared_segment **shared_segments_v = (zend_shared_segment **)to;
107 void *shared_segments_to_p = ((char *)to + count*(sizeof(void *)));
108 void *shared_segments_from_p = from;
109 int i;
110
111 for (i = 0; i < count; i++) {
112 shared_segments_v[i] = shared_segments_to_p;
113 memcpy(shared_segments_to_p, shared_segments_from_p, size);
114 shared_segments_to_p = ((char *)shared_segments_to_p + size);
115 shared_segments_from_p = ((char *)shared_segments_from_p + size);
116 }
117 }
118
zend_shared_alloc_try(const zend_shared_memory_handler_entry * he,size_t requested_size,zend_shared_segment *** shared_segments_p,int * shared_segments_count,char ** error_in)119 static int zend_shared_alloc_try(const zend_shared_memory_handler_entry *he, size_t requested_size, zend_shared_segment ***shared_segments_p, int *shared_segments_count, char **error_in)
120 {
121 int res;
122 g_shared_alloc_handler = he->handler;
123 g_shared_model = he->name;
124 ZSMMG(shared_segments) = NULL;
125 ZSMMG(shared_segments_count) = 0;
126
127 res = S_H(create_segments)(requested_size, shared_segments_p, shared_segments_count, error_in);
128
129 if (res) {
130 /* this model works! */
131 return res;
132 }
133 if (*shared_segments_p) {
134 int i;
135 /* cleanup */
136 for (i = 0; i < *shared_segments_count; i++) {
137 if ((*shared_segments_p)[i]->p && (*shared_segments_p)[i]->p != (void *)-1) {
138 S_H(detach_segment)((*shared_segments_p)[i]);
139 }
140 }
141 free(*shared_segments_p);
142 *shared_segments_p = NULL;
143 }
144 g_shared_alloc_handler = NULL;
145 return ALLOC_FAILURE;
146 }
147
zend_shared_alloc_startup(size_t requested_size,size_t reserved_size)148 int zend_shared_alloc_startup(size_t requested_size, size_t reserved_size)
149 {
150 zend_shared_segment **tmp_shared_segments;
151 size_t shared_segments_array_size;
152 zend_smm_shared_globals tmp_shared_globals, *p_tmp_shared_globals;
153 char *error_in = NULL;
154 const zend_shared_memory_handler_entry *he;
155 int res = ALLOC_FAILURE;
156 int i;
157
158 /* shared_free must be valid before we call zend_shared_alloc()
159 * - make it temporarily point to a local variable
160 */
161 smm_shared_globals = &tmp_shared_globals;
162 ZSMMG(shared_free) = requested_size - reserved_size; /* goes to tmp_shared_globals.shared_free */
163
164 #ifndef ZEND_WIN32
165 zend_shared_alloc_create_lock(ZCG(accel_directives).lockfile_path);
166 #else
167 zend_shared_alloc_create_lock();
168 #endif
169
170 if (ZCG(accel_directives).memory_model && ZCG(accel_directives).memory_model[0]) {
171 char *model = ZCG(accel_directives).memory_model;
172 /* "cgi" is really "shm"... */
173 if (strncmp(ZCG(accel_directives).memory_model, "cgi", sizeof("cgi")) == 0) {
174 model = "shm";
175 }
176
177 for (he = handler_table; he->name; he++) {
178 if (strcmp(model, he->name) == 0) {
179 res = zend_shared_alloc_try(he, requested_size, &ZSMMG(shared_segments), &ZSMMG(shared_segments_count), &error_in);
180 if (res) {
181 /* this model works! */
182 break;
183 }
184 }
185 }
186 }
187
188 if (res == FAILED_REATTACHED) {
189 smm_shared_globals = NULL;
190 return res;
191 }
192 #if ENABLE_FILE_CACHE_FALLBACK
193 if (ALLOC_FALLBACK == res) {
194 smm_shared_globals = NULL;
195 return ALLOC_FALLBACK;
196 }
197 #endif
198
199 if (!g_shared_alloc_handler) {
200 /* try memory handlers in order */
201 for (he = handler_table; he->name; he++) {
202 res = zend_shared_alloc_try(he, requested_size, &ZSMMG(shared_segments), &ZSMMG(shared_segments_count), &error_in);
203 if (res) {
204 /* this model works! */
205 break;
206 }
207 }
208 }
209
210 if (!g_shared_alloc_handler) {
211 no_memory_bailout(requested_size, error_in);
212 return ALLOC_FAILURE;
213 }
214
215 if (res == SUCCESSFULLY_REATTACHED) {
216 return res;
217 }
218 #if ENABLE_FILE_CACHE_FALLBACK
219 if (ALLOC_FALLBACK == res) {
220 smm_shared_globals = NULL;
221 return ALLOC_FALLBACK;
222 }
223 #endif
224
225 for (i = 0; i < ZSMMG(shared_segments_count); i++) {
226 ZSMMG(shared_segments)[i]->end = ZSMMG(shared_segments)[i]->size;
227 }
228
229 shared_segments_array_size = ZSMMG(shared_segments_count) * S_H(segment_type_size)();
230
231 /* move shared_segments and shared_free to shared memory */
232 ZCG(locked) = 1; /* no need to perform a real lock at this point */
233
234 p_tmp_shared_globals = (zend_smm_shared_globals *) zend_shared_alloc(sizeof(zend_smm_shared_globals));
235 if (!p_tmp_shared_globals) {
236 zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");
237 return ALLOC_FAILURE;
238 }
239 memset(p_tmp_shared_globals, 0, sizeof(zend_smm_shared_globals));
240
241 tmp_shared_segments = zend_shared_alloc(shared_segments_array_size + ZSMMG(shared_segments_count) * sizeof(void *));
242 if (!tmp_shared_segments) {
243 zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");
244 return ALLOC_FAILURE;
245 }
246
247 copy_shared_segments(tmp_shared_segments, ZSMMG(shared_segments)[0], ZSMMG(shared_segments_count), S_H(segment_type_size)());
248
249 *p_tmp_shared_globals = tmp_shared_globals;
250 smm_shared_globals = p_tmp_shared_globals;
251
252 free(ZSMMG(shared_segments));
253 ZSMMG(shared_segments) = tmp_shared_segments;
254
255 ZSMMG(shared_memory_state).positions = (size_t *)zend_shared_alloc(sizeof(size_t) * ZSMMG(shared_segments_count));
256 if (!ZSMMG(shared_memory_state).positions) {
257 zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");
258 return ALLOC_FAILURE;
259 }
260
261 if (reserved_size) {
262 i = ZSMMG(shared_segments_count) - 1;
263 if (ZSMMG(shared_segments)[i]->size - ZSMMG(shared_segments)[i]->pos >= reserved_size) {
264 ZSMMG(shared_segments)[i]->end = ZSMMG(shared_segments)[i]->size - reserved_size;
265 ZSMMG(reserved) = (char*)ZSMMG(shared_segments)[i]->p + ZSMMG(shared_segments)[i]->end;
266 ZSMMG(reserved_size) = reserved_size;
267 } else {
268 zend_accel_error_noreturn(ACCEL_LOG_FATAL, "Insufficient shared memory!");
269 return ALLOC_FAILURE;
270 }
271 }
272
273 ZCG(locked) = 0;
274
275 return res;
276 }
277
zend_shared_alloc_shutdown(void)278 void zend_shared_alloc_shutdown(void)
279 {
280 zend_shared_segment **tmp_shared_segments;
281 zend_shared_segment *shared_segments_buf[16];
282 size_t shared_segments_array_size;
283 zend_smm_shared_globals tmp_shared_globals;
284 int i;
285
286 tmp_shared_globals = *smm_shared_globals;
287 smm_shared_globals = &tmp_shared_globals;
288 shared_segments_array_size = ZSMMG(shared_segments_count) * (S_H(segment_type_size)() + sizeof(void *));
289 if (shared_segments_array_size > 16) {
290 tmp_shared_segments = malloc(shared_segments_array_size);
291 } else {
292 tmp_shared_segments = shared_segments_buf;
293 }
294 copy_shared_segments(tmp_shared_segments, ZSMMG(shared_segments)[0], ZSMMG(shared_segments_count), S_H(segment_type_size)());
295 ZSMMG(shared_segments) = tmp_shared_segments;
296
297 for (i = 0; i < ZSMMG(shared_segments_count); i++) {
298 S_H(detach_segment)(ZSMMG(shared_segments)[i]);
299 }
300 if (shared_segments_array_size > 16) {
301 free(ZSMMG(shared_segments));
302 }
303 ZSMMG(shared_segments) = NULL;
304 g_shared_alloc_handler = NULL;
305 #ifndef ZEND_WIN32
306 close(lock_file);
307
308 # ifdef ZTS
309 tsrm_mutex_free(zts_lock);
310 # endif
311 #endif
312 }
313
zend_shared_alloc_get_largest_free_block(void)314 static size_t zend_shared_alloc_get_largest_free_block(void)
315 {
316 int i;
317 size_t largest_block_size = 0;
318
319 for (i = 0; i < ZSMMG(shared_segments_count); i++) {
320 size_t block_size = ZSMMG(shared_segments)[i]->end - ZSMMG(shared_segments)[i]->pos;
321
322 if (block_size>largest_block_size) {
323 largest_block_size = block_size;
324 }
325 }
326 return largest_block_size;
327 }
328
329 #define MIN_FREE_MEMORY 64*1024
330
331 #define SHARED_ALLOC_FAILED() do { \
332 zend_accel_error(ACCEL_LOG_WARNING, "Not enough free shared space to allocate "ZEND_LONG_FMT" bytes ("ZEND_LONG_FMT" bytes free)", (zend_long)size, (zend_long)ZSMMG(shared_free)); \
333 if (zend_shared_alloc_get_largest_free_block() < MIN_FREE_MEMORY) { \
334 ZSMMG(memory_exhausted) = 1; \
335 } \
336 } while (0)
337
zend_shared_alloc(size_t size)338 void *zend_shared_alloc(size_t size)
339 {
340 int i;
341 unsigned int block_size = ZEND_ALIGNED_SIZE(size);
342
343 #if 1
344 if (!ZCG(locked)) {
345 zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Shared memory lock not obtained");
346 }
347 #endif
348 if (block_size > ZSMMG(shared_free)) { /* No hope to find a big-enough block */
349 SHARED_ALLOC_FAILED();
350 return NULL;
351 }
352 for (i = 0; i < ZSMMG(shared_segments_count); i++) {
353 if (ZSMMG(shared_segments)[i]->end - ZSMMG(shared_segments)[i]->pos >= block_size) { /* found a valid block */
354 void *retval = (void *) (((char *) ZSMMG(shared_segments)[i]->p) + ZSMMG(shared_segments)[i]->pos);
355
356 ZSMMG(shared_segments)[i]->pos += block_size;
357 ZSMMG(shared_free) -= block_size;
358 ZEND_ASSERT(((zend_uintptr_t)retval & 0x7) == 0); /* should be 8 byte aligned */
359 return retval;
360 }
361 }
362 SHARED_ALLOC_FAILED();
363 return NULL;
364 }
365
zend_shared_memdup_size(void * source,size_t size)366 int zend_shared_memdup_size(void *source, size_t size)
367 {
368 void *old_p;
369 zend_ulong key = (zend_ulong)source;
370
371 key = (key >> 3) | (key << ((sizeof(key) * 8) - 3)); /* key = _rotr(key, 3);*/
372 if ((old_p = zend_hash_index_find_ptr(&ZCG(xlat_table), key)) != NULL) {
373 /* we already duplicated this pointer */
374 return 0;
375 }
376 zend_hash_index_add_new_ptr(&ZCG(xlat_table), key, source);
377 return ZEND_ALIGNED_SIZE(size);
378 }
379
_zend_shared_memdup(void * source,size_t size,bool get_xlat,bool set_xlat,bool free_source)380 static zend_always_inline void *_zend_shared_memdup(void *source, size_t size, bool get_xlat, bool set_xlat, bool free_source)
381 {
382 void *old_p, *retval;
383 zend_ulong key;
384
385 if (get_xlat) {
386 key = (zend_ulong)source;
387 key = (key >> 3) | (key << ((sizeof(key) * 8) - 3)); /* key = _rotr(key, 3);*/
388 if ((old_p = zend_hash_index_find_ptr(&ZCG(xlat_table), key)) != NULL) {
389 /* we already duplicated this pointer */
390 return old_p;
391 }
392 }
393 retval = ZCG(mem);
394 ZCG(mem) = (void*)(((char*)ZCG(mem)) + ZEND_ALIGNED_SIZE(size));
395 memcpy(retval, source, size);
396 if (set_xlat) {
397 if (!get_xlat) {
398 key = (zend_ulong)source;
399 key = (key >> 3) | (key << ((sizeof(key) * 8) - 3)); /* key = _rotr(key, 3);*/
400 }
401 zend_hash_index_add_new_ptr(&ZCG(xlat_table), key, retval);
402 }
403 if (free_source) {
404 efree(source);
405 }
406 return retval;
407 }
408
zend_shared_memdup_get_put_free(void * source,size_t size)409 void *zend_shared_memdup_get_put_free(void *source, size_t size)
410 {
411 return _zend_shared_memdup(source, size, 1, 1, 1);
412 }
413
zend_shared_memdup_put_free(void * source,size_t size)414 void *zend_shared_memdup_put_free(void *source, size_t size)
415 {
416 return _zend_shared_memdup(source, size, 0, 1, 1);
417 }
418
zend_shared_memdup_free(void * source,size_t size)419 void *zend_shared_memdup_free(void *source, size_t size)
420 {
421 return _zend_shared_memdup(source, size, 0, 0, 1);
422 }
423
zend_shared_memdup_get_put(void * source,size_t size)424 void *zend_shared_memdup_get_put(void *source, size_t size)
425 {
426 return _zend_shared_memdup(source, size, 1, 1, 0);
427 }
428
zend_shared_memdup_put(void * source,size_t size)429 void *zend_shared_memdup_put(void *source, size_t size)
430 {
431 return _zend_shared_memdup(source, size, 0, 1, 0);
432 }
433
zend_shared_memdup(void * source,size_t size)434 void *zend_shared_memdup(void *source, size_t size)
435 {
436 return _zend_shared_memdup(source, size, 0, 0, 0);
437 }
438
zend_shared_alloc_safe_unlock(void)439 void zend_shared_alloc_safe_unlock(void)
440 {
441 if (ZCG(locked)) {
442 zend_shared_alloc_unlock();
443 }
444 }
445
zend_shared_alloc_lock(void)446 void zend_shared_alloc_lock(void)
447 {
448 #ifndef ZEND_WIN32
449 struct flock mem_write_lock;
450
451 mem_write_lock.l_type = F_WRLCK;
452 mem_write_lock.l_whence = SEEK_SET;
453 mem_write_lock.l_start = 0;
454 mem_write_lock.l_len = 1;
455
456 #ifdef ZTS
457 tsrm_mutex_lock(zts_lock);
458 #endif
459
460 #if 0
461 /* this will happen once per process, and will un-globalize mem_write_lock */
462 if (mem_write_lock.l_pid == -1) {
463 mem_write_lock.l_pid = getpid();
464 }
465 #endif
466
467 while (1) {
468 if (fcntl(lock_file, F_SETLKW, &mem_write_lock) == -1) {
469 if (errno == EINTR) {
470 continue;
471 }
472 zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Cannot create lock - %s (%d)", strerror(errno), errno);
473 }
474 break;
475 }
476 #else
477 zend_shared_alloc_lock_win32();
478 #endif
479
480 ZCG(locked) = 1;
481 }
482
zend_shared_alloc_unlock(void)483 void zend_shared_alloc_unlock(void)
484 {
485 #ifndef ZEND_WIN32
486 struct flock mem_write_unlock;
487
488 mem_write_unlock.l_type = F_UNLCK;
489 mem_write_unlock.l_whence = SEEK_SET;
490 mem_write_unlock.l_start = 0;
491 mem_write_unlock.l_len = 1;
492 #endif
493
494 ZCG(locked) = 0;
495
496 #ifndef ZEND_WIN32
497 if (fcntl(lock_file, F_SETLK, &mem_write_unlock) == -1) {
498 zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Cannot remove lock - %s (%d)", strerror(errno), errno);
499 }
500 #ifdef ZTS
501 tsrm_mutex_unlock(zts_lock);
502 #endif
503 #else
504 zend_shared_alloc_unlock_win32();
505 #endif
506 }
507
zend_shared_alloc_init_xlat_table(void)508 void zend_shared_alloc_init_xlat_table(void)
509 {
510 /* Prepare translation table */
511 zend_hash_init(&ZCG(xlat_table), 128, NULL, NULL, 0);
512 }
513
zend_shared_alloc_destroy_xlat_table(void)514 void zend_shared_alloc_destroy_xlat_table(void)
515 {
516 /* Destroy translation table */
517 zend_hash_destroy(&ZCG(xlat_table));
518 }
519
zend_shared_alloc_clear_xlat_table(void)520 void zend_shared_alloc_clear_xlat_table(void)
521 {
522 zend_hash_clean(&ZCG(xlat_table));
523 }
524
zend_shared_alloc_checkpoint_xlat_table(void)525 uint32_t zend_shared_alloc_checkpoint_xlat_table(void)
526 {
527 return ZCG(xlat_table).nNumUsed;
528 }
529
zend_shared_alloc_restore_xlat_table(uint32_t checkpoint)530 void zend_shared_alloc_restore_xlat_table(uint32_t checkpoint)
531 {
532 zend_hash_discard(&ZCG(xlat_table), checkpoint);
533 }
534
zend_shared_alloc_register_xlat_entry(const void * old,const void * new)535 void zend_shared_alloc_register_xlat_entry(const void *old, const void *new)
536 {
537 zend_ulong key = (zend_ulong)old;
538
539 key = (key >> 3) | (key << ((sizeof(key) * 8) - 3)); /* key = _rotr(key, 3);*/
540 zend_hash_index_add_new_ptr(&ZCG(xlat_table), key, (void*)new);
541 }
542
zend_shared_alloc_get_xlat_entry(const void * old)543 void *zend_shared_alloc_get_xlat_entry(const void *old)
544 {
545 void *retval;
546 zend_ulong key = (zend_ulong)old;
547
548 key = (key >> 3) | (key << ((sizeof(key) * 8) - 3)); /* key = _rotr(key, 3);*/
549 if ((retval = zend_hash_index_find_ptr(&ZCG(xlat_table), key)) == NULL) {
550 return NULL;
551 }
552 return retval;
553 }
554
zend_shared_alloc_get_free_memory(void)555 size_t zend_shared_alloc_get_free_memory(void)
556 {
557 return ZSMMG(shared_free);
558 }
559
zend_shared_alloc_save_state(void)560 void zend_shared_alloc_save_state(void)
561 {
562 int i;
563
564 for (i = 0; i < ZSMMG(shared_segments_count); i++) {
565 ZSMMG(shared_memory_state).positions[i] = ZSMMG(shared_segments)[i]->pos;
566 }
567 ZSMMG(shared_memory_state).shared_free = ZSMMG(shared_free);
568 }
569
zend_shared_alloc_restore_state(void)570 void zend_shared_alloc_restore_state(void)
571 {
572 int i;
573
574 for (i = 0; i < ZSMMG(shared_segments_count); i++) {
575 ZSMMG(shared_segments)[i]->pos = ZSMMG(shared_memory_state).positions[i];
576 }
577 ZSMMG(shared_free) = ZSMMG(shared_memory_state).shared_free;
578 ZSMMG(memory_exhausted) = 0;
579 ZSMMG(wasted_shared_memory) = 0;
580 }
581
zend_accel_get_shared_model(void)582 const char *zend_accel_get_shared_model(void)
583 {
584 return g_shared_model;
585 }
586
zend_accel_shared_protect(int mode)587 void zend_accel_shared_protect(int mode)
588 {
589 #ifdef HAVE_MPROTECT
590 int i;
591
592 if (!smm_shared_globals) {
593 return;
594 }
595
596 if (mode) {
597 mode = PROT_READ;
598 } else {
599 mode = PROT_READ|PROT_WRITE;
600 }
601
602 for (i = 0; i < ZSMMG(shared_segments_count); i++) {
603 mprotect(ZSMMG(shared_segments)[i]->p, ZSMMG(shared_segments)[i]->end, mode);
604 }
605 #elif defined(ZEND_WIN32)
606 int i;
607
608 if (!smm_shared_globals) {
609 return;
610 }
611
612 if (mode) {
613 mode = PAGE_READONLY;
614 } else {
615 mode = PAGE_READWRITE;
616 }
617
618 for (i = 0; i < ZSMMG(shared_segments_count); i++) {
619 DWORD oldProtect;
620 if (!VirtualProtect(ZSMMG(shared_segments)[i]->p, ZSMMG(shared_segments)[i]->end, mode, &oldProtect)) {
621 zend_accel_error_noreturn(ACCEL_LOG_ERROR, "Failed to protect memory");
622 }
623 }
624 #endif
625 }
626
zend_accel_in_shm(void * ptr)627 int zend_accel_in_shm(void *ptr)
628 {
629 int i;
630
631 if (!smm_shared_globals) {
632 return 0;
633 }
634
635 for (i = 0; i < ZSMMG(shared_segments_count); i++) {
636 if ((char*)ptr >= (char*)ZSMMG(shared_segments)[i]->p &&
637 (char*)ptr < (char*)ZSMMG(shared_segments)[i]->p + ZSMMG(shared_segments)[i]->end) {
638 return 1;
639 }
640 }
641 return 0;
642 }
643
