1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
/*
+----------------------------------------------------------------------+
| Zend OPcache |
+----------------------------------------------------------------------+
| Copyright (c) The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| https://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Andi Gutmans <andi@php.net> |
| Zeev Suraski <zeev@php.net> |
| Stanislav Malyshev <stas@zend.com> |
| Dmitry Stogov <dmitry@php.net> |
+----------------------------------------------------------------------+
*/
#ifndef ZEND_SHARED_ALLOC_H
#define ZEND_SHARED_ALLOC_H
#include "zend.h"
#include "ZendAccelerator.h"
#if defined(__APPLE__) && defined(__MACH__) /* darwin */
# ifdef HAVE_SHM_MMAP_POSIX
# define USE_SHM_OPEN 1
# endif
# ifdef HAVE_SHM_MMAP_ANON
# define USE_MMAP 1
# endif
#elif defined(__linux__) || defined(_AIX)
# ifdef HAVE_SHM_MMAP_POSIX
# define USE_SHM_OPEN 1
# endif
# ifdef HAVE_SHM_IPC
# define USE_SHM 1
# endif
# ifdef HAVE_SHM_MMAP_ANON
# define USE_MMAP 1
# endif
#elif defined(__sparc) || defined(__sun)
# ifdef HAVE_SHM_MMAP_POSIX
# define USE_SHM_OPEN 1
# endif
# ifdef HAVE_SHM_IPC
# define USE_SHM 1
# endif
# if defined(__i386)
# ifdef HAVE_SHM_MMAP_ANON
# define USE_MMAP 1
# endif
# endif
#else
# ifdef HAVE_SHM_MMAP_POSIX
# define USE_SHM_OPEN 1
# endif
# ifdef HAVE_SHM_MMAP_ANON
# define USE_MMAP 1
# endif
# ifdef HAVE_SHM_IPC
# define USE_SHM 1
# endif
#endif
#define ALLOC_FAILURE 0
#define ALLOC_SUCCESS 1
#define FAILED_REATTACHED 2
#define SUCCESSFULLY_REATTACHED 4
#define ALLOC_FAIL_MAPPING 8
#define ALLOC_FALLBACK 9
typedef struct _zend_shared_segment {
size_t size;
size_t end;
size_t pos; /* position for simple stack allocator */
void *p;
} zend_shared_segment;
typedef int (*create_segments_t)(size_t requested_size, zend_shared_segment ***shared_segments, int *shared_segment_count, const char **error_in);
typedef int (*detach_segment_t)(zend_shared_segment *shared_segment);
typedef struct {
create_segments_t create_segments;
detach_segment_t detach_segment;
size_t (*segment_type_size)(void);
} zend_shared_memory_handlers;
typedef struct _handler_entry {
const char *name;
const zend_shared_memory_handlers *handler;
} zend_shared_memory_handler_entry;
typedef struct _zend_shared_memory_state {
size_t *positions; /* current positions for each segment */
size_t shared_free; /* amount of free shared memory */
} zend_shared_memory_state;
typedef struct _zend_smm_shared_globals {
/* Shared Memory Manager */
zend_shared_segment **shared_segments;
/* Number of allocated shared segments */
int shared_segments_count;
/* Amount of free shared memory */
size_t shared_free;
/* Amount of shared memory allocated by garbage */
size_t wasted_shared_memory;
/* No more shared memory flag */
bool memory_exhausted;
/* Saved Shared Allocator State */
zend_shared_memory_state shared_memory_state;
/* Pointer to the application's shared data structures */
void *app_shared_globals;
/* Reserved shared memory */
void *reserved;
size_t reserved_size;
} zend_smm_shared_globals;
ZEND_EXT_API extern zend_smm_shared_globals *smm_shared_globals;
#define ZSMMG(element) (smm_shared_globals->element)
#define SHARED_ALLOC_REATTACHED (SUCCESS+1)
BEGIN_EXTERN_C()
int zend_shared_alloc_startup(size_t requested_size, size_t reserved_size);
void zend_shared_alloc_shutdown(void);
/* allocate shared memory block */
void *zend_shared_alloc(size_t size);
/**
* Wrapper for zend_shared_alloc() which aligns at 64-byte boundary if
* AVX or SSE2 are used.
*/
static inline void *zend_shared_alloc_aligned(size_t size) {
#if defined(__AVX__) || defined(__SSE2__)
/* Align to 64-byte boundary */
void *p = zend_shared_alloc(size + 64);
return (void *)(((uintptr_t)p + 63L) & ~63L);
#else
return zend_shared_alloc(size);
#endif
}
/* copy into shared memory */
void *zend_shared_memdup_get_put_free(void *source, size_t size);
void *zend_shared_memdup_put_free(void *source, size_t size);
void *zend_shared_memdup_free(void *source, size_t size);
void *zend_shared_memdup_get_put(void *source, size_t size);
void *zend_shared_memdup_put(void *source, size_t size);
void *zend_shared_memdup(void *source, size_t size);
int zend_shared_memdup_size(void *p, size_t size);
bool zend_accel_in_shm(void *ptr);
typedef union _align_test {
void *ptr;
double dbl;
zend_long lng;
} align_test;
#if ZEND_GCC_VERSION >= 2000
# define PLATFORM_ALIGNMENT (__alignof__(align_test) < 8 ? 8 : __alignof__(align_test))
#else
# define PLATFORM_ALIGNMENT (sizeof(align_test))
#endif
#define ZEND_ALIGNED_SIZE(size) \
ZEND_MM_ALIGNED_SIZE_EX(size, PLATFORM_ALIGNMENT)
/* exclusive locking */
void zend_shared_alloc_lock(void);
void zend_shared_alloc_unlock(void); /* returns the allocated size during lock..unlock */
void zend_shared_alloc_safe_unlock(void);
/* old/new mapping functions */
void zend_shared_alloc_init_xlat_table(void);
void zend_shared_alloc_destroy_xlat_table(void);
void zend_shared_alloc_clear_xlat_table(void);
uint32_t zend_shared_alloc_checkpoint_xlat_table(void);
void zend_shared_alloc_restore_xlat_table(uint32_t checkpoint);
void zend_shared_alloc_register_xlat_entry(const void *key, const void *value);
void *zend_shared_alloc_get_xlat_entry(const void *key);
size_t zend_shared_alloc_get_free_memory(void);
void zend_shared_alloc_save_state(void);
void zend_shared_alloc_restore_state(void);
const char *zend_accel_get_shared_model(void);
/**
* Memory write protection
*
* @param protected true to protect shared memory (read-only), false
* to unprotect shared memory (writable)
*/
void zend_accel_shared_protect(bool protected);
#ifdef USE_MMAP
extern const zend_shared_memory_handlers zend_alloc_mmap_handlers;
#endif
#ifdef USE_SHM
extern const zend_shared_memory_handlers zend_alloc_shm_handlers;
#endif
#ifdef USE_SHM_OPEN
extern const zend_shared_memory_handlers zend_alloc_posix_handlers;
#endif
#ifdef ZEND_WIN32
extern const zend_shared_memory_handlers zend_alloc_win32_handlers;
void zend_shared_alloc_create_lock(void);
void zend_shared_alloc_lock_win32(void);
void zend_shared_alloc_unlock_win32(void);
#endif
END_EXTERN_C()
#endif /* ZEND_SHARED_ALLOC_H */
|
