[scudo] Detach the hooks from Scudo's internal implementation

[Chia-hungDuan]

Summary

Move the invocation of hooks from Scudo internal to wrapper_c.cpp and
wrapper_c_bionic.cpp respectively. Therefore, Scudo's core algorithm
doesnt need to worry about the reentrant of hooks and leave the caring
of reentrant to the hook users.

[Chia-hungDuan]

Note, I'll update scudo_hooks_test.cpp later. Now this is more like a RFC for hook users

[fabio-d]

Adding some preliminary (minor) notes, as I haven't tested this CL on Fuchsia yet.

compiler-rt/lib/scudo/standalone/wrappers_c.inc

44

Should this pass Product as the second argument?

138

nit: This can be moved after the if below

161

Should the hook report the rounded-up size to avoid changing the current behavior? (on the other hand I'd be surprised if any existing user depends on it)

178

Similarly to above, the current behavior is to call the allocate hook first, then then deallocate hook.

nit: the two NewPtr != ptr checks can be grouped under only one if

[Chia-hungDuan]

Address review comment.

Still haven't changed the test cases. Will wait the opinion of @chelfi who is
using the hooks and wrote the tests

compiler-rt/lib/scudo/standalone/wrappers_c.inc

161

thanks, the bug from copypasta!

178

Order swapped.

I may prefer single if statement which has less indent.

[chelfi]

Thanks @Chia-hungDuan for looking into this!

Those changes look good to me. Do you also need to change wrappers_cpp.cpp similarly?

[Chia-hungDuan]

Remove scudo_hook_test.cpp and move the hook tests to wrappers_c_test.cpp and wrappers_cpp_test.cpp

[Chia-hungDuan]

In D152188#4399536, @chelfi wrote:

Thanks @Chia-hungDuan for looking into this!

Those changes look good to me. Do you also need to change wrappers_cpp.cpp similarly?

Done.

[hctim]

LGTM

[chelfi]

LGTM, thanks for working on that, @Chia-hungDuan .

I have not tested this patch yet on Fuchsia, but I intend to do so shortly this week.

[Chia-hungDuan]

Rebase

[Chia-hungDuan]

FYI, @chelfi @fabio-d, I'm planning to submit this change by the end of this week.

[cferris]

That sounds like a good plan.

compiler-rt/lib/scudo/standalone/combined.h

if (UNLIKELY(Alignment > MaxAlignment)) {
       reportAlignmentTooBig(Alignment, MaxAlignment);
     }
     if (Alignment < MinAlignment)
       Alignment = MinAlignment;
 
 #ifdef GWP_ASAN_HOOKS
     if (UNLIKELY(GuardedAlloc.shouldSample())) {
       if (void *Ptr = GuardedAlloc.allocate(Size, Alignment)) {
-        if (UNLIKELY(&__scudo_allocate_hook))
-          __scudo_allocate_hook(Ptr, Size);
         Stats.lock();
         Stats.add(StatAllocated, GuardedAllocSlotSize);
         Stats.sub(StatFree, GuardedAllocSlotSize);
         Stats.unlock();
         return Ptr;
       }
     }
 #endif // GWP_ASAN_HOOKS
#endif // GWP_ASAN_HOOKS
     Header.ClassId = ClassId & Chunk::ClassIdMask;
     Header.State = Chunk::State::Allocated;
     Header.OriginOrWasZeroed = Origin & Chunk::OriginMask;
     Header.SizeOrUnusedBytes =
         (ClassId ? Size : SecondaryBlockEnd - (UserPtr + Size)) &
         Chunk::SizeOrUnusedBytesMask;
     Chunk::storeHeader(Cookie, Ptr, &Header);
 
-    if (UNLIKELY(&__scudo_allocate_hook))
-      __scudo_allocate_hook(TaggedPtr, Size);
-
     return TaggedPtr;
   }
 
   NOINLINE void deallocate(void *Ptr, Chunk::Origin Origin, uptr DeleteSize = 0,
                            UNUSED uptr Alignment = MinAlignment) {
     // For a deallocation, we only ensure minimal initialization, meaning thread
     // local data will be left uninitialized for now (when using ELF TLS). The
     // fallback cache will be used instead. This is a workaround for a situation
     // where the only heap operation performed in a thread would be a free past
     // the TLS destructors, ending up in initialized thread specific data never
     // being destroyed properly. Any other heap operation will do a full init.
     initThreadMaybe(/*MinimalInit=*/true);
 
-    if (UNLIKELY(&__scudo_deallocate_hook))
-      __scudo_deallocate_hook(Ptr);
-
     if (UNLIKELY(!Ptr))
       return;
 
 #ifdef GWP_ASAN_HOOKS
     if (UNLIKELY(GuardedAlloc.pointerIsMine(Ptr))) {
       GuardedAlloc.deallocate(Ptr);
       Stats.lock();
       Stats.add(StatFree, GuardedAllocSlotSize);
#endif // GWP_ASAN_HOOKS
 
     // Otherwise we allocate a new one, and deallocate the old one. Some
     // allocators will allocate an even larger chunk (by a fixed factor) to
     // allow for potential further in-place realloc. The gains of such a trick
     // are currently unclear.
     void *NewPtr = allocate(NewSize, Chunk::Origin::Malloc, Alignment);
     if (LIKELY(NewPtr)) {
       memcpy(NewPtr, OldTaggedPtr, Min(NewSize, OldSize));
-      if (UNLIKELY(&__scudo_deallocate_hook))
-        __scudo_deallocate_hook(OldTaggedPtr);
       quarantineOrDeallocateChunk(Options, OldTaggedPtr, &OldHeader, OldSize);
     }
     return NewPtr;
   }
 
   // TODO(kostyak): disable() is currently best-effort. There are some small
   //                windows of time when an allocation could still succeed after
   //                this function finishes. We will revisit that later.

compiler-rt/lib/scudo/standalone/tests/CMakeLists.txt

 set(SCUDO_CXX_UNIT_TEST_SOURCES
   wrappers_cpp_test.cpp
   scudo_unit_test_main.cpp
   )
 
 add_scudo_unittest(ScudoCxxUnitTest
   SOURCES ${SCUDO_CXX_UNIT_TEST_SOURCES}
   ADDITIONAL_RTOBJECTS RTScudoStandaloneCWrappers RTScudoStandaloneCxxWrappers)
-
-set(SCUDO_HOOKS_UNIT_TEST_SOURCES
-  scudo_hooks_test.cpp
-  scudo_unit_test_main.cpp
-  )
-
-add_scudo_unittest(ScudoHooksUnitTest
-  SOURCES ${SCUDO_HOOKS_UNIT_TEST_SOURCES})

compiler-rt/lib/scudo/standalone/tests/scudo_hooks_test.cpp

-//===-- scudo_hooks_test.cpp ------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "tests/scudo_unit_test.h"
-
-#include "allocator_config.h"
-#include "combined.h"
-
-namespace {
-void *LastAllocatedPtr = nullptr;
-size_t LastRequestSize = 0;
-void *LastDeallocatedPtr = nullptr;
-} // namespace
-
-// Scudo defines weak symbols that can be defined by a client binary
-// to register callbacks at key points in the allocation timeline.  In
-// order to enforce those invariants, we provide definitions that
-// update some global state every time they are called, so that tests
-// can inspect their effects.  An unfortunate side effect of this
-// setup is that because those symbols are part of the binary, they
-// can't be selectively enabled; that means that they will get called
-// on unrelated tests in the same compilation unit. To mitigate this
-// issue, we insulate those tests in a separate compilation unit.
-extern "C" {
-__attribute__((visibility("default"))) void __scudo_allocate_hook(void *Ptr,
-                                                                  size_t Size) {
-  LastAllocatedPtr = Ptr;
-  LastRequestSize = Size;
-}
-__attribute__((visibility("default"))) void __scudo_deallocate_hook(void *Ptr) {
-  LastDeallocatedPtr = Ptr;
-}
-}
-
-// Simple check that allocation callbacks, when registered, are called:
-//   1) __scudo_allocate_hook is called when allocating.
-//   2) __scudo_deallocate_hook is called when deallocating.
-//   3) Both hooks are called when reallocating.
-//   4) Neither are called for a no-op reallocation.
-TEST(ScudoHooksTest, AllocateHooks) {
-  scudo::Allocator<scudo::DefaultConfig> Allocator;
-  constexpr scudo::uptr DefaultSize = 16U;
-  constexpr scudo::Chunk::Origin Origin = scudo::Chunk::Origin::Malloc;
-
-  // Simple allocation and deallocation.
-  {
-    LastAllocatedPtr = nullptr;
-    LastRequestSize = 0;
-
-    void *Ptr = Allocator.allocate(DefaultSize, Origin);
-
-    EXPECT_EQ(Ptr, LastAllocatedPtr);
-    EXPECT_EQ(DefaultSize, LastRequestSize);
-
-    LastDeallocatedPtr = nullptr;
-
-    Allocator.deallocate(Ptr, Origin);
-
-    EXPECT_EQ(Ptr, LastDeallocatedPtr);
-  }
-
-  // Simple no-op, same size reallocation.
-  {
-    void *Ptr = Allocator.allocate(DefaultSize, Origin);
-
-    LastAllocatedPtr = nullptr;
-    LastRequestSize = 0;
-    LastDeallocatedPtr = nullptr;
-
-    void *NewPtr = Allocator.reallocate(Ptr, DefaultSize);
-
-    EXPECT_EQ(Ptr, NewPtr);
-    EXPECT_EQ(nullptr, LastAllocatedPtr);
-    EXPECT_EQ(0U, LastRequestSize);
-    EXPECT_EQ(nullptr, LastDeallocatedPtr);
-  }
-
-  // Reallocation in increasing size classes. This ensures that at
-  // least one of the reallocations will be meaningful.
-  {
-    void *Ptr = Allocator.allocate(0, Origin);
-
-    for (scudo::uptr ClassId = 1U;
-         ClassId <= scudo::DefaultConfig::Primary::SizeClassMap::LargestClassId;
-         ++ClassId) {
-      const scudo::uptr Size =
-          scudo::DefaultConfig::Primary::SizeClassMap::getSizeByClassId(
-              ClassId);
-
-      LastAllocatedPtr = nullptr;
-      LastRequestSize = 0;
-      LastDeallocatedPtr = nullptr;
-
-      void *NewPtr = Allocator.reallocate(Ptr, Size);
-
-      if (NewPtr != Ptr) {
-        EXPECT_EQ(NewPtr, LastAllocatedPtr);
-        EXPECT_EQ(Size, LastRequestSize);
-        EXPECT_EQ(Ptr, LastDeallocatedPtr);
-      } else {
-        EXPECT_EQ(nullptr, LastAllocatedPtr);
-        EXPECT_EQ(0U, LastRequestSize);
-        EXPECT_EQ(nullptr, LastDeallocatedPtr);
-      }
-
-      Ptr = NewPtr;
-    }
-  }
-}

compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp

 #define HAVE_VALLOC 1
 #endif // !defined(__LP64__)
 #else
 // All others assumed to support both functions.
 #define HAVE_PVALLOC 1
 #define HAVE_VALLOC 1
 #endif
 
+struct AllocContext {
+  void *Ptr;
+  size_t Size;
+};
+struct DeallocContext {
+  void *Ptr;
+};
+static AllocContext AC;
+static DeallocContext DC;
+
 extern "C" {
 void malloc_enable(void);
 void malloc_disable(void);
 int malloc_iterate(uintptr_t base, size_t size,
                    void (*callback)(uintptr_t base, size_t size, void *arg),
                    void *arg);
 void *valloc(size_t size);
 void *pvalloc(size_t size);
+
+__attribute__((visibility("default"))) void __scudo_allocate_hook(void *Ptr,
+                                                                  size_t Size) {
+  AC.Ptr = Ptr;
+  AC.Size = Size;
+}
+__attribute__((visibility("default"))) void __scudo_deallocate_hook(void *Ptr) {
+  DC.Ptr = Ptr;
+}
 }
 
 // Note that every C allocation function in the test binary will be fulfilled
 // by Scudo (this includes the gtest APIs, etc.), which is a test by itself.
 // But this might also lead to unexpected side-effects, since the allocation and
 // deallocation operations in the TEST functions will coexist with others (see
 // the EXPECT_DEATH comment below).
 
 // We have to use a small quarantine to make sure that our double-free tests
 // trigger. Otherwise EXPECT_DEATH ends up reallocating the chunk that was just
 // freed (this depends on the size obviously) and the following free succeeds.
 
 static const size_t Size = 100U;
 
 TEST(ScudoWrappersCDeathTest, Malloc) {
   void *P = malloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size, malloc_usable_size(P));
   EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % FIRST_32_SECOND_64(8U, 16U), 0U);
