| 1 |
//===-- sanitizer_malloc_mac.inc --------------------------------*- C++ -*-===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
// |
| 9 |
// This file contains Mac-specific malloc interceptors and a custom zone |
| 10 |
// implementation, which together replace the system allocator. |
| 11 |
// |
| 12 |
//===----------------------------------------------------------------------===// |
| 13 |
|
| 14 |
#include "sanitizer_common/sanitizer_platform.h" |
| 15 |
#if !SANITIZER_APPLE |
| 16 |
#error "This file should only be compiled on Darwin." |
| 17 |
#endif |
| 18 |
|
| 19 |
#include <AvailabilityMacros.h> |
| 20 |
#include <CoreFoundation/CFBase.h> |
| 21 |
#include <dlfcn.h> |
| 22 |
#include <malloc/malloc.h> |
| 23 |
#include <sys/mman.h> |
| 24 |
|
| 25 |
#include "interception/interception.h" |
| 26 |
#include "sanitizer_common/sanitizer_allocator_dlsym.h" |
| 27 |
#include "sanitizer_common/sanitizer_mac.h" |
| 28 |
|
| 29 |
// Similar code is used in Google Perftools, |
| 30 |
// https://github.com/gperftools/gperftools. |
| 31 |
|
| 32 |
namespace __sanitizer { |
| 33 |
|
| 34 |
extern malloc_zone_t sanitizer_zone; |
| 35 |
|
| 36 |
struct sanitizer_malloc_introspection_t : public malloc_introspection_t { |
| 37 |
// IMPORTANT: Do not change the order, alignment, or types of these fields to |
| 38 |
// maintain binary compatibility. You should only add fields to this struct. |
| 39 |
|
| 40 |
// Used to track changes to the allocator that will affect |
| 41 |
// zone enumeration. |
| 42 |
u64 allocator_enumeration_version; |
| 43 |
uptr allocator_ptr; |
| 44 |
uptr allocator_size; |
| 45 |
}; |
| 46 |
|
| 47 |
u64 GetMallocZoneAllocatorEnumerationVersion() { |
| 48 |
// This represents the current allocator ABI version. |
| 49 |
// This field should be incremented every time the Allocator |
| 50 |
// ABI changes in a way that breaks allocator enumeration. |
| 51 |
return 0; |
| 52 |
} |
| 53 |
|
| 54 |
} // namespace __sanitizer |
| 55 |
|
| 56 |
INTERCEPTOR(malloc_zone_t *, malloc_create_zone, |
| 57 |
vm_size_t start_size, unsigned zone_flags) { |
| 58 |
COMMON_MALLOC_ENTER(); |
| 59 |
uptr page_size = GetPageSizeCached(); |
| 60 |
uptr allocated_size = RoundUpTo(sizeof(sanitizer_zone), page_size); |
| 61 |
COMMON_MALLOC_MEMALIGN(page_size, allocated_size); |
| 62 |
malloc_zone_t *new_zone = (malloc_zone_t *)p; |
| 63 |
internal_memcpy(new_zone, &sanitizer_zone, sizeof(sanitizer_zone)); |
| 64 |
new_zone->zone_name = NULL; // The name will be changed anyway. |
| 65 |
// Prevent the client app from overwriting the zone contents. |
| 66 |
// Library functions that need to modify the zone will set PROT_WRITE on it. |
| 67 |
// This matches the behavior of malloc_create_zone() on OSX 10.7 and higher. |
| 68 |
mprotect(new_zone, allocated_size, PROT_READ); |
| 69 |
// We're explicitly *NOT* registering the zone. |
| 70 |
return new_zone; |
| 71 |
} |
| 72 |
|
| 73 |
INTERCEPTOR(void, malloc_destroy_zone, malloc_zone_t *zone) { |
| 74 |
COMMON_MALLOC_ENTER(); |
| 75 |
// We don't need to do anything here. We're not registering new zones, so we |
| 76 |
// don't to unregister. Just un-mprotect and free() the zone. |
| 77 |
uptr page_size = GetPageSizeCached(); |
| 78 |
uptr allocated_size = RoundUpTo(sizeof(sanitizer_zone), page_size); |
| 79 |
mprotect(zone, allocated_size, PROT_READ | PROT_WRITE); |
| 80 |
if (zone->zone_name) { |
| 81 |
COMMON_MALLOC_FREE((void *)zone->zone_name); |
| 82 |
} |
| 83 |
COMMON_MALLOC_FREE(zone); |
| 84 |
} |
| 85 |
|
| 86 |
INTERCEPTOR(malloc_zone_t *, malloc_default_zone, void) { |
| 87 |
COMMON_MALLOC_ENTER(); |
| 88 |
return &sanitizer_zone; |
| 89 |
} |
| 90 |
|
| 91 |
INTERCEPTOR(malloc_zone_t *, malloc_zone_from_ptr, const void *ptr) { |
| 92 |
COMMON_MALLOC_ENTER(); |
| 93 |
size_t size = sanitizer_zone.size(&sanitizer_zone, ptr); |
| 94 |
if (size) { // Claimed by sanitizer zone? |
| 95 |
return &sanitizer_zone; |
| 96 |
} |
| 97 |
return REAL(malloc_zone_from_ptr)(ptr); |
| 98 |
} |
| 99 |
|
| 100 |
INTERCEPTOR(malloc_zone_t *, malloc_default_purgeable_zone, void) { |
| 101 |
// FIXME: ASan should support purgeable allocations. |
| 102 |
// https://github.com/google/sanitizers/issues/139 |
| 103 |
COMMON_MALLOC_ENTER(); |
| 104 |
return &sanitizer_zone; |
| 105 |
} |
| 106 |
|
| 107 |
INTERCEPTOR(void, malloc_make_purgeable, void *ptr) { |
| 108 |
// FIXME: ASan should support purgeable allocations. Ignoring them is fine |
| 109 |
// for now. |
| 110 |
COMMON_MALLOC_ENTER(); |
| 111 |
} |
| 112 |
|
| 113 |
INTERCEPTOR(int, malloc_make_nonpurgeable, void *ptr) { |
| 114 |
// FIXME: ASan should support purgeable allocations. Ignoring them is fine |
| 115 |
// for now. |
| 116 |
COMMON_MALLOC_ENTER(); |
| 117 |
// Must return 0 if the contents were not purged since the last call to |
| 118 |
// malloc_make_purgeable(). |
| 119 |
return 0; |
| 120 |
} |
| 121 |
|
| 122 |
INTERCEPTOR(void, malloc_set_zone_name, malloc_zone_t *zone, const char *name) { |
| 123 |
COMMON_MALLOC_ENTER(); |
| 124 |
InternalScopedString new_name; |
| 125 |
if (name && zone->introspect == sanitizer_zone.introspect) { |
| 126 |
new_name.AppendF(COMMON_MALLOC_ZONE_NAME "-%s", name); |
| 127 |
name = new_name.data(); |
| 128 |
} |
| 129 |
|
| 130 |
// Call the system malloc's implementation for both external and our zones, |
| 131 |
// since that appropriately changes VM region protections on the zone. |
| 132 |
REAL(malloc_set_zone_name)(zone, name); |
| 133 |
} |
| 134 |
|
| 135 |
INTERCEPTOR(void *, malloc, size_t size) { |
| 136 |
COMMON_MALLOC_ENTER(); |
| 137 |
COMMON_MALLOC_MALLOC(size); |
| 138 |
return p; |
| 139 |
} |
| 140 |
|
| 141 |
INTERCEPTOR(void, free, void *ptr) { |
| 142 |
COMMON_MALLOC_ENTER(); |
| 143 |
if (!ptr) return; |
| 144 |
COMMON_MALLOC_FREE(ptr); |
| 145 |
} |
| 146 |
|
| 147 |
INTERCEPTOR(void *, realloc, void *ptr, size_t size) { |
| 148 |
COMMON_MALLOC_ENTER(); |
| 149 |
COMMON_MALLOC_REALLOC(ptr, size); |
| 150 |
return p; |
| 151 |
} |
| 152 |
|
| 153 |
INTERCEPTOR(void *, calloc, size_t nmemb, size_t size) { |
| 154 |
COMMON_MALLOC_ENTER(); |
| 155 |
COMMON_MALLOC_CALLOC(nmemb, size); |
| 156 |
return p; |
| 157 |
} |
| 158 |
|
| 159 |
INTERCEPTOR(void *, valloc, size_t size) { |
| 160 |
COMMON_MALLOC_ENTER(); |
| 161 |
COMMON_MALLOC_VALLOC(size); |
| 162 |
return p; |
| 163 |
} |
| 164 |
|
| 165 |
INTERCEPTOR(size_t, malloc_good_size, size_t size) { |
| 166 |
COMMON_MALLOC_ENTER(); |
| 167 |
return sanitizer_zone.introspect->good_size(&sanitizer_zone, size); |
| 168 |
} |
| 169 |
|
| 170 |
INTERCEPTOR(int, posix_memalign, void **memptr, size_t alignment, size_t size) { |
| 171 |
COMMON_MALLOC_ENTER(); |
| 172 |
CHECK(memptr); |
| 173 |
COMMON_MALLOC_POSIX_MEMALIGN(memptr, alignment, size); |
| 174 |
return res; |
| 175 |
} |
| 176 |
|
| 177 |
namespace { |
| 178 |
|
| 179 |
// TODO(glider): the __sanitizer_mz_* functions should be united with the Linux |
| 180 |
// wrappers, as they are basically copied from there. |
| 181 |
extern "C" |
| 182 |
SANITIZER_INTERFACE_ATTRIBUTE |
| 183 |
size_t __sanitizer_mz_size(malloc_zone_t* zone, const void* ptr) { |
| 184 |
COMMON_MALLOC_SIZE(ptr); |
| 185 |
return size; |
| 186 |
} |
| 187 |
|
| 188 |
extern "C" |
| 189 |
SANITIZER_INTERFACE_ATTRIBUTE |
| 190 |
void *__sanitizer_mz_malloc(malloc_zone_t *zone, uptr size) { |
| 191 |
COMMON_MALLOC_ENTER(); |
| 192 |
COMMON_MALLOC_MALLOC(size); |
| 193 |
return p; |
| 194 |
} |
| 195 |
|
| 196 |
struct DlsymAlloc : public DlSymAllocator<DlsymAlloc> { |
| 197 |
static bool UseImpl() { return !COMMON_MALLOC_SANITIZER_INITIALIZED; } |
| 198 |
}; |
| 199 |
|
| 200 |
extern "C" |
| 201 |
SANITIZER_INTERFACE_ATTRIBUTE |
| 202 |
void *__sanitizer_mz_calloc(malloc_zone_t *zone, size_t nmemb, size_t size) { |
| 203 |
if (DlsymAlloc::Use()) |
| 204 |
return DlsymAlloc::Callocate(nmemb, size); |
| 205 |
COMMON_MALLOC_CALLOC(nmemb, size); |
| 206 |
return p; |
| 207 |
} |
| 208 |
|
| 209 |
extern "C" |
| 210 |
SANITIZER_INTERFACE_ATTRIBUTE |
| 211 |
void *__sanitizer_mz_valloc(malloc_zone_t *zone, size_t size) { |
| 212 |
COMMON_MALLOC_ENTER(); |
| 213 |
COMMON_MALLOC_VALLOC(size); |
| 214 |
return p; |
| 215 |
} |
| 216 |
|
| 217 |
// TODO(glider): the allocation callbacks need to be refactored. |
| 218 |
extern "C" |
| 219 |
SANITIZER_INTERFACE_ATTRIBUTE |
| 220 |
void __sanitizer_mz_free(malloc_zone_t *zone, void *ptr) { |
| 221 |
if (!ptr) return; |
| 222 |
if (DlsymAlloc::PointerIsMine(ptr)) |
| 223 |
return DlsymAlloc::Free(ptr); |
| 224 |
COMMON_MALLOC_FREE(ptr); |
| 225 |
} |
| 226 |
|
| 227 |
#define GET_ZONE_FOR_PTR(ptr) \ |
| 228 |
malloc_zone_t *zone_ptr = WRAP(malloc_zone_from_ptr)(ptr); \ |
| 229 |
const char *zone_name = (zone_ptr == 0) ? 0 : zone_ptr->zone_name |
| 230 |
|
| 231 |
extern "C" |
| 232 |
SANITIZER_INTERFACE_ATTRIBUTE |
| 233 |
void *__sanitizer_mz_realloc(malloc_zone_t *zone, void *ptr, size_t new_size) { |
| 234 |
if (!ptr) { |
| 235 |
COMMON_MALLOC_MALLOC(new_size); |
| 236 |
return p; |
| 237 |
} else { |
| 238 |
COMMON_MALLOC_SIZE(ptr); |
| 239 |
if (size) { |
| 240 |
COMMON_MALLOC_REALLOC(ptr, new_size); |
| 241 |
return p; |
| 242 |
} else { |
| 243 |
// We can't recover from reallocating an unknown address, because |
| 244 |
// this would require reading at most |new_size| bytes from |
| 245 |
// potentially unaccessible memory. |
| 246 |
GET_ZONE_FOR_PTR(ptr); |
| 247 |
COMMON_MALLOC_REPORT_UNKNOWN_REALLOC(ptr, zone_ptr, zone_name); |
| 248 |
return nullptr; |
| 249 |
} |
| 250 |
} |
| 251 |
} |
| 252 |
|
| 253 |
extern "C" |
| 254 |
SANITIZER_INTERFACE_ATTRIBUTE |
| 255 |
void __sanitizer_mz_destroy(malloc_zone_t* zone) { |
| 256 |
// A no-op -- we will not be destroyed! |
| 257 |
Report("__sanitizer_mz_destroy() called -- ignoring\n"); |
| 258 |
} |
| 259 |
|
| 260 |
extern "C" |
| 261 |
SANITIZER_INTERFACE_ATTRIBUTE |
| 262 |
void *__sanitizer_mz_memalign(malloc_zone_t *zone, size_t align, size_t size) { |
| 263 |
COMMON_MALLOC_ENTER(); |
| 264 |
COMMON_MALLOC_MEMALIGN(align, size); |
| 265 |
return p; |
| 266 |
} |
| 267 |
|
| 268 |
// This public API exists purely for testing purposes. |
| 269 |
extern "C" |
| 270 |
SANITIZER_INTERFACE_ATTRIBUTE |
| 271 |
malloc_zone_t* __sanitizer_mz_default_zone() { |
| 272 |
return &sanitizer_zone; |
| 273 |
} |
| 274 |
|
| 275 |
// This function is currently unused, and we build with -Werror. |
| 276 |
#if 0 |
| 277 |
void __sanitizer_mz_free_definite_size( |
| 278 |
malloc_zone_t* zone, void *ptr, size_t size) { |
| 279 |
// TODO(glider): check that |size| is valid. |
| 280 |
UNIMPLEMENTED(); |
| 281 |
} |
| 282 |
#endif |
| 283 |
|
| 284 |
#ifndef COMMON_MALLOC_HAS_ZONE_ENUMERATOR |
| 285 |
#error "COMMON_MALLOC_HAS_ZONE_ENUMERATOR must be defined" |
| 286 |
#endif |
| 287 |
static_assert((COMMON_MALLOC_HAS_ZONE_ENUMERATOR) == 0 || |
| 288 |
(COMMON_MALLOC_HAS_ZONE_ENUMERATOR) == 1, |
| 289 |
"COMMON_MALLOC_HAS_ZONE_ENUMERATOR must be 0 or 1"); |
| 290 |
|
| 291 |
#if COMMON_MALLOC_HAS_ZONE_ENUMERATOR |
| 292 |
// Forward declare and expect the implementation to provided by |
| 293 |
// includer. |
| 294 |
kern_return_t mi_enumerator(task_t task, void *, unsigned type_mask, |
| 295 |
vm_address_t zone_address, memory_reader_t reader, |
| 296 |
vm_range_recorder_t recorder); |
| 297 |
#else |
| 298 |
// Provide stub implementation that fails. |
| 299 |
kern_return_t mi_enumerator(task_t task, void *, unsigned type_mask, |
| 300 |
vm_address_t zone_address, memory_reader_t reader, |
| 301 |
vm_range_recorder_t recorder) { |
| 302 |
// Not supported. |
| 303 |
return KERN_FAILURE; |
| 304 |
} |
| 305 |
#endif |
| 306 |
|
| 307 |
#ifndef COMMON_MALLOC_HAS_EXTRA_INTROSPECTION_INIT |
| 308 |
#error "COMMON_MALLOC_HAS_EXTRA_INTROSPECTION_INIT must be defined" |
| 309 |
#endif |
| 310 |
static_assert((COMMON_MALLOC_HAS_EXTRA_INTROSPECTION_INIT) == 0 || |
| 311 |
(COMMON_MALLOC_HAS_EXTRA_INTROSPECTION_INIT) == 1, |
| 312 |
"COMMON_MALLOC_HAS_EXTRA_INTROSPECTION_INIT must be 0 or 1"); |
| 313 |
#if COMMON_MALLOC_HAS_EXTRA_INTROSPECTION_INIT |
| 314 |
// Forward declare and expect the implementation to provided by |
| 315 |
// includer. |
| 316 |
void mi_extra_init( |
| 317 |
sanitizer_malloc_introspection_t *mi); |
| 318 |
#else |
| 319 |
void mi_extra_init( |
| 320 |
sanitizer_malloc_introspection_t *mi) { |
| 321 |
// Just zero initialize the fields. |
| 322 |
mi->allocator_ptr = 0; |
| 323 |
mi->allocator_size = 0; |
| 324 |
} |
| 325 |
#endif |
| 326 |
|
| 327 |
size_t mi_good_size(malloc_zone_t *zone, size_t size) { |
| 328 |
// I think it's always safe to return size, but we maybe could do better. |
| 329 |
return size; |
| 330 |
} |
| 331 |
|
| 332 |
boolean_t mi_check(malloc_zone_t *zone) { |
| 333 |
UNIMPLEMENTED(); |
| 334 |
} |
| 335 |
|
| 336 |
void mi_print(malloc_zone_t *zone, boolean_t verbose) { |
| 337 |
UNIMPLEMENTED(); |
| 338 |
} |
| 339 |
|
| 340 |
void mi_log(malloc_zone_t *zone, void *address) { |
| 341 |
// I don't think we support anything like this |
| 342 |
} |
| 343 |
|
| 344 |
void mi_force_lock(malloc_zone_t *zone) { |
| 345 |
COMMON_MALLOC_FORCE_LOCK(); |
| 346 |
} |
| 347 |
|
| 348 |
void mi_force_unlock(malloc_zone_t *zone) { |
| 349 |
COMMON_MALLOC_FORCE_UNLOCK(); |
| 350 |
} |
| 351 |
|
| 352 |
void mi_statistics(malloc_zone_t *zone, malloc_statistics_t *stats) { |
| 353 |
COMMON_MALLOC_FILL_STATS(zone, stats); |
| 354 |
} |
| 355 |
|
| 356 |
boolean_t mi_zone_locked(malloc_zone_t *zone) { |
| 357 |
// UNIMPLEMENTED(); |
| 358 |
return false; |
| 359 |
} |
| 360 |
|
| 361 |
} // unnamed namespace |
| 362 |
|
| 363 |
namespace COMMON_MALLOC_NAMESPACE { |
| 364 |
|
| 365 |
void InitMallocZoneFields() { |
| 366 |
static sanitizer_malloc_introspection_t sanitizer_zone_introspection; |
| 367 |
// Ok to use internal_memset, these places are not performance-critical. |
| 368 |
internal_memset(&sanitizer_zone_introspection, 0, |
| 369 |
sizeof(sanitizer_zone_introspection)); |
| 370 |
|
| 371 |
sanitizer_zone_introspection.enumerator = &mi_enumerator; |
| 372 |
sanitizer_zone_introspection.good_size = &mi_good_size; |
| 373 |
sanitizer_zone_introspection.check = &mi_check; |
| 374 |
sanitizer_zone_introspection.print = &mi_print; |
| 375 |
sanitizer_zone_introspection.log = &mi_log; |
| 376 |
sanitizer_zone_introspection.force_lock = &mi_force_lock; |
| 377 |
sanitizer_zone_introspection.force_unlock = &mi_force_unlock; |
| 378 |
sanitizer_zone_introspection.statistics = &mi_statistics; |
| 379 |
sanitizer_zone_introspection.zone_locked = &mi_zone_locked; |
| 380 |
|
| 381 |
// Set current allocator enumeration version. |
| 382 |
sanitizer_zone_introspection.allocator_enumeration_version = |
| 383 |
GetMallocZoneAllocatorEnumerationVersion(); |
| 384 |
|
| 385 |
// Perform any sanitizer specific initialization. |
| 386 |
mi_extra_init(&sanitizer_zone_introspection); |
| 387 |
|
| 388 |
internal_memset(&sanitizer_zone, 0, sizeof(malloc_zone_t)); |
| 389 |
|
| 390 |
// Use version 6 for OSX >= 10.6. |
| 391 |
sanitizer_zone.version = 6; |
| 392 |
sanitizer_zone.zone_name = COMMON_MALLOC_ZONE_NAME; |
| 393 |
sanitizer_zone.size = &__sanitizer_mz_size; |
| 394 |
sanitizer_zone.malloc = &__sanitizer_mz_malloc; |
| 395 |
sanitizer_zone.calloc = &__sanitizer_mz_calloc; |
| 396 |
sanitizer_zone.valloc = &__sanitizer_mz_valloc; |
| 397 |
sanitizer_zone.free = &__sanitizer_mz_free; |
| 398 |
sanitizer_zone.realloc = &__sanitizer_mz_realloc; |
| 399 |
sanitizer_zone.destroy = &__sanitizer_mz_destroy; |
| 400 |
sanitizer_zone.batch_malloc = 0; |
| 401 |
sanitizer_zone.batch_free = 0; |
| 402 |
sanitizer_zone.free_definite_size = 0; |
| 403 |
sanitizer_zone.memalign = &__sanitizer_mz_memalign; |
| 404 |
sanitizer_zone.introspect = &sanitizer_zone_introspection; |
| 405 |
} |
| 406 |
|
| 407 |
void ReplaceSystemMalloc() { |
| 408 |
InitMallocZoneFields(); |
| 409 |
|
| 410 |
// Register the zone. |
| 411 |
malloc_zone_register(&sanitizer_zone); |
| 412 |
} |
| 413 |
|
| 414 |
} // namespace COMMON_MALLOC_NAMESPACE |