OLD | NEW |
| (Empty) |
1 // Copyright (c) 2011, Google Inc. | |
2 // All rights reserved. | |
3 // | |
4 // Redistribution and use in source and binary forms, with or without | |
5 // modification, are permitted provided that the following conditions are | |
6 // met: | |
7 // | |
8 // * Redistributions of source code must retain the above copyright | |
9 // notice, this list of conditions and the following disclaimer. | |
10 // * Redistributions in binary form must reproduce the above | |
11 // copyright notice, this list of conditions and the following disclaimer | |
12 // in the documentation and/or other materials provided with the | |
13 // distribution. | |
14 // * Neither the name of Google Inc. nor the names of its | |
15 // contributors may be used to endorse or promote products derived from | |
16 // this software without specific prior written permission. | |
17 // | |
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
29 | |
30 // --- | |
31 // Author: Craig Silverstein <opensource@google.com> | |
32 // | |
33 // Used to override malloc routines on OS X systems. We use the | |
34 // malloc-zone functionality built into OS X to register our malloc | |
35 // routine. | |
36 // | |
37 // 1) We used to use the normal 'override weak libc malloc/etc' | |
38 // technique for OS X. This is not optimal because mach does not | |
39 // support the 'alias' attribute, so we had to have forwarding | |
40 // functions. It also does not work very well with OS X shared | |
41 // libraries (dylibs) -- in general, the shared libs don't use | |
42 // tcmalloc unless run with the DYLD_FORCE_FLAT_NAMESPACE envvar. | |
43 // | |
44 // 2) Another approach would be to use an interposition array: | |
45 // static const interpose_t interposers[] __attribute__((section("__DATA, _
_interpose"))) = { | |
46 // { (void *)tc_malloc, (void *)malloc }, | |
47 // { (void *)tc_free, (void *)free }, | |
48 // }; | |
49 // This requires the user to set the DYLD_INSERT_LIBRARIES envvar, so | |
50 // is not much better. | |
51 // | |
52 // 3) Registering a new malloc zone avoids all these issues: | |
53 // http://www.opensource.apple.com/source/Libc/Libc-583/include/malloc/malloc.h | |
54 // http://www.opensource.apple.com/source/Libc/Libc-583/gen/malloc.c | |
55 // If we make tcmalloc the default malloc zone (undocumented but | |
56 // possible) then all new allocs use it, even those in shared | |
57 // libraries. Allocs done before tcmalloc was installed, or in libs | |
58 // that aren't using tcmalloc for some reason, will correctly go | |
59 // through the malloc-zone interface when free-ing, and will pick up | |
60 // the libc free rather than tcmalloc free. So it should "never" | |
61 // cause a crash (famous last words). | |
62 // | |
63 // 4) The routines one must define for one's own malloc have changed | |
64 // between OS X versions. This requires some hoops on our part, but | |
65 // is only really annoying when it comes to posix_memalign. The right | |
66 // behavior there depends on what OS version tcmalloc was compiled on, | |
67 // but also what OS version the program is running on. For now, we | |
68 // punt and don't implement our own posix_memalign. Apps that really | |
69 // care can use tc_posix_memalign directly. | |
70 | |
71 #ifndef TCMALLOC_LIBC_OVERRIDE_OSX_INL_H_ | |
72 #define TCMALLOC_LIBC_OVERRIDE_OSX_INL_H_ | |
73 | |
74 #include <config.h> | |
75 #ifdef HAVE_FEATURES_H | |
76 #include <features.h> | |
77 #endif | |
78 #include <gperftools/tcmalloc.h> | |
79 | |
80 #if !defined(__APPLE__) | |
81 # error libc_override_glibc-osx.h is for OS X distributions only. | |
82 #endif | |
83 | |
84 #include <AvailabilityMacros.h> | |
85 #include <malloc/malloc.h> | |
86 | |
87 // from AvailabilityMacros.h | |
88 #if defined(MAC_OS_X_VERSION_10_6) && \ | |
89 MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6 | |
90 extern "C" { | |
91 // This function is only available on 10.6 (and later) but the | |
92 // LibSystem headers do not use AvailabilityMacros.h to handle weak | |
93 // importing automatically. This prototype is a copy of the one in | |
94 // <malloc/malloc.h> with the WEAK_IMPORT_ATTRBIUTE added. | |
95 extern malloc_zone_t *malloc_default_purgeable_zone(void) | |
96 WEAK_IMPORT_ATTRIBUTE; | |
97 } | |
98 #endif | |
99 | |
100 // We need to provide wrappers around all the libc functions. | |
101 namespace { | |
102 size_t mz_size(malloc_zone_t* zone, const void* ptr) { | |
103 if (MallocExtension::instance()->GetOwnership(ptr) != MallocExtension::kOwned) | |
104 return 0; // malloc_zone semantics: return 0 if we don't own the memory | |
105 | |
106 // TODO(csilvers): change this method to take a const void*, one day. | |
107 return MallocExtension::instance()->GetAllocatedSize(const_cast<void*>(ptr)); | |
108 } | |
109 | |
110 void* mz_malloc(malloc_zone_t* zone, size_t size) { | |
111 return tc_malloc(size); | |
112 } | |
113 | |
114 void* mz_calloc(malloc_zone_t* zone, size_t num_items, size_t size) { | |
115 return tc_calloc(num_items, size); | |
116 } | |
117 | |
118 void* mz_valloc(malloc_zone_t* zone, size_t size) { | |
119 return tc_valloc(size); | |
120 } | |
121 | |
122 void mz_free(malloc_zone_t* zone, void* ptr) { | |
123 return tc_free(ptr); | |
124 } | |
125 | |
126 void* mz_realloc(malloc_zone_t* zone, void* ptr, size_t size) { | |
127 return tc_realloc(ptr, size); | |
128 } | |
129 | |
130 void* mz_memalign(malloc_zone_t* zone, size_t align, size_t size) { | |
131 return tc_memalign(align, size); | |
132 } | |
133 | |
134 void mz_destroy(malloc_zone_t* zone) { | |
135 // A no-op -- we will not be destroyed! | |
136 } | |
137 | |
138 // malloc_introspection callbacks. I'm not clear on what all of these do. | |
139 kern_return_t mi_enumerator(task_t task, void *, | |
140 unsigned type_mask, vm_address_t zone_address, | |
141 memory_reader_t reader, | |
142 vm_range_recorder_t recorder) { | |
143 // Should enumerate all the pointers we have. Seems like a lot of work. | |
144 return KERN_FAILURE; | |
145 } | |
146 | |
147 size_t mi_good_size(malloc_zone_t *zone, size_t size) { | |
148 // I think it's always safe to return size, but we maybe could do better. | |
149 return size; | |
150 } | |
151 | |
152 boolean_t mi_check(malloc_zone_t *zone) { | |
153 return MallocExtension::instance()->VerifyAllMemory(); | |
154 } | |
155 | |
156 void mi_print(malloc_zone_t *zone, boolean_t verbose) { | |
157 int bufsize = 8192; | |
158 if (verbose) | |
159 bufsize = 102400; // I picked this size arbitrarily | |
160 char* buffer = new char[bufsize]; | |
161 MallocExtension::instance()->GetStats(buffer, bufsize); | |
162 fprintf(stdout, "%s", buffer); | |
163 delete[] buffer; | |
164 } | |
165 | |
166 void mi_log(malloc_zone_t *zone, void *address) { | |
167 // I don't think we support anything like this | |
168 } | |
169 | |
170 void mi_force_lock(malloc_zone_t *zone) { | |
171 // Hopefully unneeded by us! | |
172 } | |
173 | |
174 void mi_force_unlock(malloc_zone_t *zone) { | |
175 // Hopefully unneeded by us! | |
176 } | |
177 | |
178 void mi_statistics(malloc_zone_t *zone, malloc_statistics_t *stats) { | |
179 // TODO(csilvers): figure out how to fill these out | |
180 stats->blocks_in_use = 0; | |
181 stats->size_in_use = 0; | |
182 stats->max_size_in_use = 0; | |
183 stats->size_allocated = 0; | |
184 } | |
185 | |
186 boolean_t mi_zone_locked(malloc_zone_t *zone) { | |
187 return false; // Hopefully unneeded by us! | |
188 } | |
189 | |
190 } // unnamed namespace | |
191 | |
192 // OS X doesn't have pvalloc, cfree, malloc_statc, etc, so we can just | |
193 // define our own. :-) OS X supplies posix_memalign in some versions | |
194 // but not others, either strongly or weakly linked, in a way that's | |
195 // difficult enough to code to correctly, that I just don't try to | |
196 // support either memalign() or posix_memalign(). If you need them | |
197 // and are willing to code to tcmalloc, you can use tc_posix_memalign(). | |
198 extern "C" { | |
199 void cfree(void* p) { tc_cfree(p); } | |
200 void* pvalloc(size_t s) { return tc_pvalloc(s); } | |
201 void malloc_stats(void) { tc_malloc_stats(); } | |
202 int mallopt(int cmd, int v) { return tc_mallopt(cmd, v); } | |
203 // No struct mallinfo on OS X, so don't define mallinfo(). | |
204 // An alias for malloc_size(), which OS X defines. | |
205 size_t malloc_usable_size(void* p) { return tc_malloc_size(p); } | |
206 } // extern "C" | |
207 | |
208 static void ReplaceSystemAlloc() { | |
209 static malloc_introspection_t tcmalloc_introspection; | |
210 memset(&tcmalloc_introspection, 0, sizeof(tcmalloc_introspection)); | |
211 | |
212 tcmalloc_introspection.enumerator = &mi_enumerator; | |
213 tcmalloc_introspection.good_size = &mi_good_size; | |
214 tcmalloc_introspection.check = &mi_check; | |
215 tcmalloc_introspection.print = &mi_print; | |
216 tcmalloc_introspection.log = &mi_log; | |
217 tcmalloc_introspection.force_lock = &mi_force_lock; | |
218 tcmalloc_introspection.force_unlock = &mi_force_unlock; | |
219 | |
220 static malloc_zone_t tcmalloc_zone; | |
221 memset(&tcmalloc_zone, 0, sizeof(malloc_zone_t)); | |
222 | |
223 // Start with a version 4 zone which is used for OS X 10.4 and 10.5. | |
224 tcmalloc_zone.version = 4; | |
225 tcmalloc_zone.zone_name = "tcmalloc"; | |
226 tcmalloc_zone.size = &mz_size; | |
227 tcmalloc_zone.malloc = &mz_malloc; | |
228 tcmalloc_zone.calloc = &mz_calloc; | |
229 tcmalloc_zone.valloc = &mz_valloc; | |
230 tcmalloc_zone.free = &mz_free; | |
231 tcmalloc_zone.realloc = &mz_realloc; | |
232 tcmalloc_zone.destroy = &mz_destroy; | |
233 tcmalloc_zone.batch_malloc = NULL; | |
234 tcmalloc_zone.batch_free = NULL; | |
235 tcmalloc_zone.introspect = &tcmalloc_introspection; | |
236 | |
237 // from AvailabilityMacros.h | |
238 #if defined(MAC_OS_X_VERSION_10_6) && \ | |
239 MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6 | |
240 // Switch to version 6 on OSX 10.6 to support memalign. | |
241 tcmalloc_zone.version = 6; | |
242 tcmalloc_zone.free_definite_size = NULL; | |
243 tcmalloc_zone.memalign = &mz_memalign; | |
244 tcmalloc_introspection.zone_locked = &mi_zone_locked; | |
245 | |
246 // Request the default purgable zone to force its creation. The | |
247 // current default zone is registered with the purgable zone for | |
248 // doing tiny and small allocs. Sadly, it assumes that the default | |
249 // zone is the szone implementation from OS X and will crash if it | |
250 // isn't. By creating the zone now, this will be true and changing | |
251 // the default zone won't cause a problem. This only needs to | |
252 // happen when actually running on OS X 10.6 and higher (note the | |
253 // ifdef above only checks if we were *compiled* with 10.6 or | |
254 // higher; at runtime we have to check if this symbol is defined.) | |
255 if (malloc_default_purgeable_zone) { | |
256 malloc_default_purgeable_zone(); | |
257 } | |
258 #endif | |
259 | |
260 // Register the tcmalloc zone. At this point, it will not be the | |
261 // default zone. | |
262 malloc_zone_register(&tcmalloc_zone); | |
263 | |
264 // Unregister and reregister the default zone. Unregistering swaps | |
265 // the specified zone with the last one registered which for the | |
266 // default zone makes the more recently registered zone the default | |
267 // zone. The default zone is then re-registered to ensure that | |
268 // allocations made from it earlier will be handled correctly. | |
269 // Things are not guaranteed to work that way, but it's how they work now. | |
270 malloc_zone_t *default_zone = malloc_default_zone(); | |
271 malloc_zone_unregister(default_zone); | |
272 malloc_zone_register(default_zone); | |
273 } | |
274 | |
275 #endif // TCMALLOC_LIBC_OVERRIDE_OSX_INL_H_ | |
OLD | NEW |