base: Add support for malloc zones to the allocator shim

base/allocator/allocator_shim.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/allocator/allocator_shim.h"
 
 #include <errno.h>
 
 #include <new>
 
 #include "base/atomicops.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/process/process_metrics.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 
 #if !defined(OS_WIN)
 #include <unistd.h>
 #else
 #include "base/allocator/winheap_stubs_win.h"
 #endif
 
+#if defined(OS_MACOSX)
+#include <malloc/malloc.h>
+#endif
+
 // No calls to malloc / new in this file. They would would cause re-entrancy of
 // the shim, which is hard to deal with. Keep this code as simple as possible
 // and don't use any external C++ object here, not even //base ones. Even if
 // they are safe to use today, in future they might be refactored.
 
 namespace {
 
 using namespace base;
 
 subtle::AtomicWord g_chain_head = reinterpret_cast<subtle::AtomicWord>(
@@ skipping 55 matching lines @@
 
 namespace base {
 namespace allocator {
 
 void SetCallNewHandlerOnMallocFailure(bool value) {
   g_call_new_handler_on_malloc_failure = value;
 }
 
 void* UncheckedAlloc(size_t size) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
-  return chain_head->alloc_function(chain_head, size);
+  return chain_head->alloc_function(chain_head, size, nullptr);
 }
 
 void InsertAllocatorDispatch(AllocatorDispatch* dispatch) {
   // Loop in case of (an unlikely) race on setting the list head.
   size_t kMaxRetries = 7;
   for (size_t i = 0; i < kMaxRetries; ++i) {
     const AllocatorDispatch* chain_head = GetChainHead();
     dispatch->next = chain_head;
 
     // This function guarantees to be thread-safe w.r.t. concurrent
@@ skipping 41 matching lines @@
 //   - If the std::new_handler is NOT set just return nullptr.
 //   - If the std::new_handler is set:
 //     - Assume it will abort() if it fails (very likely the new_handler will
 //       just suicide priting a message).
 //     - Assume it did succeed if it returns, in which case reattempt the alloc.
 
 void* ShimCppNew(size_t size) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
-    ptr = chain_head->alloc_function(chain_head, size);
+    void* context = nullptr;
+#if defined(OS_MACOSX)
+    context = malloc_default_zone();
+#endif
+    ptr = chain_head->alloc_function(chain_head, size, context);
   } while (!ptr && CallNewHandler(size));
   return ptr;
 }
 
 void ShimCppDelete(void* address) {
+  void* context = nullptr;
+#if defined(OS_MACOSX)
+  context = malloc_default_zone();
+#endif
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
-  return chain_head->free_function(chain_head, address);
+  return chain_head->free_function(chain_head, address, context);
 }
 
-void* ShimMalloc(size_t size) {
+void* ShimMalloc(size_t size, void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
-    ptr = chain_head->alloc_function(chain_head, size);
+    ptr = chain_head->alloc_function(chain_head, size, context);
   } while (!ptr && g_call_new_handler_on_malloc_failure &&
            CallNewHandler(size));
   return ptr;
 }
 
-void* ShimCalloc(size_t n, size_t size) {
+void* ShimCalloc(size_t n, size_t size, void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
-    ptr = chain_head->alloc_zero_initialized_function(chain_head, n, size);
+    ptr = chain_head->alloc_zero_initialized_function(chain_head, n, size,
+                                                      context);
   } while (!ptr && g_call_new_handler_on_malloc_failure &&
            CallNewHandler(size));
   return ptr;
 }
 
-void* ShimRealloc(void* address, size_t size) {
+void* ShimRealloc(void* address, size_t size, void* context) {
   // realloc(size == 0) means free() and might return a nullptr. We should
   // not call the std::new_handler in that case, though.
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
-    ptr = chain_head->realloc_function(chain_head, address, size);
+    ptr = chain_head->realloc_function(chain_head, address, size, context);
   } while (!ptr && size && g_call_new_handler_on_malloc_failure &&
            CallNewHandler(size));
   return ptr;
 }
 
-void* ShimMemalign(size_t alignment, size_t size) {
+void* ShimMemalign(size_t alignment, size_t size, void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   void* ptr;
   do {
-    ptr = chain_head->alloc_aligned_function(chain_head, alignment, size);
+    ptr = chain_head->alloc_aligned_function(chain_head, alignment, size,
+                                             context);
   } while (!ptr && g_call_new_handler_on_malloc_failure &&
            CallNewHandler(size));
   return ptr;
 }
 
 int ShimPosixMemalign(void** res, size_t alignment, size_t size) {
   // posix_memalign is supposed to check the arguments. See tc_posix_memalign()
   // in tc_malloc.cc.
   if (((alignment % sizeof(void*)) != 0) ||
       ((alignment & (alignment - 1)) != 0) || (alignment == 0)) {
     return EINVAL;
   }
-  void* ptr = ShimMemalign(alignment, size);
+  void* ptr = ShimMemalign(alignment, size, nullptr);
   *res = ptr;
   return ptr ? 0 : ENOMEM;
 }
 
-void* ShimValloc(size_t size) {
-  return ShimMemalign(GetCachedPageSize(), size);
+void* ShimValloc(size_t size, void* context) {
+  return ShimMemalign(GetCachedPageSize(), size, context);
 }
 
 void* ShimPvalloc(size_t size) {
   // pvalloc(0) should allocate one page, according to its man page.
   if (size == 0) {
     size = GetCachedPageSize();
   } else {
     size = (size + GetCachedPageSize() - 1) & ~(GetCachedPageSize() - 1);
   }
-  return ShimMemalign(GetCachedPageSize(), size);
+  return ShimMemalign(GetCachedPageSize(), size, nullptr);

[Primiano Tucci (use gerrit), 2017/02/20 10:33:05]

add a comment saying that this is nullptr because pvalloc is glibc only and does
not exist on OSX/BSD systems

 }
 
-void ShimFree(void* address) {
+void ShimFree(void* address, void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
-  return chain_head->free_function(chain_head, address);
+  return chain_head->free_function(chain_head, address, context);
 }
 
-size_t ShimGetSizeEstimate(const void* address) {
+size_t ShimGetSizeEstimate(const void* address, void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
-  return chain_head->get_size_estimate_function(chain_head,
-                                                const_cast<void*>(address));
+  return chain_head->get_size_estimate_function(
+      chain_head, const_cast<void*>(address), context);
 }
 
-unsigned ShimBatchMalloc(size_t size, void** results, unsigned num_requested) {
+unsigned ShimBatchMalloc(size_t size,
+                         void** results,
+                         unsigned num_requested,
+                         void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   return chain_head->batch_malloc_function(chain_head, size, results,
-                                           num_requested);
+                                           num_requested, context);
 }
 
-void ShimBatchFree(void** to_be_freed, unsigned num_to_be_freed) {
+void ShimBatchFree(void** to_be_freed,
+                   unsigned num_to_be_freed,
+                   void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
   return chain_head->batch_free_function(chain_head, to_be_freed,
-                                         num_to_be_freed);
+                                         num_to_be_freed, context);
 }
 
-void ShimFreeDefiniteSize(void* ptr, size_t size) {
+void ShimFreeDefiniteSize(void* ptr, size_t size, void* context) {
   const allocator::AllocatorDispatch* const chain_head = GetChainHead();
-  return chain_head->free_definite_size_function(chain_head, ptr, size);
+  return chain_head->free_definite_size_function(chain_head, ptr, size,
+                                                 context);
 }
 
 }  // extern "C"
 
 #if !defined(OS_WIN) && !defined(OS_MACOSX)
 // Cpp symbols (new / delete) should always be routed through the shim layer
 // except on Windows and macOS where the malloc intercept is deep enough that it
 // also catches the cpp calls.
 #include "base/allocator/allocator_shim_override_cpp_symbols.h"
 #endif
@@ skipping 38 matching lines @@
 // Cross-checks.
 
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 #error The allocator shim should not be compiled when building for memory tools.
 #endif
 
 #if (defined(__GNUC__) && defined(__EXCEPTIONS)) || \
     (defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS)
 #error This code cannot be used when exceptions are turned on.
 #endif