[GWP-ASan] Add names to anonymous mappings.

[hctim]

Summary

Adds names to anonymous GWP-ASan mappings. This helps Android with debugging
via. /proc/maps, as GWP-ASan-allocated mappings are now easily identifyable.

[eugenis]

Could you add a test?

[merge_guards_bot]

Unit tests: fail. 62146 tests passed, 5 failed and 811 were skipped.

failed: libc++.std/language_support/cmp/cmp_partialord/partialord.pass.cpp
failed: libc++.std/language_support/cmp/cmp_strongeq/cmp.strongeq.pass.cpp
failed: libc++.std/language_support/cmp/cmp_strongord/strongord.pass.cpp
failed: libc++.std/language_support/cmp/cmp_weakeq/cmp.weakeq.pass.cpp
failed: libc++.std/language_support/cmp/cmp_weakord/weakord.pass.cpp

clang-tidy: fail. clang-tidy found 3 errors and 5 warnings. 0 of them are added as review comments below (why?).

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[hctim]

In D73373#1839343, @eugenis wrote:

Could you add a test?

How would you prefer I go about testing this? I can read from /proc/maps but only on Android (which IIRC GWP-ASan doesn't actually test on upstream, only downstream). FWIW - Scudo doesn't have tests for this either.

[eugenis]

AFAIK we do test on android.
See http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-android/builds/27148/steps/run%20lit%20tests%20%5Baarch64%2Faosp_marlin-userdebug%2FPI%5D/logs/stdio - it lists a few scudo tests as unsupported, which means the rest of them have passed.

You can do something like test/sanitizer_common/TestCases/Linux/decorate_proc_maps.cpp

[hctim]

AFAIK we do test on android.

compiler-rt/cmake/config-ix.cmake:739

# Note: Fuchsia and Windows are not currently supported by GWP-ASan. Support
# is planned for these platforms. Darwin is also not supported due to TLS
# calling malloc on first use.
# TODO(hctim): Enable this on Android again. Looks like it's causing a SIGSEGV
# for Scudo and GWP-ASan, further testing needed.
if (COMPILER_RT_HAS_SANITIZER_COMMON AND GWP_ASAN_SUPPORTED_ARCH AND
    OS_NAME MATCHES "Linux") # <----------------------------------------------------------------------------[here]
  set(COMPILER_RT_HAS_GWP_ASAN TRUE)
else()
  set(COMPILER_RT_HAS_GWP_ASAN FALSE)
endif()
pythonize_bool(COMPILER_RT_HAS_GWP_ASAN)

I should probably address this TODO as well... It may actually be resolved with the fork() changes, but I can't remember what the exact problem is.

[eugenis]

Hm, we should really fix that sometime soon.

In the mean time, I'm OK with this going in w/o tests, after all it's mainly a decorative change.
But please leave a TODO somewhere.

[hctim]

• Merged from master (after enable/disable + fork support by @eugenis).

[merge_guards_bot]

Unit tests: fail. 62191 tests passed, 1 failed and 815 were skipped.

failed: libc++.std/thread/thread_mutex/thread_mutex_requirements/thread_timedmutex_requirements/thread_timedmutex_class/lock.pass.cpp

clang-tidy: fail. clang-tidy found 3 errors and 5 warnings. 0 of them are added as review comments below (why?).

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

compiler-rt/lib/gwp_asan/guarded_pool_allocator.h

 // ASan. It is the sole owner of the pool of sequentially allocated guarded
 // slots. It should always be treated as a singleton.
 
 // Functions in the public interface of this class are thread-compatible until
 // init() is called, at which point they become thread-safe (unless specified
 // otherwise).
 class GuardedPoolAllocator {
 public:
+  // Name of the GWP-ASan mapping that for `Metadata`.
+  static constexpr const char *kGwpAsanMetadataName = "GWP-ASan Metadata";
+
   static constexpr uint64_t kInvalidThreadID = UINT64_MAX;
 
   enum class Error {
     UNKNOWN,
     USE_AFTER_FREE,
     DOUBLE_FREE,
     INVALID_FREE,
     BUFFER_OVERFLOW,
public:
   // occur.
   static void reportError(uintptr_t AccessPtr, Error E = Error::UNKNOWN);
 
   // Get the current thread ID, or kInvalidThreadID if failure. Note: This
   // implementation is platform-specific.
   static uint64_t getThreadID();
 
 private:
+  // Name of actively-occupied slot mappings.
+  static constexpr const char *kGwpAsanAliveSlotName = "GWP-ASan Alive Slot";
+  // Name of the guard pages. This includes all slots that are not actively in
+  // use (i.e. were never used, or have been free()'d).)
+  static constexpr const char *kGwpAsanGuardPageName = "GWP-ASan Guard Page";
+  // Name of the mapping for `FreeSlots`.
+  static constexpr const char *kGwpAsanFreeSlotsName = "GWP-ASan Metadata";
+
   static constexpr size_t kInvalidSlotID = SIZE_MAX;
 
   // These functions anonymously map memory or change the permissions of mapped
   // memory into this process in a platform-specific way. Pointer and size
   // arguments are expected to be page-aligned. These functions will never
   // return on error, instead electing to kill the calling process on failure.
   // Note that memory is initially mapped inaccessible. In order for RW
   // mappings, call mapMemory() followed by markReadWrite() on the returned
-  // pointer.
-  void *mapMemory(size_t Size) const;
-  void unmapMemory(void *Addr, size_t Size) const;
-  void markReadWrite(void *Ptr, size_t Size) const;
-  void markInaccessible(void *Ptr, size_t Size) const;
+  // pointer. Each mapping is named on platforms that support it, primarily
+  // Android. This name must be a statically allocated string, as the Android
+  // kernel uses the string pointer directly.
+  void *mapMemory(size_t Size, const char *Name) const;
+  void unmapMemory(void *Ptr, size_t Size, const char *Name) const;
+  void markReadWrite(void *Ptr, size_t Size, const char *Name) const;
+  void markInaccessible(void *Ptr, size_t Size, const char *Name) const;
 
   // Get the page size from the platform-specific implementation. Only needs to
   // be called once, and the result should be cached in PageSize in this class.
   static size_t getPlatformPageSize();
 
   // Install the SIGSEGV crash handler for printing use-after-free and heap-
   // buffer-{under|over}flow exceptions. This is platform specific as even
   // though POSIX and Windows both support registering handlers through

compiler-rt/lib/gwp_asan/guarded_pool_allocator.cpp

void GuardedPoolAllocator::init(const options::Options &Opts) {
   if (Opts.PrintBacktrace)
     PrintBacktrace = Opts.PrintBacktrace;
   else
     PrintBacktrace = defaultPrintStackTrace;
 
   size_t PoolBytesRequired =
       PageSize * (1 + MaxSimultaneousAllocations) +
       MaxSimultaneousAllocations * maximumAllocationSize();
-  void *GuardedPoolMemory = mapMemory(PoolBytesRequired);
+  void *GuardedPoolMemory = mapMemory(PoolBytesRequired, kGwpAsanGuardPageName);
 
   size_t BytesRequired = MaxSimultaneousAllocations * sizeof(*Metadata);
-  Metadata = reinterpret_cast<AllocationMetadata *>(mapMemory(BytesRequired));
-  markReadWrite(Metadata, BytesRequired);
+  Metadata = reinterpret_cast<AllocationMetadata *>(
+      mapMemory(BytesRequired, kGwpAsanMetadataName));
+  markReadWrite(Metadata, BytesRequired, kGwpAsanMetadataName);
 
   // Allocate memory and set up the free pages queue.
   BytesRequired = MaxSimultaneousAllocations * sizeof(*FreeSlots);
-  FreeSlots = reinterpret_cast<size_t *>(mapMemory(BytesRequired));
-  markReadWrite(FreeSlots, BytesRequired);
+  FreeSlots = reinterpret_cast<size_t *>(
+      mapMemory(BytesRequired, kGwpAsanFreeSlotsName));
+  markReadWrite(FreeSlots, BytesRequired, kGwpAsanFreeSlotsName);
 
   // Multiply the sample rate by 2 to give a good, fast approximation for (1 /
   // SampleRate) chance of sampling.
   if (Opts.SampleRate != 1)
     AdjustedSampleRatePlusOne = static_cast<uint32_t>(Opts.SampleRate) * 2 + 1;
   else
     AdjustedSampleRatePlusOne = 2;
 

 
 void GuardedPoolAllocator::disable() { PoolMutex.lock(); }
 
 void GuardedPoolAllocator::enable() { PoolMutex.unlock(); }
 
 void GuardedPoolAllocator::uninitTestOnly() {
   if (GuardedPagePool) {
     unmapMemory(reinterpret_cast<void *>(GuardedPagePool),
-                GuardedPagePoolEnd - GuardedPagePool);
+                GuardedPagePoolEnd - GuardedPagePool, kGwpAsanGuardPageName);
     GuardedPagePool = 0;
     GuardedPagePoolEnd = 0;
   }
   if (Metadata) {
-    unmapMemory(Metadata, MaxSimultaneousAllocations * sizeof(*Metadata));
+    unmapMemory(Metadata, MaxSimultaneousAllocations * sizeof(*Metadata),
+                kGwpAsanMetadataName);
     Metadata = nullptr;
   }
   if (FreeSlots) {
-    unmapMemory(FreeSlots, MaxSimultaneousAllocations * sizeof(*FreeSlots));
+    unmapMemory(FreeSlots, MaxSimultaneousAllocations * sizeof(*FreeSlots),
+                kGwpAsanFreeSlotsName);
     FreeSlots = nullptr;
   }
   uninstallSignalHandlers();
 }
 
 void *GuardedPoolAllocator::allocate(size_t Size) {
   // GuardedPagePoolEnd == 0 when GWP-ASan is disabled. If we are disabled, fall
   // back to the supporting allocator.
void *GuardedPoolAllocator::allocate(size_t Size) {
 
   uintptr_t Ptr = slotToAddr(Index);
   Ptr += allocationSlotOffset(Size);
   AllocationMetadata *Meta = addrToMetadata(Ptr);
 
   // If a slot is multiple pages in size, and the allocation takes up a single
   // page, we can improve overflow detection by leaving the unused pages as
   // unmapped.
-  markReadWrite(reinterpret_cast<void *>(getPageAddr(Ptr)), Size);
+  markReadWrite(reinterpret_cast<void *>(getPageAddr(Ptr)), Size,
+                kGwpAsanAliveSlotName);
 
   Meta->RecordAllocation(Ptr, Size, Backtrace);
 
   return reinterpret_cast<void *>(Ptr);
 }
 
 void GuardedPoolAllocator::deallocate(void *Ptr) {
   assert(pointerIsMine(Ptr) && "Pointer is not mine!");
// pool during the expensive markInaccessible() call.
     }
 
     // Ensure that the deallocation is recorded before marking the page as
     // inaccessible. Otherwise, a racy use-after-free will have inconsistent
     // metadata.
     Meta->RecordDeallocation(Backtrace);
   }
 
-  markInaccessible(reinterpret_cast<void *>(SlotStart),
-                   maximumAllocationSize());
+  markInaccessible(reinterpret_cast<void *>(SlotStart), maximumAllocationSize(),
+                   kGwpAsanGuardPageName);
 
   // And finally, lock again to release the slot back into the pool.
   ScopedLock L(PoolMutex);
   freeSlot(addrToSlot(UPtr));
 }
 
 size_t GuardedPoolAllocator::getSize(const void *Ptr) {
   assert(pointerIsMine(Ptr));

compiler-rt/lib/gwp_asan/platform_specific/guarded_pool_allocator_posix.cpp

 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <unistd.h>
 
-namespace gwp_asan {
+#ifdef ANDROID
+#include <sys/prctl.h>
+#define PR_SET_VMA 0x53564d41
+#define PR_SET_VMA_ANON_NAME 0
+#endif // ANDROID
+
+void MaybeSetMappingName(void *Mapping, size_t Size, const char *Name) {
+#ifdef ANDROID
+  prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, Mapping, Size, Name);
+#endif // ANDROID
+  // Anonymous mapping names are only supported on Android.
+  return;
+}
 
-void *GuardedPoolAllocator::mapMemory(size_t Size) const {
+namespace gwp_asan {
+void *GuardedPoolAllocator::mapMemory(size_t Size, const char *Name) const {
   void *Ptr =
       mmap(nullptr, Size, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
 
   if (Ptr == MAP_FAILED) {
     Printf("Failed to map guarded pool allocator memory, errno: %d\n", errno);
     Printf("  mmap(nullptr, %zu, ...) failed.\n", Size);
     exit(EXIT_FAILURE);
   }
+  MaybeSetMappingName(Ptr, Size, Name);
   return Ptr;
 }
 
-void GuardedPoolAllocator::unmapMemory(void *Addr, size_t Size) const {
-  int Res = munmap(Addr, Size);
+void GuardedPoolAllocator::unmapMemory(void *Ptr, size_t Size,
+                                       const char *Name) const {
+  int Res = munmap(Ptr, Size);
 
   if (Res != 0) {
     Printf("Failed to unmap guarded pool allocator memory, errno: %d\n", errno);
-    Printf("  unmmap(%p, %zu, ...) failed.\n", Addr, Size);
+    Printf("  unmmap(%p, %zu, ...) failed.\n", Ptr, Size);
     exit(EXIT_FAILURE);
   }
+  MaybeSetMappingName(Ptr, Size, Name);
 }
 
-void GuardedPoolAllocator::markReadWrite(void *Ptr, size_t Size) const {
+void GuardedPoolAllocator::markReadWrite(void *Ptr, size_t Size,
+                                         const char *Name) const {
   if (mprotect(Ptr, Size, PROT_READ | PROT_WRITE) != 0) {
     Printf("Failed to set guarded pool allocator memory at as RW, errno: %d\n",
            errno);
     Printf("  mprotect(%p, %zu, RW) failed.\n", Ptr, Size);
     exit(EXIT_FAILURE);
   }
+  MaybeSetMappingName(Ptr, Size, Name);
 }
 
-void GuardedPoolAllocator::markInaccessible(void *Ptr, size_t Size) const {
+void GuardedPoolAllocator::markInaccessible(void *Ptr, size_t Size,
+                                            const char *Name) const {
   // mmap() a PROT_NONE page over the address to release it to the system, if
   // we used mprotect() here the system would count pages in the quarantine
   // against the RSS.
   if (mmap(Ptr, Size, PROT_NONE, MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1,
            0) == MAP_FAILED) {
     Printf("Failed to set guarded pool allocator memory as inaccessible, "
            "errno: %d\n",
            errno);
     Printf("  mmap(%p, %zu, NONE, ...) failed.\n", Ptr, Size);
     exit(EXIT_FAILURE);
   }
+  MaybeSetMappingName(Ptr, Size, Name);
 }
 
 size_t GuardedPoolAllocator::getPlatformPageSize() {
   return sysconf(_SC_PAGESIZE);
 }
 
 struct sigaction PreviousHandler;
 bool SignalHandlerInstalled;