+  EXPECT_EQ(P, AC.Ptr);
+  EXPECT_EQ(Size, AC.Size);
 
   // An update to this warning in Clang now triggers in this line, but it's ok
   // because the check is expecting a bad pointer and should fail.
 #if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfree-nonheap-object"
 #endif
   EXPECT_DEATH(
       free(reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(P) | 1U)), "");
 #if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
 #pragma GCC diagnostic pop
 #endif
 
   free(P);
+  EXPECT_EQ(P, DC.Ptr);
   EXPECT_DEATH(free(P), "");
 
   P = malloc(0U);
   EXPECT_NE(P, nullptr);
   free(P);
 
   errno = 0;
   EXPECT_EQ(malloc(SIZE_MAX), nullptr);
   EXPECT_EQ(errno, ENOMEM);
 }
 
 TEST(ScudoWrappersCTest, Calloc) {
   void *P = calloc(1U, Size);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size, malloc_usable_size(P));
+  EXPECT_EQ(P, AC.Ptr);
+  EXPECT_EQ(Size, AC.Size);
   for (size_t I = 0; I < Size; I++)
     EXPECT_EQ((reinterpret_cast<uint8_t *>(P))[I], 0U);
   free(P);
+  EXPECT_EQ(P, DC.Ptr);
 
   P = calloc(1U, 0U);
   EXPECT_NE(P, nullptr);
   free(P);
   P = calloc(0U, 1U);
   EXPECT_NE(P, nullptr);
   free(P);
 
