Merge remote-tracking branch 'origin/main' into rust_libc_api_support

Author: wpbrown

Diff for: .github/workflows/main.yml

@@ -1,5 +1,11 @@
 name: snmalloc CI
 
+# The following should ensure that the workflow only runs a single set of actions
+# for each PR. But it will not apply this to pushes to the main branch.
+concurrency:
+  group: ${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
 # Controls when the workflow will run
 on:
   # Triggers the workflow on push or pull request events but only for the master branch
@@ -16,7 +22,7 @@ jobs:
     strategy:
       matrix:
         # Build each combination of OS and release/debug variants
-        os: [ "ubuntu-latest", "ubuntu-20.04" ]
+        os: [ "ubuntu-24.04", "ubuntu-22.04", "ubuntu-20.04", "ubuntu-24.04-arm" ]
         build-type: [ "Release", "Debug" ]
         # Extra cmake flags.  GitHub Actions matrix overloads `include` to mean
         # 'add extra things to a job' and 'add jobs'.  You can add extra things
@@ -33,30 +39,34 @@ jobs:
         extra-cmake-flags: [ "" ]
         # Modify the complete matrix
         include:
+          - os: "ubuntu-22.04"
+            variant: "C++17"
+            build-type: "Debug"
+            extra-cmake-flags: "-DSNMALLOC_USE_CXX17=ON"
           - os: "ubuntu-20.04"
             variant: "C++17"
             build-type: "Debug"
             extra-cmake-flags: "-DSNMALLOC_USE_CXX17=ON"
           # Add the self-host build, using the bounds-checked memcpy in
           # maximally paranoid mode (checking loads and stores)
-          - os: "ubuntu-latest"
+          - os: "ubuntu-24.04"
             build-type: Debug
             self-host: true
             extra-cmake-flags: "-DSNMALLOC_MEMCPY_BOUNDS=ON -DSNMALLOC_CHECK_LOADS=ON"
           # Extra build to check using pthread library for destructing local state.
-          - os: "ubuntu-latest"
+          - os: "ubuntu-24.04"
             variant: "with pthread destructors"
             build-type: Debug
             self-host: true
             extra-cmake-flags: "-DSNMALLOC_USE_PTHREAD_DESTRUCTORS=On"
           # Extra build to check using individual mitigations works.
-          - os: "ubuntu-latest"
+          - os: "ubuntu-24.04"
             variant: "individual mitigations"
             build-type: Release
             self-host: true
             extra-cmake-flags: "-DSNMALLOC_BENCHMARK_INDIVIDUAL_MITIGATIONS=On -DSNMALLOC_BUILD_TESTING=Off"
           # Check that we can build specifically with libstdc++
-          - os: "ubuntu-latest"
+          - os: "ubuntu-24.04"
             variant: "libstdc++ (Build only)"
             build-type: Release
             extra-cmake-flags: "-DCMAKE_CXX_COMPILER=clang++ -DCMAKE_CXX_FLAGS=-stdlib=libstdc++"
@@ -80,7 +90,7 @@ jobs:
       # Don't abort runners if a single one fails
       fail-fast: false
     runs-on: ${{ matrix.os }}
-    name: ${{ matrix.os }} ${{ matrix.build-type }} ${{ matrix.variant }}
+    name: Ubuntu - ${{ matrix.os }} ${{ matrix.build-type }} ${{ matrix.variant }}
     steps:
     - uses: actions/checkout@v4
     - name: Install build dependencies
@@ -116,7 +126,7 @@ jobs:
         extra-cmake-flags: [ "", "-DSNMALLOC_USE_CXX17=ON" ]
       fail-fast: false
     runs-on: ${{ matrix.os }}
-    name: ${{ matrix.os }} ${{ matrix.build-type }} ${{ matrix.extra-cmake-flags }}
+    name: Mac OS ${{ matrix.os }} ${{ matrix.build-type }} ${{ matrix.extra-cmake-flags }}
     steps:
     - uses: actions/checkout@v4
     - name: Install build dependencies
@@ -255,21 +265,20 @@ jobs:
       matrix:
         # Build just release variant as Debug is too slow.
         build-type: [ Release ]
-        os: ["ubuntu-latest", "ubuntu-20.04"]
+        os: ["ubuntu-24.04", "ubuntu-22.04"]
         include:
-          - os: "ubuntu-latest"
+          - os: "ubuntu-22.04"
             variant: "libc++ (TSan + UBSan)"
             dependencies: "sudo apt install ninja-build libc++-dev"
             extra-cmake-flags: "-DCMAKE_CXX_COMPILER=clang++ -DCMAKE_CXX_FLAGS=-stdlib=\"libc++ -g\" -DSNMALLOC_SANITIZER=undefined,thread"
-          # Also test specifically with clang-10 (on ubuntu-20.04)
-          - os: "ubuntu-20.04"
-            variant: "clang-10 libc++ (TSan + UBSan)"
+          - os: "ubuntu-24.04"
+            variant: "libc++ (TSan + UBSan)"
             dependencies: "sudo apt install ninja-build libc++-dev"
-            extra-cmake-flags: "-DCMAKE_CXX_COMPILER=clang++-10 -DCMAKE_CXX_FLAGS=-stdlib=\"libc++ -g\" -DSNMALLOC_SANITIZER=undefined,thread"
+            extra-cmake-flags: "-DCMAKE_CXX_COMPILER=clang++ -DCMAKE_CXX_FLAGS=-stdlib=\"libc++ -g\" -DSNMALLOC_SANITIZER=undefined,thread"
       # Don't abort runners if a single one fails
       fail-fast: false
     runs-on: ${{ matrix.os }}
-    name: ${{ matrix.os }} ${{ matrix.build-type }} ${{ matrix.variant }}
+    name: Sanitizer - ${{ matrix.os }} ${{ matrix.build-type }} ${{ matrix.variant }}
     steps:
     - uses: actions/checkout@v4
     - name: Install build dependencies
@@ -294,13 +303,13 @@ jobs:
             triple: arm-linux-gnueabihf
             rtld: ld-linux-armhf.so.3
             ld-flavour: lld
-            host-os: ubuntu-latest
+            host-os: ubuntu-24.04
           - name: arm64
             system-processor: aarch64
             triple: aarch64-linux-gnu
             rtld: ld-linux-aarch64.so.1
             ld-flavour: lld
-            host-os: ubuntu-latest
+            host-os: ubuntu-24.04
           - name: ppc64el
             system-processor: powerpc64le
             triple: powerpc64le-linux-gnu
@@ -315,11 +324,11 @@ jobs:
             extra-packages: binutils-riscv64-linux-gnu
             ld-flavour: bfd
             ld: /usr/bin/riscv64-linux-gnu-ld.bfd
-            host-os: ubuntu-latest
+            host-os: ubuntu-24.04
       # Don't abort runners if a single one fails
       fail-fast: false
     runs-on: ${{matrix.arch.host-os}}
-    name: ${{matrix.build-type}} cross-build for ${{ matrix.arch.triple }}
+    name: Crossbuild - ${{matrix.build-type}} cross-build for ${{ matrix.arch.triple }}
     steps:
     - uses: actions/checkout@v4
     - name: "Install cross-compile toolchain and QEMU (ubuntu-20.04)"
@@ -332,8 +341,8 @@ jobs:
         sudo apt update
         sudo apt install libstdc++-9-dev-${{ matrix.arch.name }}-cross qemu-user ninja-build clang-13 lld-13
         sudo apt install ${{matrix.arch.extra-packages}}
-    - name: "Install cross-compile toolchain and QEMU (ubuntu-latest)"
-      if: matrix.arch.host-os == 'ubuntu-latest'
+    - name: "Install cross-compile toolchain and QEMU (ubuntu-24.04)"
+      if: matrix.arch.host-os == 'ubuntu-24.04'
       run: |
         sudo apt update
         sudo apt install libstdc++-12-dev-${{ matrix.arch.name }}-cross qemu-user ninja-build
@@ -350,7 +359,7 @@ jobs:
         chmod +x ppc64.sh
     - name: Configure
       env:
-        SNMALLOC_CI_CLANG_VERSION: ${{ (matrix.arch.host-os == 'ubuntu-latest') && 16 || 13 }}
+        SNMALLOC_CI_CLANG_VERSION: ${{ (matrix.arch.host-os == 'ubuntu-24.04') && 16 || 13 }}
         RTLD_NAME: ${{ matrix.arch.rtld }}
         ARCH: ${{ matrix.arch.system-processor }}
         TRIPLE: ${{ matrix.arch.triple}}
@@ -384,7 +393,7 @@ jobs:
     strategy:
       matrix:
         # Build each combination of OS and release/debug variants
-        os: [ windows-2019 ]
+        os: [ windows-2019, windows-2022, windows-2025 ]
         build-type: [ Release, Debug ]
         arch: [ Win32, x64 ]
         toolchain: [ "", "-T ClangCL" ]
@@ -439,7 +448,7 @@ jobs:
       # Don't abort runners if a single one fails
       fail-fast: false
     runs-on: ${{ matrix.os }}
-    name: ${{ matrix.os }} ${{ matrix.arch }} ${{ matrix.build-type }} ${{ matrix.toolchain }} ${{ matrix.variant }}
+    name: Windows - ${{ matrix.os }} ${{ matrix.arch }} ${{ matrix.build-type }} ${{ matrix.toolchain }} ${{ matrix.variant }}
     steps:
     - uses: actions/checkout@v4
     - name: Configure CMake
@@ -459,6 +468,7 @@ jobs:
   # Job to run clang-format and report errors
   format:
     runs-on: ubuntu-22.04
+    name: Format check
     # We don't need to do the build for this job, but we need to configure it to get the clang-format target
     steps:
     - uses: actions/checkout@v4
@@ -484,6 +494,7 @@ jobs:
         fi
 
   fuzzing:
+    name: Fuzzing
     runs-on: ubuntu-24.04
     steps:
     - uses: actions/checkout@v4
@@ -495,7 +506,6 @@ jobs:
       run: ${{github.workspace}}/build/fuzzing/snmalloc-fuzzer
 
   self-vendored:
-    name: Self Vendored STL Functionality
     strategy:
       fail-fast: false
       matrix:
@@ -513,6 +523,7 @@ jobs:
           cxx: clang++
           cc: clang 
     runs-on: ${{ matrix.os }}
+    name: Self Vendored STL - ${{ matrix.os }} ${{ matrix.cxx }}
     steps:
     - uses: actions/checkout@v4
     - name: Prepare Windows
@@ -542,12 +553,57 @@ jobs:
       run: |
         cd ${{github.workspace}}/build
         ctest --parallel
-      
+
+  gwp-asan:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.04, ubuntu-24.04-arm]
+        profile: [RelWithDebInfo, Debug]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install Ninja
+      run: |
+        sudo apt-get install -y ninja-build
+    - name: Install Compiler-RT
+      shell: bash
+      run: |
+        cd ..
+        git clone https://github.com/llvm/llvm-project --depth=1 -b llvmorg-19.1.7
+        mkdir compiler-rt
+        cmake -G Ninja \
+              -S llvm-project/runtimes \
+              -B llvm-project/build \
+              -DCMAKE_BUILD_TYPE=${{ matrix.profile }}\
+              -DLLVM_ENABLE_RUNTIMES=compiler-rt \
+              -DCMAKE_CXX_COMPILER=clang++-18 \
+              -DCMAKE_C_COMPILER=clang-18 \
+              -DCMAKE_INSTALL_PREFIX=$(realpath compiler-rt)
+        cmake --build llvm-project/build --parallel
+        cmake --build llvm-project/build --target=install
+    - name: Configure SnMalloc
+      run: >
+        cmake -GNinja
+        -B${{github.workspace}}/build
+        -DCMAKE_BUILD_TYPE=${{ matrix.profile }}
+        -DCMAKE_CXX_COMPILER=clang++-18
+        -DCMAKE_C_COMPILER=clang-18
+        -DSNMALLOC_ENABLE_GWP_ASAN_INTEGRATION=On
+        -DSNMALLOC_GWP_ASAN_INCLUDE_PATH=${{github.workspace}}/../llvm-project/compiler-rt/lib
+        -DSNMALLOC_GWP_ASAN_LIBRARY_PATH=${{github.workspace}}/../compiler-rt/lib/linux
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --parallel
+    - name: Test
+      run: |
+        cd ${{github.workspace}}/build
+        ctest --parallel --output-on-failure
+
   all-checks:
     # Currently FreeBSD and NetBSD CI are not working, so we do not require them to pass.
     # Add fuzzing back when the memove issue is fixed.
     needs: [ubuntu, macos, freebsd, netbsd, sanitizer, qemu-crossbuild, windows, format]
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
     - name: Dummy step
       run: true

