[tsan] Refactor Memory Release Functions.

[charco]

Summary

This commit refactors calls to ReleaseMemoryPagesToOS into calls to
ReleaseTSANPages, and unmap/map to zero fill memory into ZeroPages.

This is in preparation for porting TSAN for Fuchsia: fuchsia doesn't
implement ReleaseMemoryPagesToOS, so we cannot call it directly.
Instead we will call an internal function that is able to only return
memory used for the tsan data structures (shadow, meta-shadow and
traces).

[charco]

Fix ptrdiff error.

[charco]

wrong argument order.

[mcgrathr]

I'm not sure this is the optimal refactor ultimately, but it seems like a safe and clean pure refactor that's at least an incremental cleanup in expressing what the APIs are being used for.

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

125

This is the conservative change as a pure refactor. But on any POSIX system the munmap is superfluous before overmapping with MAP_FIXED so this call could be dropped.

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

36

Perhaps a comment that this is only used by TSan and TSan doesn't support Windows.

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

void OnUnmap(uptr p, uptr size) const {
     if (diff != 0) {
       p += diff;
       size -= diff;
     }
     diff = p + size - RoundDown(p + size, kPageSize);
     if (diff != 0)
       size -= diff;
     uptr p_meta = (uptr)MemToMeta(p);
-    ReleaseMemoryPagesToOS(p_meta, p_meta + size / kMetaRatio);
+    ReleaseTSANPages(p_meta, size / kMetaRatio);
   }
 };
 
 static char allocator_placeholder[sizeof(Allocator)] ALIGNED(64);
 Allocator *allocator() {
   return reinterpret_cast<Allocator*>(&allocator_placeholder);
 }
 

compiler-rt/lib/tsan/rtl/tsan_platform.h

 
 int call_pthread_cancel_with_cleanup(int(*fn)(void *c, void *m,
     void *abstime), void *c, void *m, void *abstime,
     void(*cleanup)(void *arg), void *arg);
 
 void DestroyThreadState();
 void PlatformCleanUpThreadState(ThreadState *thr);
 
+void ZeroPages(uptr addr, uptr size);
+void ReleaseTSANPages(uptr addr, uptr size);
+
 }  // namespace __tsan
 
 #endif  // TSAN_PLATFORM_H

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

internal_snprintf(buf, buf_size,
       stacks->allocated >> 20, stacks->n_uniq_ids,
       nlive, nthread);
 }
 
 #if SANITIZER_LINUX
 void FlushShadowMemoryCallback(
     const SuspendedThreadsList &suspended_threads_list,
     void *argument) {
-  ReleaseMemoryPagesToOS(ShadowBeg(), ShadowEnd());
+  ReleaseTSANPages(ShadowBeg(), ShadowEnd() - ShadowBeg());
 }
 #endif
 
 void FlushShadowMemory() {
 #if SANITIZER_LINUX
   StopTheWorld(FlushShadowMemoryCallback, 0);
 #endif
 }

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

#endif
   // Protect the whole range for now, so that user does not map something here.
   ProtectRange(TraceMemBeg(), TraceMemEnd());
   ProtectRange(TraceMemEnd(), HeapMemBeg());
   ProtectRange(HeapEnd(), HiAppMemBeg());
 #endif
 }
 #endif
 
+void ZeroPages(uptr addr, uptr size) {
+  UnmapOrDie((void*)addr, size);
+  if (!MmapFixedSuperNoReserve(addr, size))
+    Die();
+}
+
+void ReleaseTSANPages(uptr addr, uptr size) {
+  ReleaseMemoryPagesToOS(addr, addr + size);
+}
+
 }  // namespace __tsan
 
 #endif  // SANITIZER_POSIX

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

 }
 
 void InitializePlatformEarly() {
 }
 
 void InitializePlatform() {
 }
 
