Add __sanitizer_get_allocated_begin API and implementations

[thurston]

Summary

This function will return the start of the allocation, if given a pointer that lies within an allocation. Otherwise, it returns NULL.

It will be useful for detecting dynamic TLS allocations in glibc >=2.25, which
uses malloc (see https://github.com/google/sanitizers/issues/1409#issuecomment-1214244142).

[thurston]

Add test for freed (new int)

[kstoimenov]

compiler-rt/lib/hwasan/hwasan_allocator.cpp

646

Nit: no space after function name.

653

I think that beg will be an untagged pointer. Please take that into account when implementing the client code because there is a good chance the pointer in the client code will be tagged.

compiler-rt/test/msan/get_allocation_bounds.cpp

1 ↗

(On Diff #508810)

Can we try moving this to compiler-rt/test/sanitizer_common? I am working on enabling HWASAN for those so when it's done HWASAN will be covered as well. Currently "supported tools" are: set(SUPPORTED_TOOLS_INIT asan lsan msan tsan ubsan) in compiler-rt/test/sanitizer_common/CMakeLists.txt.

[thurston]

compiler-rt/test/msan/get_allocation_bounds.cpp

1 ↗

(On Diff #508810)

To put this in sanitizer_common tests, I would need to add __sanitizer_get_allocation_bounds to stand-alone ubsan, even though AFAICS it doesn't have its own memory allocator. Should I proceed with that?

[kstoimenov]

compiler-rt/test/msan/get_allocation_bounds.cpp

1 ↗

(On Diff #508810)

Main motivation is to have this test run with all applicable sanitizers. You could disabled UBSAN using the UNSUPPORTED keyword. Another option is to provide an implementation which would satisfy the test with the standard allocator. Please double-check with vitalybuka@ before going down that path.

[thurston]

Minor bug fix

[thurston]

Revert to diff 2 (+ whitespace changes)

[thurston]

Formatting and minor bug fixes

[thurston]

Add function to sanitizer_common_interface.inc

[thurston]

Change HWASan implementation of __sanitizer_get_allocation_bounds to return tagged pointer

Mark test as unsupported for UBSan

[thurston]

compiler-rt/lib/hwasan/hwasan_allocator.cpp

653

Thanks for pointing this out! I've changed the implementation to return a tagged pointer.

[thurston]

Test both the primary and secondary allocators, by trying many different allocation sizes

[vitalybuka]

Could you please add a patch into the stack where it's used?

compiler-rt/include/sanitizer/allocator_interface.h

36 ↗

(On Diff #509789)

This is public interface, if we don't have to, we should avoid exposing it here.
Do we have a reason to do so?

sanitizer_common/sanitizer_interface_internal.h probably more appropriate?

compiler-rt/test/sanitizer_common/TestCases/get_allocation_bounds.cpp

8

how long this takes with? Can you make sure that it does not get into the top of:
LIT_OPTS="--time-tests" ninja check-sanitizer

[thurston]

compiler-rt/include/sanitizer/allocator_interface.h

36 ↗

(On Diff #509789)

I'll try moving it there.

compiler-rt/test/sanitizer_common/TestCases/get_allocation_bounds.cpp

8

It's not among the slowest tests:

4.70s: SanitizerCommon-tsan-x86_64-Linux :: get_allocation_bounds.cpp
4.53s: SanitizerCommon-asan-i386-Linux :: get_allocation_bounds.cpp
4.17s: SanitizerCommon-asan-x86_64-Linux :: get_allocation_bounds.cpp
3.99s: SanitizerCommon-msan-x86_64-Linux :: get_allocation_bounds.cpp
3.45s: SanitizerCommon-lsan-i386-Linux :: get_allocation_bounds.cpp
3.29s: SanitizerCommon-lsan-x86_64-Linux :: get_allocation_bounds.cpp

Slowest Tests:
--------------------------------------------------------------------------
16.38s: SanitizerCommon-msan-x86_64-Linux :: Linux/soft_rss_limit_mb_test.cpp
14.82s: SanitizerCommon-asan-i386-Linux :: Linux/soft_rss_limit_mb_test.cpp
14.77s: SanitizerCommon-asan-x86_64-Linux :: Linux/soft_rss_limit_mb_test.cpp
14.42s: SanitizerCommon-ubsan-i386-Linux :: Posix/qsort.cpp
14.14s: SanitizerCommon-tsan-x86_64-Linux :: Linux/soft_rss_limit_mb_test.cpp
14.12s: SanitizerCommon-ubsan-x86_64-Linux :: Posix/qsort.cpp
14.06s: SanitizerCommon-lsan-i386-Linux :: Linux/soft_rss_limit_mb_test.cpp
13.83s: SanitizerCommon-lsan-x86_64-Linux :: Linux/soft_rss_limit_mb_test.cpp
11.52s: SanitizerCommon-msan-x86_64-Linux :: compress_stack_depot.cpp
11.18s: SanitizerCommon-asan-i386-Linux :: Posix/qsort.cpp
10.47s: SanitizerCommon-Unit :: ./Sanitizer-x86_64-Test/SanitizerCommon/CombinedAllocator32Compact
10.29s: SanitizerCommon-msan-x86_64-Linux :: Posix/qsort.cpp
10.24s: SanitizerCommon-asan-x86_64-Linux :: Posix/qsort.cpp
9.82s: SanitizerCommon-lsan-i386-Linux :: Posix/qsort.cpp
9.81s: SanitizerCommon-asan-i386-Linux :: get_allocation_bounds.cpp
9.57s: SanitizerCommon-lsan-x86_64-Linux :: Posix/qsort.cpp
9.52s: SanitizerCommon-asan-i386-Linux :: Linux/signal_segv_handler.cpp
9.48s: SanitizerCommon-tsan-x86_64-Linux :: Linux/resize_tls_dynamic.cpp
9.39s: SanitizerCommon-asan-i386-Linux :: compress_stack_depot.cpp
9.37s: SanitizerCommon-lsan-i386-Linux :: Linux/signal_segv_handler.cpp

[thurston]

Move __sanitizer_get_allocation_bounds to internal header, per Vitaly's suggestion.

Update test accordingly.

[thurston]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

40–42

I'll work on removing this too.

[vitalybuka]

compiler-rt/include/sanitizer/allocator_interface.h

36 ↗

(On Diff #509789)

Sorry, after looking into this more, seems original header was fine.

36 ↗

(On Diff #509789)

there is redundancy sanitizer_get_allocation_bounds sanitizer_get_allocated_size

sanitizer_get_allocated_size does half the work
would it be better to add:

void * __sanitizer_get_allocated_begin(const volatile void *p)

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_allocator.cpp

644

I'd recommend to extract AllocationBegin() next to AllocationSize() and keep interface methods implementation short like __sanitizer_get_allocated_size.

Please do the same for all sanitizers

646

looks tool long, please

git clang-format -f --extensions=inc,cc,h,c,cpp,rst HEAD^

compiler-rt/lib/tsan/rtl/tsan_mman.cpp

450

is this for malloc(0)? looks strange, but let's keep it consistent with __sanitizer_get_allocated_size

[vitalybuka]

compiler-rt/lib/tsan/rtl/tsan_mman.cpp

450

is this for malloc(0)? looks strange, but let's keep it consistent with __sanitizer_get_allocated_size

strange that we return 1 to the user, I would expected the same value as passed into malloc.

[thurston]

Change sanitizer_get_allocation_bounds to sanitizer_get_allocated_begin,
per Vitaly's comment

[thurston]

In D147005#4237707, @vitalybuka wrote:

Could you please add a patch into the stack where it's used?

Coming soon (tm)

compiler-rt/include/sanitizer/allocator_interface.h

36 ↗

(On Diff #509789)

Sorry, after looking into this more, seems original header was fine.

I've moved it back to the original header

36 ↗

(On Diff #509789)

there is redundancy sanitizer_get_allocation_bounds sanitizer_get_allocated_size

sanitizer_get_allocated_size does half the work
would it be better to add:

void * __sanitizer_get_allocated_begin(const volatile void *p)

Done

compiler-rt/lib/hwasan/hwasan_allocator.cpp

644

I'd recommend to extract AllocationBegin() next to AllocationSize() and keep interface methods implementation short like __sanitizer_get_allocated_size.

Please do the same for all sanitizers

Done

646

looks tool long, please

git clang-format -f --extensions=inc,cc,h,c,cpp,rst HEAD^

Done

[thurston]

In D147005#4241093, @thurston wrote:

In D147005#4237707, @vitalybuka wrote:

Could you please add a patch into the stack where it's used?

Coming soon (tm)

This patch is useful for "Fix tls_get_addr handling for glibc >=2.25" (https://reviews.llvm.org/D147459)

[vitalybuka]

compiler-rt/lib/dfsan/dfsan_allocator.cpp

181

We use implicit pointer tests, please fix for entire patch

[vitalybuka]

compiler-rt/lib/lsan/lsan_allocator.cpp

366

why this one is SANITIZER_WEAK_ATTRIBUTE? It should not be

[thurston]

Use implicit pointer checks, per Vitaly's feedback

Also removed unnecessary weak annotation (though the
header still has it).

[thurston]

compiler-rt/lib/dfsan/dfsan_allocator.cpp

181

Done

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

24

It was LGTM assuming you'll remove SANITIZER_WEAK_ATTRIBUTE

compiler-rt/lib/asan/asan_allocator.cpp

uptr __sanitizer_get_allocated_size(const void *p) {
   // Die if p is not malloced or if it is already freed.
   if (allocated_size == 0) {
     GET_STACK_TRACE_FATAL_HERE;
     ReportSanitizerGetAllocatedSizeNotOwned(ptr, &stack);
   }
   return allocated_size;
 }
 
+int __sanitizer_get_allocation_bounds(const void *p, void **start, unsigned long long *size) {
+  AsanChunk *m = __asan::instance.GetAsanChunkByAddr((uptr)p);
+  if (!m) return 0;
+  if (atomic_load(&m->chunk_state, memory_order_acquire) != CHUNK_ALLOCATED)
+    return 0;
+  if (m->UsedSize() == 0) return 0;
+  *start = (void*)(m->Beg());
+  *size = m->UsedSize();
+  return 1;
+}
+
 void __sanitizer_purge_allocator() {
   GET_STACK_TRACE_MALLOC;
   instance.Purge(&stack);
 }
 
 int __asan_update_allocation_context(void* addr) {
   GET_STACK_TRACE_MALLOC;
   return instance.UpdateAllocationStack((uptr)addr, &stack);
 }

compiler-rt/lib/dfsan/dfsan_allocator.cpp

void *DFsanCalloc(uptr nmemb, uptr size) {
   }
   return DFsanAllocate(nmemb * size, sizeof(u64), true /*zeroise*/);
 }
 
 static uptr AllocationSize(const void *p) {
   if (!p)
     return 0;
   const void *beg = allocator.GetBlockBegin(p);
   if (beg != p)
     return 0;
   Metadata *b = (Metadata *)allocator.GetMetaData(p);
   return b->requested_size;
 }
 
 void *dfsan_malloc(uptr size) {
   return SetErrnoOnNull(DFsanAllocate(size, sizeof(u64), false /*zeroise*/));
 }

 
 uptr __sanitizer_get_unmapped_bytes() { return 1; }
 
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 int __sanitizer_get_ownership(const void *p) { return AllocationSize(p) != 0; }
 
 uptr __sanitizer_get_allocated_size(const void *p) { return AllocationSize(p); }
+
+int __sanitizer_get_allocation_bounds(const void *p, void **start,
+                                      unsigned long long *size) {
+  if (!p)
+    return 0;
+  const void *beg = allocator.GetBlockBegin(p);
+  if (beg == nullptr)
+    return 0;
+  Metadata *b = (Metadata *)allocator.GetMetaData(beg);
+  if (b == nullptr)
+    return 0;
+  if (b->requested_size == 0)
+    return 0;
+  *start = (void *)beg;
+  *size = b->requested_size;
+  return 1;
+}

compiler-rt/lib/hwasan/hwasan_allocator.cpp

 uptr __sanitizer_get_free_bytes() { return 1; }
 
 uptr __sanitizer_get_unmapped_bytes() { return 1; }
 
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 int __sanitizer_get_ownership(const void *p) { return AllocationSize(p) != 0; }
 
 uptr __sanitizer_get_allocated_size(const void *p) { return AllocationSize(p); }
+
+int __sanitizer_get_allocation_bounds(const void *p, void **start, unsigned long long *size) {
+  const void *untagged_ptr = UntagPtr(p);
+  if (!untagged_ptr) return 0;
+
+  const void *beg = allocator.GetBlockBegin(untagged_ptr);
+  if (beg == nullptr) return 0;
+
+  Metadata *b = (Metadata *)allocator.GetMetaData(beg);
+  if (b->GetRequestedSize() == 0) return 0;
+
+  tag_t tag = GetTagFromPointer((uptr)p);
+  *start = (void*)AddTagToPointer((uptr)beg, tag);
+  *size = b->GetRequestedSize();
+
+  return 1;
+}

compiler-rt/lib/lsan/lsan_allocator.cpp

 uptr __sanitizer_get_unmapped_bytes() { return 0; }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 int __sanitizer_get_ownership(const void *p) { return Metadata(p) != nullptr; }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_allocated_size(const void *p) {
   return GetMallocUsableSize(p);
 }
 
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
+int __sanitizer_get_allocation_bounds(const void *p, void **start, unsigned long long *size) {
+  if (!p) return 0;
+  const void *beg = allocator.GetBlockBegin(p);
+  if (beg == nullptr) return 0;
+  ChunkMetadata *m = Metadata(beg);
+  if (m == nullptr) return 0;
+  if (!m->allocated) return 0;
+  if (m->requested_size == 0) return 0;
+  *start = (void*)beg;
+  *size = m->requested_size;
+  return 1;
+}
+
 } // extern "C"

compiler-rt/lib/memprof/memprof_allocator.cpp

 int __sanitizer_get_ownership(const void *p) {
   return memprof_malloc_usable_size(p, 0, 0) != 0;
 }
 
 uptr __sanitizer_get_allocated_size(const void *p) {
   return memprof_malloc_usable_size(p, 0, 0);
 }
 
+int __sanitizer_get_allocation_bounds(const void *p, void **start, unsigned long long *size) {
+  u64 user_requested_size;
+  MemprofChunk *m = instance.GetMemprofChunkByAddr((uptr)p, user_requested_size);
+  if (!m)
+    return 0;
+  if (user_requested_size == 0) return 0;
+  *start = (void*)m->Beg();
+  *size = user_requested_size;
+  return 1;
+}
+
 int __memprof_profile_dump() {
   instance.FinishAndWrite();
   // In the future we may want to return non-zero if there are any errors
   // detected during the dumping process.
   return 0;
 }

compiler-rt/lib/msan/msan_allocator.cpp

 
 uptr __sanitizer_get_unmapped_bytes() { return 1; }
 
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 int __sanitizer_get_ownership(const void *p) { return AllocationSize(p) != 0; }
 
 uptr __sanitizer_get_allocated_size(const void *p) { return AllocationSize(p); }
+
+int __sanitizer_get_allocation_bounds(const void *p, void **start, unsigned long long *size) {
+  if (!p) return 0;
+  const void *beg = allocator.GetBlockBegin(p);
+  if (beg == nullptr) return 0;
+  Metadata *b = (Metadata *)allocator.GetMetaData(beg);
+  if (b == nullptr) return 0;
+  if (b->requested_size == 0) return 0;
+  *start = (void*)beg;
+  *size = b->requested_size;
+  return 1;
+}

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

 #include "sanitizer_internal_defs.h"
 
 using __sanitizer::uptr;
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_estimated_allocated_size(uptr size);
 SANITIZER_INTERFACE_ATTRIBUTE int __sanitizer_get_ownership(const void *p);
 SANITIZER_INTERFACE_ATTRIBUTE uptr
 __sanitizer_get_allocated_size(const void *p);
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_current_allocated_bytes();
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_heap_size();
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_free_bytes();
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_unmapped_bytes();
 
 SANITIZER_INTERFACE_ATTRIBUTE int __sanitizer_install_malloc_and_free_hooks(
     void (*malloc_hook)(const void *, uptr),
     void (*free_hook)(const void *));
 
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
     void __sanitizer_malloc_hook(void *ptr, uptr size);
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
     void __sanitizer_free_hook(void *ptr);
 
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE int
+__sanitizer_get_allocation_bounds(const void *p, void **start,
+                                  unsigned long long *size);
+
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
 __sanitizer_purge_allocator();
 
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void
 __sanitizer_print_memory_profile(uptr top_percent, uptr max_number_of_contexts);
 }  // extern "C"
 
 #endif  // SANITIZER_ALLOCATOR_INTERFACE_H

compiler-rt/lib/sanitizer_common/sanitizer_allocator_internal.h

 void *InternalReallocArray(void *p, uptr count, uptr size,
                            InternalAllocatorCache *cache = nullptr);
 void *InternalCalloc(uptr count, uptr size,
                      InternalAllocatorCache *cache = nullptr);
 void InternalFree(void *p, InternalAllocatorCache *cache = nullptr);
 void InternalAllocatorLock();
 void InternalAllocatorUnlock();
 InternalAllocator *internal_allocator();
-
+int __sanitizer_get_allocation_bounds(const void *p, void **start,
+                                      unsigned long long *size);
 } // namespace __sanitizer
 
 #endif // SANITIZER_ALLOCATOR_INTERNAL_H

compiler-rt/lib/tsan/rtl/tsan_mman.cpp

 int __sanitizer_get_ownership(const void *p) {
   return allocator()->GetBlockBegin(p) != 0;
 }
 
 uptr __sanitizer_get_allocated_size(const void *p) {
   return user_alloc_usable_size(p);
 }
 
+int __sanitizer_get_allocation_bounds(const void *p, void **start, unsigned long long *size) {
+  if (p == 0 || !IsAppMem((uptr)p))
+    return 0;
+  const void *beg = allocator()->GetBlockBegin(p);
+  if (beg == nullptr) return 0;
+
+  MBlock *b = ctx->metamap.GetBlock((uptr)beg);
+  if (!b)
+    return 0; // Not a valid pointer.
+
+  *start = (void*)beg;
+
+  if (b->siz == 0) {
+    *size = 1; // Zero-sized allocations are actually 1 byte.
+  } else {
+    *size = b->siz;
+  }
+  return 1;
+}
+
 void __tsan_on_thread_idle() {
   ThreadState *thr = cur_thread();
   allocator()->SwallowCache(&thr->proc()->alloc_cache);
   internal_allocator()->SwallowCache(&thr->proc()->internal_alloc_cache);
   ctx->metamap.OnProcIdle(thr->proc());
 }
 }  // extern "C"

compiler-rt/test/sanitizer_common/TestCases/get_allocation_bounds.cpp

+// RUN: %clangxx -O0 -g %s -o %t && %run %t
+
+// UBSan does not have its own allocator
+// UNSUPPORTED: ubsan
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern "C" int __sanitizer_get_allocation_bounds(const void *p, void **start,
+                                                 unsigned long long *size);
+
+// Based on lib/msan/tests/msan_test.cpp::get_allocated_size_and_ownership
+int main(void) {
+  int sizes[] = {10, 100, 1000, 10000, 100000, 1000000};
+
+  for (int i = 0; i < sizeof(sizes) / sizeof(int); i++) {
+    printf("Testing size %d\n", sizes[i]);
+
+    char *array = reinterpret_cast<char *>(malloc(sizes[i]));
+    int *int_ptr = new int;
+    printf("array: %p\n", array);
+    printf("int_ptr: %p\n", int_ptr);
+
+    // Bogus values to unpoison these. Calling __sanitizer_get_allocation_bounds
+    // does not unpoison them.
+    void *start = NULL;
+    unsigned long long size = 666;
+    for (int j = 0; j < sizes[i]; j++) {
+      printf("j: %d\n", j);
+
+      printf("Bounds ok? %d\n",
+             __sanitizer_get_allocation_bounds(array + j, &start, &size));
+      fflush(stdout);
+      assert(__sanitizer_get_allocation_bounds(array + j, &start, &size));
+      printf("Size: %llu (expected: %d)\n", size, sizes[i]);
+      fflush(stdout);
+      printf("Start: %p (expected: %p)\n", start, array);
+      fflush(stdout);
+      assert(array == start);
+      assert(sizes[i] == size);
+    }
+
+    assert(__sanitizer_get_allocation_bounds(int_ptr, &start, &size));
+    assert(int_ptr == start);
+    assert(sizeof(*int_ptr) == size);
+
+    void *wild_addr = reinterpret_cast<void *>(4096 * 160);
+    assert(!__sanitizer_get_allocation_bounds(wild_addr, &start, &size));
+
+    wild_addr = reinterpret_cast<void *>(0x1);
+    assert(!__sanitizer_get_allocation_bounds(wild_addr, &start, &size));
+
+    // NULL is a valid argument for GetAllocatedSize but is not owned.
+    assert(!__sanitizer_get_allocation_bounds(NULL, &start, &size));
+
+    free(array);
+    for (int j = 0; j < sizes[i]; j++) {
+      assert(!__sanitizer_get_allocation_bounds(array + j, &start, &size));
+    }
+
+    delete int_ptr;
+    assert(!__sanitizer_get_allocation_bounds(int_ptr, &start, &size));
+  }
+
+  return 0;
+}