TEST(ScudoWrappersCTest, Memalign) {
   void *P;
   for (size_t I = FIRST_32_SECOND_64(2U, 3U); I <= 18U; I++) {
     const size_t Alignment = 1U << I;
 
     P = memalign(Alignment, Size);
     EXPECT_NE(P, nullptr);
     EXPECT_LE(Size, malloc_usable_size(P));
     EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
+    EXPECT_EQ(P, AC.Ptr);
+    EXPECT_EQ(Size, AC.Size);
     free(P);
+    EXPECT_EQ(P, DC.Ptr);
 
     P = nullptr;
     EXPECT_EQ(posix_memalign(&P, Alignment, Size), 0);
     EXPECT_NE(P, nullptr);
     EXPECT_LE(Size, malloc_usable_size(P));
     EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
+    EXPECT_EQ(P, AC.Ptr);
+    EXPECT_EQ(Size, AC.Size);
     free(P);
+    EXPECT_EQ(P, DC.Ptr);
   }
 
   EXPECT_EQ(memalign(4096U, SIZE_MAX), nullptr);
   EXPECT_EQ(posix_memalign(&P, 15U, Size), EINVAL);
   EXPECT_EQ(posix_memalign(&P, 4096U, SIZE_MAX), ENOMEM);
 
   // Android's memalign accepts non power-of-2 alignments, and 0.
   if (SCUDO_ANDROID) {
     for (size_t Alignment = 0U; Alignment <= 128U; Alignment++) {
       P = memalign(Alignment, 1024U);
       EXPECT_NE(P, nullptr);
+      EXPECT_EQ(P, AC.Ptr);
+      EXPECT_EQ(Size, AC.Size);
       free(P);
+      EXPECT_EQ(P, DC.Ptr);
     }
   }
 }
 
 TEST(ScudoWrappersCTest, AlignedAlloc) {
   const size_t Alignment = 4096U;
   void *P = aligned_alloc(Alignment, Alignment * 4U);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Alignment * 4U, malloc_usable_size(P));
   EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % Alignment, 0U);
