tree: 338108694ce3949e7846628db47449133a70576e [path history] [tgz]
  1. BUILD.gn
  2. OWNERS
  3. README.md
  4. allocator_check.cc
  5. allocator_check.h
  6. allocator_extension.cc
  7. allocator_extension.h
  8. allocator_interception_mac.h
  9. allocator_interception_mac.mm
  10. allocator_interception_mac_unittest.mm
  11. allocator_shim.cc
  12. allocator_shim.h
  13. allocator_shim_default_dispatch_to_glibc.cc
  14. allocator_shim_default_dispatch_to_linker_wrapped_symbols.cc
  15. allocator_shim_default_dispatch_to_mac_zoned_malloc.cc
  16. allocator_shim_default_dispatch_to_mac_zoned_malloc.h
  17. allocator_shim_default_dispatch_to_tcmalloc.cc
  18. allocator_shim_default_dispatch_to_winheap.cc
  19. allocator_shim_internals.h
  20. allocator_shim_override_cpp_symbols.h
  21. allocator_shim_override_glibc_weak_symbols.h
  22. allocator_shim_override_libc_symbols.h
  23. allocator_shim_override_linker_wrapped_symbols.h
  24. allocator_shim_override_mac_symbols.h
  25. allocator_shim_override_ucrt_symbols_win.h
  26. allocator_shim_unittest.cc
  27. debugallocation_shim.cc
  28. malloc_zone_functions_mac.cc
  29. malloc_zone_functions_mac.h
  30. malloc_zone_functions_mac_unittest.cc
  31. partition_allocator/
  32. tcmalloc_unittest.cc
  33. unittest_utils.cc
  34. winheap_stubs_win.cc
  35. winheap_stubs_win.h
  36. winheap_stubs_win_unittest.cc
base/allocator/README.md

This document describes how malloc / new calls are routed in the various Chrome platforms.

Bare in mind that the chromium codebase does not always just use malloc(). Some examples:

  • Large parts of the renderer (Blink) use two home-brewed allocators, PartitionAlloc and BlinkGC (Oilpan).
  • Some subsystems, such as the V8 JavaScript engine, handle memory management autonomously.
  • Various parts of the codebase use abstractions such as SharedMemory or DiscardableMemory which, similarly to the above, have their own page-level memory management.

Background

The allocator target defines at compile-time the platform-specific choice of the allocator and extra-hooks which services calls to malloc/new. The relevant build-time flags involved are use_allocator and use_allocator_shim.

The default choices are as follows:

Windows use_allocator: winheap, the default Windows heap. Additionally, static_library (i.e. non-component) builds have a shim layer wrapping malloc/new, which is controlled by use_allocator_shim. The shim layer provides extra security features, such as preventing large allocations that can hit signed vs. unsigned bugs in third_party code.

Linux Desktop / CrOS use_allocator: tcmalloc, a forked copy of tcmalloc which resides in third_party/tcmalloc/chromium. Setting use_allocator: none causes the build to fall back to the system (Glibc) symbols.

Android use_allocator: none, always use the allocator symbols coming from Android's libc (Bionic). As it is developed as part of the OS, it is considered to be optimized for small devices and more memory-efficient than other choices. The actual implementation backing malloc symbols in Bionic is up to the board config and can vary (typically dlmalloc or jemalloc on most Nexus devices).

Mac/iOS use_allocator: none, we always use the system's allocator implementation.

In addition, when building for asan / msan both the allocator and the shim layer are disabled.

Layering and build deps

The allocator target provides both the source files for tcmalloc (where applicable) and the linker flags required for the Windows shim layer. The base target is (almost) the only one depending on allocator. No other targets should depend on it, with the exception of the very few executables / dynamic libraries that don't depend, either directly or indirectly, on base within the scope of a linker unit.

More importantly, no other place outside of /base should depend on the specific allocator (e.g., directly include third_party/tcmalloc). If such a functional dependency is required that should be achieved using abstractions in base (see /base/allocator/allocator_extension.h and /base/memory/)

Why base depends on allocator? Because it needs to provide services that depend on the actual allocator implementation. In the past base used to pretend to be allocator-agnostic and get the dependencies injected by other layers. This ended up being an inconsistent mess. See the allocator cleanup doc for more context.

Linker unit targets (executables and shared libraries) that depend in some way on base (most of the targets in the codebase) get automatically the correct set of linker flags to pull in tcmalloc or the Windows shim-layer.

Source code

This directory contains just the allocator (i.e. shim) layer that switches between the different underlying memory allocation implementations.

