[lsan] Handle fork() correctly.

[earthdok]

Summary

Update the main thread's os_id on every pthread_create, and before
initiating leak checking. This ensures that we have the correct os_id even if we
have forked after Init(). Not sure of the performance implications for
pthread_create, but this is more robust than intercepting fork() since this
scheme handles fork by syscall too.

[samsonov]

Can you please clarify why we it is necessary to ensure correct os_id before pthread_create?

lib/asan/asan_interceptors.cc

141

Please add this to CreateThread() interceptor as well.

lib/asan/asan_thread.cc

259

static_cast here for consistency.

lib/asan/asan_thread.h

127

I think the comment needs to be more explicit.

[earthdok]

lib/asan/asan_interceptors.cc

141

As discussed offline, this is not needed since fork() without exec() does not have a Windows equivalent.

lib/asan/asan_thread.cc

259

Actually this needs a reinterpret_cast. Also fixed in GetCurrentThread().

lib/asan/asan_thread.h

127

fixed

lib/asan/asan_interceptors.cc

static thread_return_t THREAD_CALLING_CONV asan_thread_start(void *arg) {
   return t->ThreadStart(GetTid());
 }
 
 #if ASAN_INTERCEPT_PTHREAD_CREATE
 extern "C" int pthread_attr_getdetachstate(void *attr, int *v);
 
 INTERCEPTOR(int, pthread_create, void *thread,
     void *attr, void *(*start_routine)(void*), void *arg) {
+  EnsureMainThreadIsCorrect();
   // Strict init-order checking in thread-hostile.
   if (flags()->strict_init_order)
     StopInitOrderChecking();
   GET_STACK_TRACE_THREAD;
   int detached = 0;
   if (attr != 0)
     pthread_attr_getdetachstate(attr, &detached);
 

lib/asan/asan_thread.h

 AsanThreadContext *GetThreadContextByTidLocked(u32 tid);
 
 // Get the current thread. May return 0.
 AsanThread *GetCurrentThread();
 void SetCurrentThread(AsanThread *t);
 u32 GetCurrentTidOrInvalid();
 AsanThread *FindThreadByStackAddress(uptr addr);
 
+// Used to handle fork().
+void EnsureMainThreadIsCorrect();
 }  // namespace __asan
 
 #endif  // ASAN_THREAD_H

lib/asan/asan_thread.cc

 
 AsanThread *FindThreadByStackAddress(uptr addr) {
   asanThreadRegistry().CheckLocked();
   AsanThreadContext *tctx = static_cast<AsanThreadContext *>(
       asanThreadRegistry().FindThreadContextLocked(ThreadStackContainsAddress,
                                                    (void *)addr));
   return tctx ? tctx->thread : 0;
 }