+void ZeroPages(uptr addr, uptr size) {
+  // Unimplemented.
+  __builtin_trap();
+}
+
+void ReleaseTSANPages(uptr addr, uptr size) {
+  ReleaseMemoryPagesToOS(addr, addr + size);
+}
+
 }  // namespace __tsan
 
 #endif  // SANITIZER_WINDOWS

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

static void StopBackgroundThread() {
   atomic_store(&ctx->stop_background_thread, 1, memory_order_relaxed);
   internal_join_thread(ctx->background_thread);
   ctx->background_thread = 0;
 }
 #endif
 #endif
 
 void DontNeedShadowFor(uptr addr, uptr size) {
-  ReleaseMemoryPagesToOS(MemToShadow(addr), MemToShadow(addr + size));
+  ReleaseTSANPages(MemToShadow(addr),
+                   MemToShadow(addr + size) - MemToShadow(addr));
 }
 
 #if !SANITIZER_GO
 void UnmapShadow(ThreadState *thr, uptr addr, uptr size) {
   if (size == 0) return;
   DontNeedShadowFor(addr, size);
   ScopedGlobalProcessor sgp;
   ctx->metamap.ResetRange(thr->proc(), addr, size);
if (SANITIZER_WINDOWS || size < common_flags()->clear_shadow_mmap_threshold) {
     u64 *p = begin;
     // Set at least first kPageSize/2 to page boundary.
     while ((p < begin + kPageSize / kShadowSize / 2) || ((uptr)p % kPageSize)) {
       *p++ = val;
       for (uptr j = 1; j < kShadowCnt; j++)
         *p++ = 0;
     }
     // Reset middle part.
-    u64 *p1 = p;
+    uptr p1 = reinterpret_cast<uptr>(p);
     p = RoundDown(end, kPageSize);
-    UnmapOrDie((void*)p1, (uptr)p - (uptr)p1);
-    if (!MmapFixedSuperNoReserve((uptr)p1, (uptr)p - (uptr)p1))
-      Die();
+
+    ZeroPages(p1, reinterpret_cast<uptr>(p) - p1);
+
     // Set the ending.
     while (p < end) {
       *p++ = val;
       for (uptr j = 1; j < kShadowCnt; j++)
         *p++ = 0;
     }
   }
 }

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

void ThreadContext::OnCreated(void *arg) {
   creation_stack_id = CurrentStackId(args->thr, args->pc);
   if (reuse_count == 0)
     StatInc(args->thr, StatThreadMaxTid);
 }
 
 void ThreadContext::OnReset() {
   CHECK_EQ(sync.size(), 0);
   uptr trace_p = GetThreadTrace(tid);
-  ReleaseMemoryPagesToOS(trace_p, trace_p + TraceSize() * sizeof(Event));
-  //!!! ReleaseMemoryToOS(GetThreadTraceHeader(tid), sizeof(Trace));
+  ReleaseTSANPages(trace_p, TraceSize() * sizeof(Event));
 }
 
 void ThreadContext::OnDetached(void *arg) {
   ThreadState *thr1 = static_cast<ThreadState*>(arg);
   sync.Reset(&thr1->proc()->clock_cache);
 }
 
 struct OnStartedArgs {

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

if (!has_something && checked > (512 << 10))
       break;
   }
   // Finally, page out the whole range (including the parts that we've just
   // freed). Note: we can't simply madvise, because we need to leave a zeroed
   // range (otherwise __tsan_java_move can crash if it encounters a left-over
   // meta objects in java heap).
   uptr metap = (uptr)MemToMeta(p0);
   uptr metasz = sz0 / kMetaRatio;
-  UnmapOrDie((void*)metap, metasz);
-  if (!MmapFixedSuperNoReserve(metap, metasz))
-    Die();
+  ZeroPages(metap, metasz);
 }
 
 MBlock* MetaMap::GetBlock(uptr p) {
   u32 *meta = MemToMeta(p);
   u32 idx = *meta;
   for (;;) {
     if (idx == 0)
       return 0;