+  EXPECT_EQ(P, AC.Ptr);
+  EXPECT_EQ(Alignment * 4U, AC.Size);
   free(P);
+  EXPECT_EQ(P, DC.Ptr);
 
   errno = 0;
   P = aligned_alloc(Alignment, Size);
   EXPECT_EQ(P, nullptr);
   EXPECT_EQ(errno, EINVAL);
 }
 
 TEST(ScudoWrappersCDeathTest, Realloc) {
   // realloc(nullptr, N) is malloc(N)
-  void *P = realloc(nullptr, 0U);
+  void *P = realloc(nullptr, Size);
   EXPECT_NE(P, nullptr);
+  EXPECT_EQ(P, AC.Ptr);
+  EXPECT_EQ(Size, AC.Size);
   free(P);
+  EXPECT_EQ(P, DC.Ptr);
 
   P = malloc(Size);
   EXPECT_NE(P, nullptr);
   // realloc(P, 0U) is free(P) and returns nullptr
   EXPECT_EQ(realloc(P, 0U), nullptr);
+  EXPECT_EQ(P, DC.Ptr);
 
   P = malloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size, malloc_usable_size(P));
   memset(P, 0x42, Size);
 
+  AC.Ptr = reinterpret_cast<void *>(0xdeadbeef);
+  void *OldP = P;
   P = realloc(P, Size * 2U);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size * 2U, malloc_usable_size(P));
   for (size_t I = 0; I < Size; I++)
     EXPECT_EQ(0x42, (reinterpret_cast<uint8_t *>(P))[I]);
+  if (OldP == P) {
+    EXPECT_EQ(AC.Ptr, reinterpret_cast<void *>(0xdeadbeef));
+  } else {
+    EXPECT_EQ(P, AC.Ptr);
+    EXPECT_EQ(Size * 2U, AC.Size);
+    EXPECT_EQ(OldP, DC.Ptr);
+  }
 
+  AC.Ptr = reinterpret_cast<void *>(0xdeadbeef);
+  OldP = P;
   P = realloc(P, Size / 2U);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size / 2U, malloc_usable_size(P));
   for (size_t I = 0; I < Size / 2U; I++)
     EXPECT_EQ(0x42, (reinterpret_cast<uint8_t *>(P))[I]);
+  if (OldP == P) {
+    EXPECT_EQ(AC.Ptr, reinterpret_cast<void *>(0xdeadbeef));
+  } else {
+    EXPECT_EQ(P, AC.Ptr);
+    EXPECT_EQ(Size / 2U, AC.Size);
+  }
   free(P);
 
   EXPECT_DEATH(P = realloc(P, Size), "");
 
   errno = 0;
   EXPECT_EQ(realloc(nullptr, SIZE_MAX), nullptr);
   EXPECT_EQ(errno, ENOMEM);
   P = malloc(Size);

 TEST(ScudoWrappersCTest, OtherAlloc) {
 #if HAVE_PVALLOC
   const size_t PageSize = static_cast<size_t>(sysconf(_SC_PAGESIZE));
 
   void *P = pvalloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0U);
   EXPECT_LE(PageSize, malloc_usable_size(P));