+
+void EnsureMainThreadIsCorrect() {
+  AsanThreadContext *context = (AsanThreadContext*)AsanTSDGet();
+  if (context && (context->tid == 0))
+    context->os_id = GetTid();
+}
 }  // namespace __asan
 
 // --- Implementation of LSan-specific functions --- {{{1
 namespace __lsan {
 bool GetThreadRangesLocked(uptr os_id, uptr *stack_begin, uptr *stack_end,
                            uptr *tls_begin, uptr *tls_end,
                            uptr *cache_begin, uptr *cache_end) {
   __asan::AsanThreadContext *context = static_cast<__asan::AsanThreadContext *>(

 
 void LockThreadRegistry() {
   __asan::asanThreadRegistry().Lock();
 }
 
 void UnlockThreadRegistry() {
   __asan::asanThreadRegistry().Unlock();
 }
+
+void EnsureMainThreadIsCorrect() {
+  __asan::EnsureMainThreadIsCorrect();
+}
 }  // namespace __lsan

lib/lsan/lit_tests/TestCases/fork.cc

+// Test that thread local data is handled correctly after forking without exec().
+// RUN: %clangxx_lsan %s -o %t
+// RUN: %t 2>&1
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+__thread void *thread_local_var;
+
+int main() {
+  int status = 0;
+  thread_local_var = malloc(1337);
+  pid_t pid = fork();
+  assert(pid >= 0);
+  if (pid > 0) {
+    waitpid(pid, &status, 0);
+    assert(WIFEXITED(status));
+    return WEXITSTATUS(status);
+  }
+  return 0;
+}

lib/lsan/lit_tests/TestCases/fork_threaded.cc

+// Test that thread local data is handled correctly after forking without
+// exec(). In this test leak checking is initiated from a non-main thread.
+// RUN: %clangxx_lsan %s -o %t
+// RUN: %t 2>&1
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+__thread void *thread_local_var;
+
+void *exit_thread_func(void *arg) {
+  exit(0);
+}
+
+void ExitFromThread() {
+  pthread_t tid;
+  int res;
+  res = pthread_create(&tid, 0, exit_thread_func, 0);
+  assert(res == 0);
+  res = pthread_join(tid, 0);
+  assert(res == 0);
+}
+
+int main() {
+  int status = 0;
+  thread_local_var = malloc(1337);
+  pid_t pid = fork();
+  assert(pid >= 0);
+  if (pid > 0) {
+    waitpid(pid, &status, 0);
+    assert(WIFEXITED(status));
+    return WEXITSTATUS(status);
+  } else {
+    // Spawn a thread and call exit() from there, to check that we track main
+    // thread's pid correctly even if leak checking is initiated from another
+    // thread.
+    ExitFromThread();
+  }
+  return 0;
+}

lib/lsan/lsan_common.h

 void LockAllocator();
 void UnlockAllocator();
 // Wrappers for ThreadRegistry access.
 void LockThreadRegistry();
 void UnlockThreadRegistry();
 bool GetThreadRangesLocked(uptr os_id, uptr *stack_begin, uptr *stack_end,
                            uptr *tls_begin, uptr *tls_end,
                            uptr *cache_begin, uptr *cache_end);
+// Needed to handle forked processed.
+void EnsureMainThreadIsCorrect();
 // If p points into a chunk that has been allocated to the user, returns its
 // user-visible address. Otherwise, returns 0.
 uptr PointsIntoChunk(void *p);
 // Returns address of user-visible chunk contained in this allocator chunk.
 uptr GetUserBegin(uptr chunk);
 // Helper for __lsan_ignore_object().
 IgnoreObjectResult IgnoreObjectLocked(const void *p);
 // Wrapper for chunk metadata operations.

lib/lsan/lsan_common.cc

static void DoLeakCheckCallback(const SuspendedThreadsList &suspended_threads,
   ClassifyAllChunks(suspended_threads);
   ForEachChunk(CollectLeaksCb, &param->leak_report);
   if (!param->leak_report.IsEmpty() && flags()->report_objects)
     PrintLeaked();
   param->success = true;
 }
 
 void DoLeakCheck() {
+  EnsureMainThreadIsCorrect();
   BlockingMutexLock l(&global_mutex);
   static bool already_done;
   CHECK(!already_done);
   already_done = true;
   if (&__lsan_is_turned_off && __lsan_is_turned_off())
     return;
 
   DoLeakCheckParam param;

lib/lsan/lsan_interceptors.cc

extern "C" void *__lsan_thread_start_func(void *arg) {
   SetCurrentThread(tid);
   ThreadStart(tid, GetTid());
   return callback(param);
 }
 
 INTERCEPTOR(int, pthread_create, void *th, void *attr,
             void *(*callback)(void *), void *param) {
   Init();
+  EnsureMainThreadIsCorrect();
   __sanitizer_pthread_attr_t myattr;
   if (attr == 0) {
     pthread_attr_init(&myattr);
     attr = &myattr;
   }
   AdjustStackSizeLinux(attr, 0);
   int detached = 0;
   pthread_attr_getdetachstate(attr, &detached);

lib/lsan/lsan_thread.h

 void ThreadFinish();
 u32 ThreadCreate(u32 tid, uptr uid, bool detached);
 void ThreadJoin(u32 tid);
 u32 ThreadTid(uptr uid);
 
 u32 GetCurrentThread();
 void SetCurrentThread(u32 tid);
 ThreadContext *CurrentThreadContext();
-
+void EnsureMainThreadIsCorrect();
 }  // namespace __lsan
 
 #endif  // LSAN_THREAD_H

lib/lsan/lsan_thread.cc

u32 ThreadTid(uptr uid) {
   return thread_registry->FindThread(FindThreadByUid, (void*)uid);
 }
 
 void ThreadJoin(u32 tid) {
   CHECK_NE(tid, kInvalidTid);
   thread_registry->JoinThread(tid, /* arg */0);
 }
 
+void EnsureMainThreadIsCorrect() {
+  if (GetCurrentThread() == 0)
+    CurrentThreadContext()->os_id = GetTid();
+}
+
 ///// Interface to the common LSan module. /////
 
 bool GetThreadRangesLocked(uptr os_id, uptr *stack_begin, uptr *stack_end,
                            uptr *tls_begin, uptr *tls_end,
                            uptr *cache_begin, uptr *cache_end) {
   ThreadContext *context = static_cast<ThreadContext *>(
       thread_registry->FindThreadContextByOsIDLocked(os_id));
   if (!context) return false;