[hwasan] Madvise away unused shadow.

[eugenis]

Summary

Whenever a large shadow region is tagged to zero, madvise(DONT_NEED)
as much of it as possible.

This reduces shadow RSS on Android by 45% or so, and total memory use
by 2-4%, probably even more on long running multithreaded programs.
CPU time seems to be in the noise.

[pcc]

compiler-rt/lib/hwasan/hwasan_poisoning.cc

34–36

This code would work without the ifs, right?

[eugenis]

a test case

[pcc]

compiler-rt/test/hwasan/TestCases/Linux/release-shadow.c

35 ↗

(On Diff #182637)

Can't this just be open("/proc/self/statm", O_RDONLY);?

[eugenis]

.

[eugenis]

compiler-rt/test/hwasan/TestCases/Linux/release-shadow.c

35 ↗

(On Diff #182637)

I suppose it could.

[pcc]

LGTM

compiler-rt/lib/hwasan/hwasan.cc

SetCommonFlagsDefaults();
     cf.CopyFrom(*common_flags());
     cf.external_symbolizer_path = GetEnv("HWASAN_SYMBOLIZER_PATH");
     cf.malloc_context_size = 20;
     cf.handle_ioctl = true;
     // FIXME: test and enable.
     cf.check_printf = false;
     cf.intercept_tls_get_addr = true;
     cf.exitcode = 99;
+    // 8 shadow pages ~~ 512kB, small enough to cover common stack sizes.
+    cf.clear_shadow_mmap_threshold = 4096 * (SANITIZER_ANDROID ? 2 : 8);
     // Sigtrap is used in error reporting.
     cf.handle_sigtrap = kHandleSignalExclusive;
 
 #if SANITIZER_ANDROID
     // Let platform handle other signals. It is better at reporting them then we
     // are.
     cf.handle_segv = kHandleSignalNo;
     cf.handle_sigbus = kHandleSignalNo;

compiler-rt/lib/hwasan/hwasan_poisoning.cc

 
 namespace __hwasan {
 
 uptr TagMemoryAligned(uptr p, uptr size, tag_t tag) {
   CHECK(IsAligned(p, kShadowAlignment));
   CHECK(IsAligned(size, kShadowAlignment));
   uptr shadow_start = MemToShadow(p);
   uptr shadow_size = MemToShadowSize(size);
+
+  uptr page_size = GetPageSizeCached();
+  uptr page_start = RoundUpTo(shadow_start, page_size);
+  uptr page_end = RoundDownTo(shadow_start + shadow_size, page_size);
+  uptr threshold = common_flags()->clear_shadow_mmap_threshold;
+  if (SANITIZER_LINUX &&
+      UNLIKELY(page_end >= page_start + threshold && tag == 0)) {
+    if (page_start > shadow_start)
+      internal_memset((void *)shadow_start, tag, page_start - shadow_start);
+    if (shadow_start + shadow_size > page_end)
+      internal_memset((void *)page_end, tag,
+                      shadow_start + shadow_size - page_end);
+    // For an anonymous private mapping MADV_DONTNEED will return a zero page on
+    // Linux.
+    ReleaseMemoryPagesToOS(page_start, page_end);
+  } else {
     internal_memset((void *)shadow_start, tag, shadow_size);
+  }
   return AddTagToPointer(p, tag);
 }
 
 uptr TagMemory(uptr p, uptr size, tag_t tag) {
   uptr start = RoundDownTo(p, kShadowAlignment);
   uptr end = RoundUpTo(p + size, kShadowAlignment);
   return TagMemoryAligned(start, end - start, tag);
 }
 
 }  // namespace __hwasan