+  EXPECT_EQ(P, AC.Ptr);
+  // Size will be rounded up to PageSize.
+  EXPECT_EQ(PageSize, AC.Size);
   free(P);
+  EXPECT_EQ(P, DC.Ptr);
 
   EXPECT_EQ(pvalloc(SIZE_MAX), nullptr);
 
   P = pvalloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0U);
   free(P);
 #endif

compiler-rt/lib/scudo/standalone/tests/wrappers_cpp_test.cpp

 
 // Android does not support checking for new/delete mismatches.
 #if SCUDO_ANDROID
 #define SKIP_MISMATCH_TESTS 1
 #else
 #define SKIP_MISMATCH_TESTS 0
 #endif
 
+struct AllocContext {
+  void *Ptr;
+  size_t Size;
+};
+struct DeallocContext {
+  void *Ptr;
+};
+static AllocContext AC;
+static DeallocContext DC;
+
 void operator delete(void *, size_t) noexcept;
 void operator delete[](void *, size_t) noexcept;
 
+extern "C" {
+__attribute__((visibility("default"))) void __scudo_allocate_hook(void *Ptr,
+                                                                  size_t Size) {
+  AC.Ptr = Ptr;
+  AC.Size = Size;
+}
+__attribute__((visibility("default"))) void __scudo_deallocate_hook(void *Ptr) {
+  DC.Ptr = Ptr;
+}
+}
 // Note that every Cxx allocation function in the test binary will be fulfilled
 // by Scudo. See the comment in the C counterpart of this file.
 
 template <typename T> static void testCxxNew() {
   T *P = new T;
   EXPECT_NE(P, nullptr);
+  EXPECT_EQ(P, AC.Ptr);
+  EXPECT_EQ(sizeof(T), AC.Size);
   memset(P, 0x42, sizeof(T));
   EXPECT_DEATH(delete[] P, "");
   delete P;
+  EXPECT_EQ(P, DC.Ptr);
   EXPECT_DEATH(delete P, "");
 
   P = new T;
   EXPECT_NE(P, nullptr);
   memset(P, 0x42, sizeof(T));
   operator delete(P, sizeof(T));
+  EXPECT_EQ(P, DC.Ptr);
 
   P = new (std::nothrow) T;
+  EXPECT_EQ(P, AC.Ptr);
+  EXPECT_EQ(sizeof(T), AC.Size);
   EXPECT_NE(P, nullptr);
   memset(P, 0x42, sizeof(T));
   delete P;
+  EXPECT_EQ(P, DC.Ptr);
 
   const size_t N = 16U;
   T *A = new T[N];
   EXPECT_NE(A, nullptr);
+  EXPECT_EQ(A, AC.Ptr);
+  EXPECT_EQ(sizeof(T) * N, AC.Size);
   memset(A, 0x42, sizeof(T) * N);
   EXPECT_DEATH(delete A, "");
   delete[] A;
+  EXPECT_EQ(A, DC.Ptr);
   EXPECT_DEATH(delete[] A, "");
 
   A = new T[N];
   EXPECT_NE(A, nullptr);
   memset(A, 0x42, sizeof(T) * N);
   operator delete[](A, sizeof(T) * N);
+  EXPECT_EQ(A, DC.Ptr);
 
   A = new (std::nothrow) T[N];
+  EXPECT_EQ(A, AC.Ptr);
+  EXPECT_EQ(sizeof(T) * N, AC.Size);
   EXPECT_NE(A, nullptr);
   memset(A, 0x42, sizeof(T) * N);
   delete[] A;
+  EXPECT_EQ(A, DC.Ptr);
 }
 
 class Pixel {
 public:
   enum class Color { Red, Green, Blue };
   int X = 0;
   int Y = 0;
   Color C = Color::Red;

compiler-rt/lib/scudo/standalone/wrappers_c.cpp

 //===-- wrappers_c.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "platform.h"
 
 // Skip this compilation unit if compiled as part of Bionic.
 #if !SCUDO_ANDROID || !_BIONIC
 
 #include "allocator_config.h"
+#include "scudo/interface.h"
 #include "wrappers_c.h"
 #include "wrappers_c_checks.h"
 
 #include <stdint.h>
 #include <stdio.h>
 
 #define SCUDO_PREFIX(name) name
 #define SCUDO_ALLOCATOR Allocator

compiler-rt/lib/scudo/standalone/wrappers_c.inc

 
 // malloc-type functions have to be aligned to std::max_align_t. This is
 // distinct from (1U << SCUDO_MIN_ALIGNMENT_LOG), since C++ new-type functions
 // do not have to abide by the same requirement.
 #ifndef SCUDO_MALLOC_ALIGNMENT
 #define SCUDO_MALLOC_ALIGNMENT FIRST_32_SECOND_64(8U, 16U)
 #endif
 
+static void reportAllocation(void *ptr, size_t size) {
+  if (__scudo_allocate_hook && ptr)
+    __scudo_allocate_hook(ptr, size);
+}
+
+static void reportDeallocation(void *ptr) {
+  if (__scudo_deallocate_hook)
+    __scudo_deallocate_hook(ptr);
+}
+
 extern "C" {
 
 INTERFACE WEAK void *SCUDO_PREFIX(calloc)(size_t nmemb, size_t size) {
   scudo::uptr Product;
   if (UNLIKELY(scudo::checkForCallocOverflow(size, nmemb, &Product))) {
     if (SCUDO_ALLOCATOR.canReturnNull()) {
       errno = ENOMEM;
       return nullptr;
     }
     scudo::reportCallocOverflow(nmemb, size);
   }
-  return scudo::setErrnoOnNull(SCUDO_ALLOCATOR.allocate(
-      Product, scudo::Chunk::Origin::Malloc, SCUDO_MALLOC_ALIGNMENT, true));
+  void *Ptr = SCUDO_ALLOCATOR.allocate(Product, scudo::Chunk::Origin::Malloc,
+                                       SCUDO_MALLOC_ALIGNMENT, true);
+  reportAllocation(Ptr, Product);
+  return scudo::setErrnoOnNull(Ptr);
 }
 
 INTERFACE WEAK void SCUDO_PREFIX(free)(void *ptr) {
+  reportDeallocation(ptr);
   SCUDO_ALLOCATOR.deallocate(ptr, scudo::Chunk::Origin::Malloc);
 }
 
 INTERFACE WEAK struct SCUDO_MALLINFO SCUDO_PREFIX(mallinfo)(void) {
   struct SCUDO_MALLINFO Info = {};
   scudo::StatCounters Stats;
   SCUDO_ALLOCATOR.getStats(Stats);
   // Space allocated in mmapped regions (bytes)
INTERFACE WEAK struct __scudo_mallinfo2 SCUDO_PREFIX(mallinfo2)(void) {
   Info.uordblks = Stats[scudo::StatAllocated];
   // Total free space (bytes)
   Info.fordblks = Info.fsmblks;
   return Info;
 }
 #endif
 
 INTERFACE WEAK void *SCUDO_PREFIX(malloc)(size_t size) {
-  return scudo::setErrnoOnNull(SCUDO_ALLOCATOR.allocate(
-      size, scudo::Chunk::Origin::Malloc, SCUDO_MALLOC_ALIGNMENT));
+  void *Ptr = SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Malloc,
+                                       SCUDO_MALLOC_ALIGNMENT);
+  reportAllocation(Ptr, size);
+  return scudo::setErrnoOnNull(Ptr);
 }
 
 #if SCUDO_ANDROID
 INTERFACE WEAK size_t SCUDO_PREFIX(malloc_usable_size)(const void *ptr) {
 #else
 INTERFACE WEAK size_t SCUDO_PREFIX(malloc_usable_size)(void *ptr) {
 #endif
   return SCUDO_ALLOCATOR.getUsableSize(ptr);
if (SCUDO_ANDROID) {
     if (UNLIKELY(!scudo::isPowerOfTwo(alignment))) {
       if (SCUDO_ALLOCATOR.canReturnNull()) {
         errno = EINVAL;
         return nullptr;
       }
       scudo::reportAlignmentNotPowerOfTwo(alignment);
     }
   }
-  return SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Memalign,
-                                  alignment);
+  void *Ptr =
+      SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Memalign, alignment);
+  reportAllocation(Ptr, size);
+  return Ptr;
 }
 
 INTERFACE WEAK int SCUDO_PREFIX(posix_memalign)(void **memptr, size_t alignment,
                                                 size_t size) {
   if (UNLIKELY(scudo::checkPosixMemalignAlignment(alignment))) {
     if (!SCUDO_ALLOCATOR.canReturnNull())
       scudo::reportInvalidPosixMemalignAlignment(alignment);
     return EINVAL;
   }
   void *Ptr =
       SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Memalign, alignment);
   if (UNLIKELY(!Ptr))
     return ENOMEM;
+  reportAllocation(Ptr, size);
+
   *memptr = Ptr;
   return 0;
 }
 
 INTERFACE WEAK void *SCUDO_PREFIX(pvalloc)(size_t size) {
   const scudo::uptr PageSize = scudo::getPageSizeCached();
   if (UNLIKELY(scudo::checkForPvallocOverflow(size, PageSize))) {
     if (SCUDO_ALLOCATOR.canReturnNull()) {
       errno = ENOMEM;
       return nullptr;
     }
     scudo::reportPvallocOverflow(size);
   }
   // pvalloc(0) should allocate one page.
-  return scudo::setErrnoOnNull(
+  void *Ptr =
       SCUDO_ALLOCATOR.allocate(size ? scudo::roundUp(size, PageSize) : PageSize,
-                               scudo::Chunk::Origin::Memalign, PageSize));
+                               scudo::Chunk::Origin::Memalign, PageSize);
+  reportAllocation(Ptr, scudo::roundUp(size, PageSize));
+
+  return scudo::setErrnoOnNull(Ptr);
 }
 
 INTERFACE WEAK void *SCUDO_PREFIX(realloc)(void *ptr, size_t size) {
-  if (!ptr)
-    return scudo::setErrnoOnNull(SCUDO_ALLOCATOR.allocate(
-        size, scudo::Chunk::Origin::Malloc, SCUDO_MALLOC_ALIGNMENT));
+  if (!ptr) {
+    void *Ptr = SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Malloc,
+                                         SCUDO_MALLOC_ALIGNMENT);
+    reportAllocation(Ptr, size);
+    return scudo::setErrnoOnNull(Ptr);
+  }
   if (size == 0) {
+    reportDeallocation(ptr);
     SCUDO_ALLOCATOR.deallocate(ptr, scudo::Chunk::Origin::Malloc);
     return nullptr;
   }
