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 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 * 63 zone_malloc(malloc_zone_t *zone, size_t size) 64 { 65 66 return (je_malloc(size)); 67 } 68 69 static void * 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 * 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 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 * 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 * 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 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 * 136 zone_destroy(malloc_zone_t *zone) 137 { 138 139 /* This function should never be called. */ 140 assert(false); 141 return (NULL); 142 } 143 144 static size_t 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 154 zone_force_lock(malloc_zone_t *zone) 155 { 156 157 if (isthreaded) 158 jemalloc_prefork(); 159 } 160 161 static void 162 zone_force_unlock(malloc_zone_t *zone) 163 { 164 165 if (isthreaded) 166 jemalloc_postfork_parent(); 167 } 168 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 if (!default_zone->zone_name || 180 strcmp(default_zone->zone_name, "DefaultMallocZone") != 0) { 181 return; 182 } 183 184 zone.size = (void *)zone_size; 185 zone.malloc = (void *)zone_malloc; 186 zone.calloc = (void *)zone_calloc; 187 zone.valloc = (void *)zone_valloc; 188 zone.free = (void *)zone_free; 189 zone.realloc = (void *)zone_realloc; 190 zone.destroy = (void *)zone_destroy; 191 zone.zone_name = "jemalloc_zone"; 192 zone.batch_malloc = NULL; 193 zone.batch_free = NULL; 194 zone.introspect = &zone_introspect; 195 zone.version = JEMALLOC_ZONE_VERSION; 196 #if (JEMALLOC_ZONE_VERSION >= 5) 197 zone.memalign = zone_memalign; 198 #endif 199 #if (JEMALLOC_ZONE_VERSION >= 6) 200 zone.free_definite_size = zone_free_definite_size; 201 #endif 202 #if (JEMALLOC_ZONE_VERSION >= 8) 203 zone.pressure_relief = NULL; 204 #endif 205 206 zone_introspect.enumerator = NULL; 207 zone_introspect.good_size = (void *)zone_good_size; 208 zone_introspect.check = NULL; 209 zone_introspect.print = NULL; 210 zone_introspect.log = NULL; 211 zone_introspect.force_lock = (void *)zone_force_lock; 212 zone_introspect.force_unlock = (void *)zone_force_unlock; 213 zone_introspect.statistics = NULL; 214 #if (JEMALLOC_ZONE_VERSION >= 6) 215 zone_introspect.zone_locked = NULL; 216 #endif 217 #if (JEMALLOC_ZONE_VERSION >= 7) 218 zone_introspect.enable_discharge_checking = NULL; 219 zone_introspect.disable_discharge_checking = NULL; 220 zone_introspect.discharge = NULL; 221 #ifdef __BLOCKS__ 222 zone_introspect.enumerate_discharged_pointers = NULL; 223 #else 224 zone_introspect.enumerate_unavailable_without_blocks = NULL; 225 #endif 226 #endif 227 228 /* 229 * The default purgeable zone is created lazily by OSX's libc. It uses 230 * the default zone when it is created for "small" allocations 231 * (< 15 KiB), but assumes the default zone is a scalable_zone. This 232 * obviously fails when the default zone is the jemalloc zone, so 233 * malloc_default_purgeable_zone is called beforehand so that the 234 * default purgeable zone is created when the default zone is still 235 * a scalable_zone. As purgeable zones only exist on >= 10.6, we need 236 * to check for the existence of malloc_default_purgeable_zone() at 237 * run time. 238 */ 239 if (malloc_default_purgeable_zone != NULL) 240 malloc_default_purgeable_zone(); 241 242 /* Register the custom zone. At this point it won't be the default. */ 243 malloc_zone_register(&zone); 244 245 /* 246 * Unregister and reregister the default zone. On OSX >= 10.6, 247 * unregistering takes the last registered zone and places it at the 248 * location of the specified zone. Unregistering the default zone thus 249 * makes the last registered one the default. On OSX < 10.6, 250 * unregistering shifts all registered zones. The first registered zone 251 * then becomes the default. 252 */ 253 do { 254 default_zone = malloc_default_zone(); 255 malloc_zone_unregister(default_zone); 256 malloc_zone_register(default_zone); 257 } while (malloc_default_zone() != &zone); 258 } 259