The tcmalloc library originates outside of Chromium and exists in ../../third_party/tcmalloc (currently, the actual location is defined in the allocator.gyp file). The third party sources use a vendor-branch SCM pattern to track Chromium-specific changes independently from upstream changes.

The general intent is to push local changes upstream so that over time we no longer need any forked files.

Unified allocator shim

On most platforms, Chrome overrides the malloc / operator new symbols (and corresponding free / delete and other variants). This is to enforce security checks and lately to enable the memory-infra heap profiler. Historically each platform had its special logic for defining the allocator symbols in different places of the codebase. The unified allocator shim is a project aimed to unify the symbol definition and allocator routing logic in a central place.

Overview of the unified allocator shim The allocator shim consists of three stages:

+-------------------------+    +-----------------------+    +----------------+
|     malloc & friends    | -> |       shim layer      | -> |   Routing to   |
|    symbols definition   |    |     implementation    |    |    allocator   |
+-------------------------+    +-----------------------+    +----------------+
| - libc symbols (malloc, |    | - Security checks     |    | - tcmalloc     |
|   calloc, free, ...)    |    | - Chain of dispatchers|    | - glibc        |
| - C++ symbols (operator |    |   that can intercept  |    | - Android      |
|   new, delete, ...)     |    |   and override        |    |   bionic       |
| - glibc weak symbols    |    |   allocations         |    | - WinHeap      |
|   (__libc_malloc, ...)  |    +-----------------------+    +----------------+
+-------------------------+

1. malloc symbols definition This stage takes care of overriding the symbols malloc, free, operator new, operator delete and friends and routing those calls inside the allocator shim (next point). This is taken care of by the headers in allocator_shim_override_*.

On Linux/CrOS: the allocator symbols are defined as exported global symbols in allocator_shim_override_libc_symbols.h (for malloc, free and friends) and in allocator_shim_override_cpp_symbols.h (for operator new, operator delete and friends). This enables proper interposition of malloc symbols referenced by the main executable and any third party libraries. Symbol resolution on Linux is a breadth first search that starts from the root link unit, that is the executable (see EXECUTABLE AND LINKABLE FORMAT (ELF) - Portable Formats Specification). Additionally, when tcmalloc is the default allocator, some extra glibc symbols are also defined in allocator_shim_override_glibc_weak_symbols.h, for subtle reasons explained in that file. The Linux/CrOS shim was introduced by crrev.com/1675143004.

On Android: load-time symbol interposition (unlike the Linux/CrOS case) is not possible. This is because Android processes are fork()-ed from the Android zygote, which pre-loads libc.so and only later native code gets loaded via dlopen() (symbols from dlopen()-ed libraries get a different resolution scope). In this case, the approach instead of wrapping symbol resolution at link time (i.e. during the build), via the --Wl,-wrap,malloc linker flag. The use of this wrapping flag causes:

  • All references to allocator symbols in the Chrome codebase to be rewritten as references to __wrap_malloc and friends. The __wrap_malloc symbols are defined in the allocator_shim_override_linker_wrapped_symbols.h and route allocator calls inside the shim layer.
  • The reference to the original malloc symbols (which typically is defined by the system's libc.so) are accessible via the special __real_malloc and friends symbols (which will be relocated, at load time, against malloc).

In summary, this approach is transparent to the dynamic loader, which still sees undefined symbol references to malloc symbols. These symbols will be resolved against libc.so as usual. More details in crrev.com/1719433002.

2. Shim layer implementation This stage contains the actual shim implementation. This consists of:

  • A singly linked list of dispatchers (structs with function pointers to malloc-like functions). Dispatchers can be dynamically inserted at runtime (using the InsertAllocatorDispatch API). They can intercept and override allocator calls.
  • The security checks (suicide on malloc-failure via std::new_handler, etc). This happens inside allocator_shim.cc

3. Final allocator routing The final element of the aforementioned dispatcher chain is statically defined at build time and ultimately routes the allocator calls to the actual allocator (as described in the Background section above). This is taken care of by the headers in allocator_shim_default_dispatch_to_* files.

Appendixes

How does the Windows shim layer replace the malloc symbols? The mechanism for hooking LIBCMT in Windows is rather tricky. The core problem is that by default, the Windows library does not declare malloc and free as weak symbols. Because of this, they cannot be overridden. To work around this, we start with the LIBCMT.LIB, and manually remove all allocator related functions from it using the visual studio library tool. Once removed, we can now link against the library and provide custom versions of the allocator related functionality. See the script preb_libc.py in this folder.

Related links