-  return scudo::setErrnoOnNull(
-      SCUDO_ALLOCATOR.reallocate(ptr, size, SCUDO_MALLOC_ALIGNMENT));
+
+  void *NewPtr = SCUDO_ALLOCATOR.reallocate(ptr, size, SCUDO_MALLOC_ALIGNMENT);
+  if (NewPtr != ptr) {
+    reportAllocation(NewPtr, size);
+    reportDeallocation(ptr);
+  }
+
+  return scudo::setErrnoOnNull(NewPtr);
 }
 
 INTERFACE WEAK void *SCUDO_PREFIX(valloc)(size_t size) {
-  return scudo::setErrnoOnNull(SCUDO_ALLOCATOR.allocate(
-      size, scudo::Chunk::Origin::Memalign, scudo::getPageSizeCached()));
+  void *Ptr = SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Memalign,
+                                       scudo::getPageSizeCached());
+  reportAllocation(Ptr, size);
+
+  return scudo::setErrnoOnNull(Ptr);
 }
 
 INTERFACE WEAK int SCUDO_PREFIX(malloc_iterate)(
     uintptr_t base, size_t size,
     void (*callback)(uintptr_t base, size_t size, void *arg), void *arg) {
   SCUDO_ALLOCATOR.iterateOverChunks(base, size, callback, arg);
   return 0;
 }
