[lsan] Fix allocator_interface implementation

[vitalybuka]

Summary

__sanitizer_get_current_allocated_bytes had as body, but allocator
caches were not registered to collect stats. It's done by
SizeClassAllocator64LocalCache::Init().

[vitalybuka]

update

[vitalybuka]

This one is more than XFAIL, we have failed tests in LSAN which query this stats

[dyung]

Hi @vitalybuka, after your change, the test sanitizer_common/TestCases/Linux/release_to_os_test.cpp started to XPASS on a bot https://lab.llvm.org/buildbot/#/builders/247/builds/4903. Can you take a look and if it is expected, remove the XFAIL?

[thurston]

@dyung

@vitalybuka had submitted a patch to deflake this test: https://github.com/llvm/llvm-project/commit/3afd1b2c357fb5353084a736d885af60115d6acb

I've temporarily disabled the test altogether: https://reviews.llvm.org/rG9289b64bc48f13638cff7e470afce738af56b795

compiler-rt/lib/lsan/lsan_allocator.h

 void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
                  uptr alignment);
 uptr GetMallocUsableSize(const void *p);
 
 template<typename Callable>
 void ForEachChunk(const Callable &callback);
 
 void GetAllocatorCacheRange(uptr *begin, uptr *end);
+void AllocatorThreadStart();
 void AllocatorThreadFinish();
 void InitializeAllocator();
 
 const bool kAlwaysClearMemory = true;
 
 struct ChunkMetadata {
   u8 allocated : 8;  // Must be first.
   ChunkTag tag : 2;

compiler-rt/lib/lsan/lsan_allocator.cpp

allocator.InitLinkerInitialized(
       common_flags()->allocator_release_to_os_interval_ms);
   if (common_flags()->max_allocation_size_mb)
     max_malloc_size = Min(common_flags()->max_allocation_size_mb << 20,
                           kMaxAllowedMallocSize);
   else
     max_malloc_size = kMaxAllowedMallocSize;
 }
 
+void AllocatorThreadStart() { allocator.InitCache(GetAllocatorCache()); }
+
 void AllocatorThreadFinish() {
   allocator.SwallowCache(GetAllocatorCache());
+  allocator.DestroyCache(GetAllocatorCache());
 }
 
 static ChunkMetadata *Metadata(const void *p) {
   return reinterpret_cast<ChunkMetadata *>(allocator.GetMetaData(p));
 }
 
 static void RegisterAllocation(const StackTrace &stack, void *p, uptr size) {
   if (!p) return;

 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_heap_size() {
   uptr stats[AllocatorStatCount];
   allocator.GetStats(stats);
   return stats[AllocatorStatMapped];
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
-uptr __sanitizer_get_free_bytes() { return 0; }
+uptr __sanitizer_get_free_bytes() { return 1; }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 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; }
+int __sanitizer_get_ownership(const void *p) {
+  return GetMallocBegin(p) != nullptr;
+}
 
 SANITIZER_INTERFACE_ATTRIBUTE
 const void * __sanitizer_get_allocated_begin(const void *p) {
   return GetMallocBegin(p);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_allocated_size(const void *p) {
   return GetMallocUsableSize(p);
 }
 
+SANITIZER_INTERFACE_ATTRIBUTE
+void __sanitizer_purge_allocator() { allocator.ForceReleaseToOS(); }
+
 } // extern "C"

compiler-rt/lib/lsan/lsan_thread.cpp

void InitializeThreadRegistry() {
   thread_arg_retval = new (thread_arg_retval_placeholder) ThreadArgRetval();
 }
 
 ThreadArgRetval &GetThreadArgRetval() { return *thread_arg_retval; }
 
 ThreadContextLsanBase::ThreadContextLsanBase(int tid)
     : ThreadContextBase(tid) {}
 
-void ThreadContextLsanBase::OnStarted(void *arg) { SetCurrentThread(this); }
+void ThreadContextLsanBase::OnStarted(void *arg) {
+  SetCurrentThread(this);
+  AllocatorThreadStart();
+}
 
 void ThreadContextLsanBase::OnFinished() {
   AllocatorThreadFinish();
   DTLS_Destroy();
   SetCurrentThread(nullptr);
 }
 
 u32 ThreadCreate(u32 parent_tid, bool detached, void *arg) {

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

 // RUN: %clangxx %s -o %t && %run %t 1234
 // RUN: %clangxx %s -o %t && %run %t 5678910
 
 // No allocator.
 // UNSUPPORTED: ubsan
 
 // FIXME: implementation is incomplete.
-// XFAIL: lsan, hwasan
+// XFAIL: hwasan
 
 #include <assert.h>
 #include <sanitizer/allocator_interface.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <thread>
 
 void Test(int size) {