Diff for: CMakeLists.txt

@@ -37,6 +37,12 @@ cmake_dependent_option(SNMALLOC_STATIC_LIBRARY "Build static libraries" ON "NOT
 cmake_dependent_option(SNMALLOC_CHECK_LOADS "Perform bounds checks on the source argument to memcpy with heap objects" OFF "NOT SNMALLOC_HEADER_ONLY_LIBRARY" OFF)
 cmake_dependent_option(SNMALLOC_OPTIMISE_FOR_CURRENT_MACHINE "Compile for current machine architecture" Off "NOT SNMALLOC_HEADER_ONLY_LIBRARY" OFF)
 cmake_dependent_option(SNMALLOC_PAGEID "Set an id to memory regions" OFF "NOT SNMALLOC_PAGEID" OFF)
+
+# GwpAsan secondary allocator
+option(SNMALLOC_ENABLE_GWP_ASAN_INTEGRATION "Enable GwpAsan as a secondary allocator" OFF)
+set(SNMALLOC_GWP_ASAN_INCLUDE_PATH "" CACHE PATH "GwpAsan header directory")
+set(SNMALLOC_GWP_ASAN_LIBRARY_PATH "" CACHE PATH "GwpAsan library directory")
+
 if (NOT SNMALLOC_HEADER_ONLY_LIBRARY)
   # Pick a sensible default for the thread cleanup mechanism
   if (${CMAKE_SYSTEM_NAME} STREQUAL FreeBSD)
@@ -115,6 +121,19 @@ int main()
  SNMALLOC_LINKER_SUPPORT_NOSTDLIBXX)
 set(CMAKE_REQUIRED_LINK_OPTIONS "")
 