INTERFACE WEAK void *SCUDO_PREFIX(aligned_alloc)(size_t alignment,
                                                  size_t size) {
   if (UNLIKELY(scudo::checkAlignedAllocAlignmentAndSize(alignment, size))) {
     if (SCUDO_ALLOCATOR.canReturnNull()) {
       errno = EINVAL;
       return nullptr;
     }
     scudo::reportInvalidAlignedAllocAlignment(alignment, size);
   }
-  return scudo::setErrnoOnNull(
-      SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Malloc, alignment));
+
+  void *Ptr =
+      SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Malloc, alignment);
+  reportAllocation(Ptr, size);
+
+  return scudo::setErrnoOnNull(Ptr);
 }
 
 INTERFACE WEAK int SCUDO_PREFIX(malloc_info)(UNUSED int options, FILE *stream) {
   const scudo::uptr max_size =
       decltype(SCUDO_ALLOCATOR)::PrimaryT::SizeClassMap::MaxSize;
   auto *sizes = static_cast<scudo::uptr *>(
       SCUDO_PREFIX(calloc)(max_size, sizeof(scudo::uptr)));
   auto callback = [](uintptr_t, size_t size, void *arg) {

compiler-rt/lib/scudo/standalone/wrappers_c_bionic.cpp

 //===-- wrappers_c_bionic.cpp -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "platform.h"
 
 // This is only used when compiled as part of Bionic.
 #if SCUDO_ANDROID && _BIONIC
 
 #include "allocator_config.h"
+#include "scudo/interface.h"
 #include "wrappers_c.h"
 #include "wrappers_c_checks.h"
 
 #include <stdint.h>
 #include <stdio.h>
 
 // Regular MallocDispatch definitions.
 #define SCUDO_PREFIX(name) CONCATENATE(scudo_, name)

compiler-rt/lib/scudo/standalone/wrappers_cpp.cpp

 //===-- wrappers_cpp.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "platform.h"
 
 // Skip this compilation unit if compiled as part of Bionic.
 #if !SCUDO_ANDROID || !_BIONIC
 
 #include "allocator_config.h"
+#include "scudo/interface.h"
 #include "wrappers_c.h"
 
 #include <stdint.h>
 
 namespace std {
 struct nothrow_t {};
 enum class align_val_t : size_t {};
 } // namespace std
 
+static void reportAllocation(void *ptr, size_t size) {
+  if (__scudo_allocate_hook && ptr)
+    __scudo_allocate_hook(ptr, size);
+}
+
+static void reportDeallocation(void *ptr) {
+  if (__scudo_deallocate_hook)
+    __scudo_deallocate_hook(ptr);
+}
+
 INTERFACE WEAK void *operator new(size_t size) {
-  return Allocator.allocate(size, scudo::Chunk::Origin::New);
+  void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::New);
+  reportAllocation(Ptr, size);
+  return Ptr;
 }
 INTERFACE WEAK void *operator new[](size_t size) {
-  return Allocator.allocate(size, scudo::Chunk::Origin::NewArray);
+  void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::NewArray);
+  reportAllocation(Ptr, size);
+  return Ptr;
 }
 INTERFACE WEAK void *operator new(size_t size,
                                   std::nothrow_t const &) NOEXCEPT {
-  return Allocator.allocate(size, scudo::Chunk::Origin::New);
+  void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::New);
+  reportAllocation(Ptr, size);
+  return Ptr;
 }
 INTERFACE WEAK void *operator new[](size_t size,
                                     std::nothrow_t const &) NOEXCEPT {
-  return Allocator.allocate(size, scudo::Chunk::Origin::NewArray);
+  void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::NewArray);
+  reportAllocation(Ptr, size);
+  return Ptr;
 }
 INTERFACE WEAK void *operator new(size_t size, std::align_val_t align) {
-  return Allocator.allocate(size, scudo::Chunk::Origin::New,
+  void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::New,
                                  static_cast<scudo::uptr>(align));
+  reportAllocation(Ptr, size);
+  return Ptr;
 }
 INTERFACE WEAK void *operator new[](size_t size, std::align_val_t align) {
-  return Allocator.allocate(size, scudo::Chunk::Origin::NewArray,
+  void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::NewArray,
                                  static_cast<scudo::uptr>(align));
+  reportAllocation(Ptr, size);
+  return Ptr;
 }
 INTERFACE WEAK void *operator new(size_t size, std::align_val_t align,
                                   std::nothrow_t const &) NOEXCEPT {
-  return Allocator.allocate(size, scudo::Chunk::Origin::New,
+  void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::New,
                                  static_cast<scudo::uptr>(align));
+  reportAllocation(Ptr, size);
+  return Ptr;
 }
 INTERFACE WEAK void *operator new[](size_t size, std::align_val_t align,
                                     std::nothrow_t const &) NOEXCEPT {
-  return Allocator.allocate(size, scudo::Chunk::Origin::NewArray,
+  void *Ptr = Allocator.allocate(size, scudo::Chunk::Origin::NewArray,
                                  static_cast<scudo::uptr>(align));
+  reportAllocation(Ptr, size);
+  return Ptr;
 }
 
 INTERFACE WEAK void operator delete(void *ptr) NOEXCEPT {
+  reportDeallocation(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::New);
 }
 INTERFACE WEAK void operator delete[](void *ptr) NOEXCEPT {
+  reportDeallocation(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray);
 }
 INTERFACE WEAK void operator delete(void *ptr,
                                     std::nothrow_t const &) NOEXCEPT {
+  reportDeallocation(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::New);
 }
 INTERFACE WEAK void operator delete[](void *ptr,
                                       std::nothrow_t const &) NOEXCEPT {
+  reportDeallocation(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray);
 }
 INTERFACE WEAK void operator delete(void *ptr, size_t size) NOEXCEPT {
+  reportDeallocation(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::New, size);
 }
 INTERFACE WEAK void operator delete[](void *ptr, size_t size) NOEXCEPT {
+  reportDeallocation(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, size);
 }
 INTERFACE WEAK void operator delete(void *ptr,
                                     std::align_val_t align) NOEXCEPT {
+  reportDeallocation(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::New, 0,
                        static_cast<scudo::uptr>(align));
 }
 INTERFACE WEAK void operator delete[](void *ptr,
                                       std::align_val_t align) NOEXCEPT {
+  reportDeallocation(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, 0,
                        static_cast<scudo::uptr>(align));
 }
 INTERFACE WEAK void operator delete(void *ptr, std::align_val_t align,
                                     std::nothrow_t const &) NOEXCEPT {
+  reportDeallocation(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::New, 0,
                        static_cast<scudo::uptr>(align));
 }
 INTERFACE WEAK void operator delete[](void *ptr, std::align_val_t align,
                                       std::nothrow_t const &) NOEXCEPT {
+  reportDeallocation(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, 0,
                        static_cast<scudo::uptr>(align));
 }
 INTERFACE WEAK void operator delete(void *ptr, size_t size,
                                     std::align_val_t align) NOEXCEPT {
+  reportDeallocation(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::New, size,
                        static_cast<scudo::uptr>(align));
 }
 INTERFACE WEAK void operator delete[](void *ptr, size_t size,
                                       std::align_val_t align) NOEXCEPT {
+  reportDeallocation(ptr);
   Allocator.deallocate(ptr, scudo::Chunk::Origin::NewArray, size,
                        static_cast<scudo::uptr>(align));
 }
 
 #endif // !SCUDO_ANDROID || !_BIONIC