[lsan] Do not check for leaks in the forked process

[vitalybuka]

Summary

If calling process had threads forked process will fail to detect references
from them.

Fixes https://github.com/google/sanitizers/issues/836

[vitalybuka]

typo

[vitalybuka]

test cleanup

[alekseyshl]

compiler-rt/lib/lsan/lsan_common.cc

577

It might be a good idea to print something to the log explaining that lsan is pretty much disabled. On the other hand, not sure how spammy that would be. Up to you.

[vitalybuka]

warning

[vitalybuka]

It was reverted. But I am not planing to work on this soon.

compiler-rt/lib/lsan/lsan_common.cc

 
 static SuppressionContext *GetSuppressionContext() {
   CHECK(suppression_ctx);
   return suppression_ctx;
 }
 
 static InternalMmapVector<RootRegion> *root_regions;
 
+static uptr initialized_for_pid;
+
 InternalMmapVector<RootRegion> const *GetRootRegions() { return root_regions; }
 
 void InitializeRootRegions() {
   CHECK(!root_regions);
   ALIGNED(64) static char placeholder[sizeof(InternalMmapVector<RootRegion>)];
   root_regions = new (placeholder) InternalMmapVector<RootRegion>();  // NOLINT
 }
 
 const char *MaybeCallLsanDefaultOptions() {
   return (&__lsan_default_options) ? __lsan_default_options() : "";
 }
 
 void InitCommonLsan() {
+  initialized_for_pid = internal_getpid();
   InitializeRootRegions();
   if (common_flags()->detect_leaks) {
     // Initialization which can fail or print warnings should only be done if
     // LSan is actually enabled.
     InitializeSuppressions();
     InitializePlatformSpecificModules();
   }
 }
static void CheckForLeaksCallback(const SuspendedThreadsList &suspended_threads,
   // kIgnored tags.
   ForEachChunk(ResetTagsCb, nullptr);
   param->success = true;
 }
 
 static bool CheckForLeaks() {
   if (&__lsan_is_turned_off && __lsan_is_turned_off())
       return false;
+  // If process was forked and it had threads we do meaningfull leak checks.
+  if (initialized_for_pid != internal_getpid())
+    return false;
   EnsureMainThreadIDIsCorrect();
   CheckForLeaksParam param;
   param.success = false;
   LockThreadRegistry();
   LockAllocator();
   DoStopTheWorld(CheckForLeaksCallback, &param);
   UnlockAllocator();
   UnlockThreadRegistry();
 

compiler-rt/test/lsan/TestCases/Linux/fork_with_threads.cc

+// Test forked thread does not run lsan.
+// RUN: %clangxx_lsan %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+static pthread_barrier_t barrier;
+
+// CHECK-NOT: SUMMARY: {{(Leak|Address)}}Sanitizer:
+void *thread_func(void *arg) {
+  void *buffer = malloc(1337);
+  pthread_barrier_wait(&barrier);
+  for (;;)
+    pthread_yield();
+  return 0;
+}
+
+int main() {
+  pthread_barrier_init(&barrier, 0, 2);
+  pthread_t tid;
+  int res = pthread_create(&tid, 0, thread_func, 0);
+  pthread_barrier_wait(&barrier);
+  pid_t pid = fork();
+  pthread_barrier_destroy(&barrier);
+  printf("OK\n");
+  return 0;
+}
+// CHECK: OK