+# Detect if pthread_atfork works
+CHECK_CXX_SOURCE_COMPILES("
+#include <pthread.h>
+void prepare() {}
+void parent() {}
+void child() {}
+int main() {
+  pthread_atfork(prepare, parent, child);
+  return 0;
+}
+" SNMALLOC_PTHREAD_ATFORK_WORKS)
+
+
 if (NOT MSVC AND NOT (SNMALLOC_CLEANUP STREQUAL CXX11_DESTRUCTORS))
   # If the target compiler doesn't support -nostdlib++ then we must enable C at
   # the global scope for the fallbacks to work.
@@ -242,6 +261,20 @@ if(SNMALLOC_USE_SELF_VENDORED_STL)
   target_compile_definitions(snmalloc INTERFACE SNMALLOC_USE_SELF_VENDORED_STL)
 endif()
 
+if (SNMALLOC_ENABLE_GWP_ASAN_INTEGRATION)
+  if (NOT EXISTS ${SNMALLOC_GWP_ASAN_INCLUDE_PATH})
+    message(FATAL_ERROR "GwpAsan cannot be enabled without setting SNMALLOC_GWP_ASAN_INCLUDE_PATH")
+  endif()
+  if (NOT EXISTS ${SNMALLOC_GWP_ASAN_LIBRARY_PATH})
+    message(FATAL_ERROR "GwpAsan cannot be enabled without setting SNMALLOC_GWP_ASAN_LIBRARY_PATH")
+  endif()
+  message(STATUS "GwpAsan is enabled: ${SNMALLOC_GWP_ASAN_LIBRARY_PATH}/libclang_rt.gwp_asan-${CMAKE_SYSTEM_PROCESSOR}.a")
+  target_include_directories(snmalloc INTERFACE ${SNMALLOC_GWP_ASAN_INCLUDE_PATH})
+  target_link_directories(snmalloc INTERFACE ${SNMALLOC_GWP_ASAN_LIBRARY_PATH})
+  target_compile_definitions(snmalloc INTERFACE -DSNMALLOC_ENABLE_GWP_ASAN_INTEGRATION)
+  target_link_libraries(snmalloc INTERFACE clang_rt.gwp_asan-${CMAKE_SYSTEM_PROCESSOR})
+endif()
+
 # https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus
 if(MSVC)
   target_compile_options(snmalloc INTERFACE "/Zc:__cplusplus")
@@ -301,6 +334,7 @@ add_as_define(SNMALLOC_QEMU_WORKAROUND)
 add_as_define(SNMALLOC_TRACING)
 add_as_define(SNMALLOC_CI_BUILD)
 add_as_define(SNMALLOC_PLATFORM_HAS_GETENTROPY)
+add_as_define(SNMALLOC_PTHREAD_ATFORK_WORKS)
 add_as_define(SNMALLOC_HAS_LINUX_RANDOM_H)
 add_as_define(SNMALLOC_HAS_LINUX_FUTEX_H)
 if (SNMALLOC_NO_REALLOCARRAY)
@@ -559,22 +593,9 @@ endif()
   endif()
 
   if (SNMALLOC_BUILD_TESTING)
-    if (WIN32
-    OR (CMAKE_SYSTEM_NAME STREQUAL NetBSD)
-    OR (CMAKE_SYSTEM_NAME STREQUAL OpenBSD)
-    OR (CMAKE_SYSTEM_NAME STREQUAL SunOS))
-    # Windows does not support aligned allocation well enough
-    # for pass through.
-    # NetBSD, OpenBSD and DragonFlyBSD do not support malloc*size calls.
-      set(FLAVOURS fast;check)
-    else()
-      set(FLAVOURS fast;check;malloc)
-    endif()
+    set(FLAVOURS fast;check)
 
     foreach(FLAVOUR ${FLAVOURS})
-      if (${FLAVOUR} STREQUAL "malloc")
-        set(DEFINES SNMALLOC_PASS_THROUGH)
-      endif()
       if (${FLAVOUR} STREQUAL "check")
         set(DEFINES SNMALLOC_CHECK_CLIENT)
       endif()

Diff for: docs/AddressSpace.md

@@ -16,10 +16,10 @@ For simplicity, we assume that
 Since this is the first allocation, all the internal caches will be empty, and so we will hit all the slow paths.
 For simplicity, we gloss over much of the "lazy initialization" that would actually be implied by a first allocation.
 
-1. The `LocalAlloc::small_alloc` finds that it cannot satisfy the request because its `LocalCache` lacks a free list for this size class.
-   The request is delegated, unchanged, to `CoreAllocator::small_alloc`.
+1. The `Allocator::small_alloc` finds that it cannot satisfy the request because its lacks a fast free list for this size class.
+   The request is delegated, unchanged, to `Allocator::small_refill`.
 
-2. The `CoreAllocator` has no active slab for this sizeclass, so `CoreAllocator::small_alloc_slow` delegates to `BackendAllocator::alloc_chunk`.
+2. The `Allocator` has no active slab for this sizeclass, so `Allocator::small_refill_slow` delegates to `BackendAllocator::alloc_chunk`.
    At this point, the allocation request is enlarged to one or a few chunks (a small counting number multiple of `MIN_CHUNK_SIZE`, which is typically 16KiB); see `sizeclass_to_slab_size`.
 
 3. `BackendAllocator::alloc_chunk` at this point splits the allocation request in two, allocating both the chunk's metadata structure (of size `PAGEMAP_METADATA_STRUCT_SIZE`) and the chunk itself (a multiple of `MIN_CHUNK_SIZE`).

Diff for: docs/release/0.7/README.md

@@ -109,10 +109,10 @@ The additional meta-data size in snmalloc 0.6 was fixed and under a cache line i
 In snmalloc 0.7, we have made this meta-data size configurable.
 This allows developers to build new security features on top of snmalloc.
 
-For instance, building snmalloc with the following definition of `Alloc` will allow you to store a 64-bit counter for each allocation:
+For instance, building snmalloc with the following definition of `Config` will allow you to store a 64-bit counter for each allocation:
 ```cpp
-  using Alloc = snmalloc::LocalAllocator<snmalloc::StandardConfigClientMeta<
-    ArrayClientMetaDataProvider<std::atomic<size_t>>>>;
+  using Config = snmalloc::StandardConfigClientMeta<
+    ArrayClientMetaDataProvider<std::atomic<size_t>>>;
 ```
 
 This does not affect the underlying alignment of the allocations.

Diff for: fuzzing/snmalloc-fuzzer.cpp

@@ -148,7 +148,7 @@ struct Result
   {
     auto alloc = snmalloc::get_scoped_allocator();
     if (ptr)
-      alloc->dealloc(ptr, size);
+      alloc->dealloc(ptr);
     ptr = nullptr;
   }
 };

Diff for: src/snmalloc/README.md

@@ -20,7 +20,7 @@ These are arranged in a hierarchy such that each of the directories may include
    This includes data structures such as pagemap implementations (efficient maps from a chunk address to associated metadata) and buddy allocators for managing address-space ranges.
  - `backend/` provides some example implementations for snmalloc embeddings that provide a global memory allocator for an address space.
    Users may ignore this entirely and use the types in `mem/` with a custom back end to expose an snmalloc instance with specific behaviour.
-   Layers above this can be used with a custom configuration by defining `SNMALLOC_PROVIDE_OWN_CONFIG` and exporting a type as `snmalloc::Alloc` that defines the type of an `snmalloc::LocalAllocator` template specialisation.
+   Layers above this can be used with a custom configuration by defining `SNMALLOC_PROVIDE_OWN_CONFIG` and exporting a type as `snmalloc::Config` that defines the configuration.
  - `global/` provides some front-end components that assume that snmalloc is available in a global configuration.
  - `override/` builds on top of `global/` to provide specific implementations with compatibility with external specifications (for example C `malloc`, C++ `operator new`, jemalloc's `*allocx`, or Rust's `std::alloc`).