1 #include "jemalloc/internal/jemalloc_internal.h"
2 #ifndef JEMALLOC_ZONE
3 # error "This source file is for zones on Darwin (OS X)."
4 #endif
5
6 /*
7 * The malloc_default_purgeable_zone function is only available on >= 10.6.
8 * We need to check whether it is present at runtime, thus the weak_import.
9 */
10 extern malloc_zone_t *malloc_default_purgeable_zone(void)
11 JEMALLOC_ATTR(weak_import);
12
13 /******************************************************************************/
14 /* Data. */
15
16 static malloc_zone_t zone;
17 static struct malloc_introspection_t zone_introspect;
18
19 /******************************************************************************/
20 /* Function prototypes for non-inline static functions. */
21
22 static size_t zone_size(malloc_zone_t *zone, void *ptr);
23 static void *zone_malloc(malloc_zone_t *zone, size_t size);
24 static void *zone_calloc(malloc_zone_t *zone, size_t num, size_t size);
25 static void *zone_valloc(malloc_zone_t *zone, size_t size);
26 static void zone_free(malloc_zone_t *zone, void *ptr);
27 static void *zone_realloc(malloc_zone_t *zone, void *ptr, size_t size);
28 #if (JEMALLOC_ZONE_VERSION >= 5)
29 static void *zone_memalign(malloc_zone_t *zone, size_t alignment,
30 #endif
31 #if (JEMALLOC_ZONE_VERSION >= 6)
32 size_t size);
33 static void zone_free_definite_size(malloc_zone_t *zone, void *ptr,
34 size_t size);
35 #endif
36 static void *zone_destroy(malloc_zone_t *zone);
37 static size_t zone_good_size(malloc_zone_t *zone, size_t size);
38 static void zone_force_lock(malloc_zone_t *zone);
39 static void zone_force_unlock(malloc_zone_t *zone);
40
41 /******************************************************************************/
42 /*
43 * Functions.
44 */
45
46 static size_t
zone_size(malloc_zone_t * zone,void * ptr)47 zone_size(malloc_zone_t *zone, void *ptr)
48 {
49
50 /*
51 * There appear to be places within Darwin (such as setenv(3)) that
52 * cause calls to this function with pointers that *no* zone owns. If
53 * we knew that all pointers were owned by *some* zone, we could split
54 * our zone into two parts, and use one as the default allocator and
55 * the other as the default deallocator/reallocator. Since that will
56 * not work in practice, we must check all pointers to assure that they
57 * reside within a mapped chunk before determining size.
58 */
59 return (ivsalloc(ptr, config_prof));
60 }
61
62 static void *
zone_malloc(malloc_zone_t * zone,size_t size)63 zone_malloc(malloc_zone_t *zone, size_t size)
64 {
65
66 return (je_malloc(size));
67 }
68
69 static void *
zone_calloc(malloc_zone_t * zone,size_t num,size_t size)70 zone_calloc(malloc_zone_t *zone, size_t num, size_t size)
71 {
72
73 return (je_calloc(num, size));
74 }
75
76 static void *
zone_valloc(malloc_zone_t * zone,size_t size)77 zone_valloc(malloc_zone_t *zone, size_t size)
78 {
79 void *ret = NULL; /* Assignment avoids useless compiler warning. */
80
81 je_posix_memalign(&ret, PAGE, size);
82
83 return (ret);
84 }
85
86 static void
zone_free(malloc_zone_t * zone,void * ptr)87 zone_free(malloc_zone_t *zone, void *ptr)
88 {
89
90 if (ivsalloc(ptr, config_prof) != 0) {
91 je_free(ptr);
92 return;
93 }
94
95 free(ptr);
96 }
97
98 static void *
zone_realloc(malloc_zone_t * zone,void * ptr,size_t size)99 zone_realloc(malloc_zone_t *zone, void *ptr, size_t size)
100 {
101
102 if (ivsalloc(ptr, config_prof) != 0)
103 return (je_realloc(ptr, size));
104
105 return (realloc(ptr, size));
106 }
107
108 #if (JEMALLOC_ZONE_VERSION >= 5)
109 static void *
zone_memalign(malloc_zone_t * zone,size_t alignment,size_t size)110 zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size)
111 {
112 void *ret = NULL; /* Assignment avoids useless compiler warning. */
113
114 je_posix_memalign(&ret, alignment, size);
115
116 return (ret);
117 }
118 #endif
119
120 #if (JEMALLOC_ZONE_VERSION >= 6)
121 static void
zone_free_definite_size(malloc_zone_t * zone,void * ptr,size_t size)122 zone_free_definite_size(malloc_zone_t *zone, void *ptr, size_t size)
123 {
124
125 if (ivsalloc(ptr, config_prof) != 0) {
126 assert(ivsalloc(ptr, config_prof) == size);
127 je_free(ptr);
128 return;
129 }
130
131 free(ptr);
132 }
133 #endif
134
135 static void *
zone_destroy(malloc_zone_t * zone)136 zone_destroy(malloc_zone_t *zone)
137 {
138
139 /* This function should never be called. */
140 not_reached();
141 return (NULL);
142 }
143
144 static size_t
zone_good_size(malloc_zone_t * zone,size_t size)145 zone_good_size(malloc_zone_t *zone, size_t size)
146 {
147
148 if (size == 0)
149 size = 1;
150 return (s2u(size));
151 }
152
153 static void
zone_force_lock(malloc_zone_t * zone)154 zone_force_lock(malloc_zone_t *zone)
155 {
156
157 if (isthreaded)
158 jemalloc_prefork();
159 }
160
161 static void
zone_force_unlock(malloc_zone_t * zone)162 zone_force_unlock(malloc_zone_t *zone)
163 {
164
165 if (isthreaded)
166 jemalloc_postfork_parent();
167 }
168
JEMALLOC_ATTR(constructor)169 JEMALLOC_ATTR(constructor)
170 void
171 register_zone(void)
172 {
173
174 /*
175 * If something else replaced the system default zone allocator, don't
176 * register jemalloc's.
177 */
178 malloc_zone_t *default_zone = malloc_default_zone();
179 malloc_zone_t *purgeable_zone = NULL;
180 if (!default_zone->zone_name ||
181 strcmp(default_zone->zone_name, "DefaultMallocZone") != 0) {
182 return;
183 }
184
185 zone.size = (void *)zone_size;
186 zone.malloc = (void *)zone_malloc;
187 zone.calloc = (void *)zone_calloc;
188 zone.valloc = (void *)zone_valloc;
189 zone.free = (void *)zone_free;
190 zone.realloc = (void *)zone_realloc;
191 zone.destroy = (void *)zone_destroy;
192 zone.zone_name = "jemalloc_zone";
193 zone.batch_malloc = NULL;
194 zone.batch_free = NULL;
195 zone.introspect = &zone_introspect;
196 zone.version = JEMALLOC_ZONE_VERSION;
197 #if (JEMALLOC_ZONE_VERSION >= 5)
198 zone.memalign = zone_memalign;
199 #endif
200 #if (JEMALLOC_ZONE_VERSION >= 6)
201 zone.free_definite_size = zone_free_definite_size;
202 #endif
203 #if (JEMALLOC_ZONE_VERSION >= 8)
204 zone.pressure_relief = NULL;
205 #endif
206
207 zone_introspect.enumerator = NULL;
208 zone_introspect.good_size = (void *)zone_good_size;
209 zone_introspect.check = NULL;
210 zone_introspect.print = NULL;
211 zone_introspect.log = NULL;
212 zone_introspect.force_lock = (void *)zone_force_lock;
213 zone_introspect.force_unlock = (void *)zone_force_unlock;
214 zone_introspect.statistics = NULL;
215 #if (JEMALLOC_ZONE_VERSION >= 6)
216 zone_introspect.zone_locked = NULL;
217 #endif
218 #if (JEMALLOC_ZONE_VERSION >= 7)
219 zone_introspect.enable_discharge_checking = NULL;
220 zone_introspect.disable_discharge_checking = NULL;
221 zone_introspect.discharge = NULL;
222 #ifdef __BLOCKS__
223 zone_introspect.enumerate_discharged_pointers = NULL;
224 #else
225 zone_introspect.enumerate_unavailable_without_blocks = NULL;
226 #endif
227 #endif
228
229 /*
230 * The default purgeable zone is created lazily by OSX's libc. It uses
231 * the default zone when it is created for "small" allocations
232 * (< 15 KiB), but assumes the default zone is a scalable_zone. This
233 * obviously fails when the default zone is the jemalloc zone, so
234 * malloc_default_purgeable_zone is called beforehand so that the
235 * default purgeable zone is created when the default zone is still
236 * a scalable_zone. As purgeable zones only exist on >= 10.6, we need
237 * to check for the existence of malloc_default_purgeable_zone() at
238 * run time.
239 */
240 if (malloc_default_purgeable_zone != NULL)
241 purgeable_zone = malloc_default_purgeable_zone();
242
243 /* Register the custom zone. At this point it won't be the default. */
244 malloc_zone_register(&zone);
245
246 do {
247 default_zone = malloc_default_zone();
248 /*
249 * Unregister and reregister the default zone. On OSX >= 10.6,
250 * unregistering takes the last registered zone and places it
251 * at the location of the specified zone. Unregistering the
252 * default zone thus makes the last registered one the default.
253 * On OSX < 10.6, unregistering shifts all registered zones.
254 * The first registered zone then becomes the default.
255 */
256 malloc_zone_unregister(default_zone);
257 malloc_zone_register(default_zone);
258 /*
259 * On OSX 10.6, having the default purgeable zone appear before
260 * the default zone makes some things crash because it thinks it
261 * owns the default zone allocated pointers. We thus
262 * unregister/re-register it in order to ensure it's always
263 * after the default zone. On OSX < 10.6, there is no purgeable
264 * zone, so this does nothing. On OSX >= 10.6, unregistering
265 * replaces the purgeable zone with the last registered zone
266 * above, i.e. the default zone. Registering it again then puts
267 * it at the end, obviously after the default zone.
268 */
269 if (purgeable_zone) {
270 malloc_zone_unregister(purgeable_zone);
271 malloc_zone_register(purgeable_zone);
272 }
273 } while (malloc_default_zone() != &zone);
274 }
275