[sanitizers][Windows] implement __sanitizer_purge_allocator for Win64

[mcgov]

Summary

On Windows memory is never released once it's mapped with VirtualAlloc. This isn't a huge deal for many applications but with LibFuzzer this can lead to OOM's quite quickly.

The memory management model for the sanitizer allocator doesn't seem to quite fit the needs of Windows in this case, I think the assumption is that pages will be reclaimed and remapped as needed by the OS when they are touched. This patch attempts to unmap and remap pages, I'm putting it up for comment and review, I'm guessing this will need some additional work to avoid putting Windows code in a shared section.

Thank you everyone for your time, attention, and expertise!

patch authored by mcgov and Jordyn Puryear

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_allocator_primary64.h

152

MmapFixedOrDie can't return nulltpr

compiler-rt/lib/sanitizer_common/sanitizer_win.cpp

337–343

Isn't sanitizers on windows are always 64?

338

RoundUpTo/RoundDownTo?

[mcgov]

added purge test, updated for Vitaly's comments

[mcgov]

update test to only apply to x64 (we still build x86)

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_win.cpp

337–344

I see no reason to split declaration from initialization.

compiler-rt/test/asan/TestCases/Windows/sanitizer_purge.cpp

7–9

We usually put RUN: before includes

and
// RUN: %clang_cl_asan -Od %s -Fe%t && %t
is a little bit more convenient for copying reproducer line from failed test output

18–32

please clang-format

[mcgov]

nit, style fix

[mcgov]

Thank you Vitaly! I'm going to wait on a review from @mstorsjo to land this

[mstorsjo]

Seems to build fine in my configs, so no objections from me - thanks for looping me in!

[mcgov]

landed https://github.com/llvm/llvm-project/commit/81b1d3da094c54ffd75e05c8d4683792edf17f4c

compiler-rt/lib/sanitizer_common/sanitizer_allocator_primary64.h

public:
 
   NOINLINE bool GetFromAllocator(AllocatorStats *stat, uptr class_id,
                                  CompactPtrT *chunks, uptr n_chunks) {
     RegionInfo *region = GetRegionInfo(class_id);
     uptr region_beg = GetRegionBeginBySizeClass(class_id);
     CompactPtrT *free_array = GetFreeArray(region_beg);
 
     BlockingMutexLock l(&region->mutex);
+#if SANITIZER_WINDOWS
+    /* On Windows unmapping of memory during __sanitizer_purge_allocator is
+    explicit and immediate, so unmapped regions must be explicitly mapped back
+    in when they are accessed again. */
+    if (region->rtoi.last_released_bytes > 0) {
+      MmapFixedOrDie(region_beg, region->mapped_user,
+                                      "SizeClassAllocator: region data");
+      region->rtoi.n_freed_at_last_release = 0;
+      region->rtoi.last_released_bytes = 0;
+    }
+#endif
     if (UNLIKELY(region->num_freed_chunks < n_chunks)) {
       if (UNLIKELY(!PopulateFreeArray(stat, class_id, region,
                                       n_chunks - region->num_freed_chunks)))
         return false;
       CHECK_GE(region->num_freed_chunks, n_chunks);
     }
     region->num_freed_chunks -= n_chunks;
     uptr base_idx = region->num_freed_chunks;

compiler-rt/lib/sanitizer_common/sanitizer_win.cpp

 }
 
 bool MprotectNoAccess(uptr addr, uptr size) {
   DWORD old_protection;
   return VirtualProtect((LPVOID)addr, size, PAGE_NOACCESS, &old_protection);
 }
 
 void ReleaseMemoryPagesToOS(uptr beg, uptr end) {
-  // This is almost useless on 32-bits.
-  // FIXME: add madvise-analog when we move to 64-bits.
+  uptr beg_aligned, end_aligned;
+  beg_aligned = RoundDownTo(beg, GetPageSizeCached());
+  end_aligned = RoundDownTo(end, GetPageSizeCached());
+  CHECK(beg < end);                // make sure the region is sane
+  if (beg_aligned == end_aligned)  // make sure we're freeing at least 1 page;
+    return;
+  UnmapOrDie((void *)beg, end_aligned - beg_aligned);
 }
 
 void SetShadowRegionHugePageMode(uptr addr, uptr size) {
   // FIXME: probably similar to ReleaseMemoryToOS.
 }
 
 bool DontDumpShadowMemory(uptr addr, uptr length) {
   // This is almost useless on 32-bits.
   // FIXME: add madvise-analog when we move to 64-bits.

compiler-rt/test/asan/TestCases/Windows/sanitizer_purge.cpp

+#include <Windows.h>
+#include <stdio.h>
+#include <sanitizer/allocator_interface.h>
+#include <psapi.h>
+
+// RUN: %clang_cl_asan -Od %s -Fe%t 
+// RUN: %t
+
+size_t GetRSS() {
+  PROCESS_MEMORY_COUNTERS counters;
+  if (!GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters)))
+    return 0;
+  return counters.WorkingSetSize;
+}
+
+int main(){
+    for (int i = 0; i < 1000; i++) {
+        void* a = malloc(1000);
+        free(a);
+    }
+    size_t rss_pre  = GetRSS();
+    __sanitizer_purge_allocator();
+    size_t rss_post = GetRSS();
+
+    if (rss_pre <= rss_post){
+        return -1;
+    }
+
+    return 0;
+}
 No newline at end of file