Commit 38fd1806 authored by Roland McGrath's avatar Roland McGrath Committed by Petr Hosek
Browse files

[lsan] Factor pthread-specific assumptions out of thread tracking code 

This is a small refactoring to prepare for porting LSan to Fuchsia.
Factor out parts of lsan_thread.{cpp,h} that don't apply to Fuchsia.
Since existing supported systems are POSIX-based, the affected code
is moved to lsan_posix.{cpp.h}.

Patch By: mcgrathr

Differential Revision: https://reviews.llvm.org/D73309
parent aae707cd

compiler-rt/lib/lsan/CMakeLists.txt

+2 −1
Original line number Diff line number Diff line
@@ -12,10 +12,11 @@ set(LSAN_COMMON_SOURCES 
set(LSAN_SOURCES

  lsan.cpp

  lsan_allocator.cpp

  lsan_linux.cpp

  lsan_interceptors.cpp

  lsan_linux.cpp

  lsan_mac.cpp

  lsan_malloc_mac.cpp

  lsan_posix.cpp

  lsan_preinit.cpp

  lsan_thread.cpp

  )

compiler-rt/lib/lsan/lsan.cpp

+1 −4
Original line number Diff line number Diff line
@@ -114,10 +114,7 @@ extern "C" void __lsan_init() { 
  InitializeInterceptors();

  InitializeThreadRegistry();

  InstallDeadlySignalHandlers(LsanOnDeadlySignal);

  u32 tid = ThreadCreate(0, 0, true);

  CHECK_EQ(tid, 0);

  ThreadStart(tid, GetTid());

  SetCurrentThread(tid);

  InitializeMainThread();



  if (common_flags()->detect_leaks && common_flags()->leak_check_at_exit)

    Atexit(DoLeakCheck);

compiler-rt/lib/lsan/lsan.h

+3 −0
Original line number Diff line number Diff line
@@ -12,6 +12,9 @@ 
//===----------------------------------------------------------------------===//



#include "lsan_thread.h"

#if SANITIZER_POSIX

#include "lsan_posix.h"

#endif

#include "sanitizer_common/sanitizer_flags.h"

#include "sanitizer_common/sanitizer_stacktrace.h"

compiler-rt/lib/lsan/lsan_interceptors.cpp

+2 −1
Original line number Diff line number Diff line
@@ -22,7 +22,9 @@ 
#include "sanitizer_common/sanitizer_platform_interceptors.h"

#include "sanitizer_common/sanitizer_platform_limits_netbsd.h"

#include "sanitizer_common/sanitizer_platform_limits_posix.h"

#if SANITIZER_POSIX

#include "sanitizer_common/sanitizer_posix.h"

#endif

#include "sanitizer_common/sanitizer_tls_get_addr.h"

#include "lsan.h"

#include "lsan_allocator.h"
@@ -416,7 +418,6 @@ extern "C" void *__lsan_thread_start_func(void *arg) { 
  int tid = 0;

  while ((tid = atomic_load(&p->tid, memory_order_acquire)) == 0)

    internal_sched_yield();

  SetCurrentThread(tid);

  ThreadStart(tid, GetTid());

  atomic_store(&p->tid, 0, memory_order_release);

  return callback(param);

compiler-rt/lib/lsan/lsan_posix.cpp

0 → 100644
+85 −0
Original line number Diff line number Diff line 
//=-- lsan_posix.cpp -----------------------------------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===---------------------------------------------------------------------===//

//

// This file is a part of LeakSanitizer.

// Standalone LSan RTL code common to POSIX-like systems.

//

//===---------------------------------------------------------------------===//



#include "sanitizer_common/sanitizer_platform.h"



#if SANITIZER_POSIX

#include "lsan.h"

#include "lsan_allocator.h"

#include "sanitizer_common/sanitizer_stacktrace.h"

#include "sanitizer_common/sanitizer_tls_get_addr.h"



namespace __lsan {



ThreadContext::ThreadContext(int tid) : ThreadContextLsanBase(tid) {}



struct OnStartedArgs {

  uptr stack_begin;

  uptr stack_end;

  uptr cache_begin;

  uptr cache_end;

  uptr tls_begin;

  uptr tls_end;

  DTLS *dtls;

};



void ThreadContext::OnStarted(void *arg) {

  auto args = reinterpret_cast<const OnStartedArgs *>(arg);

  stack_begin_ = args->stack_begin;

  stack_end_ = args->stack_end;

  tls_begin_ = args->tls_begin;

  tls_end_ = args->tls_end;

  cache_begin_ = args->cache_begin;

  cache_end_ = args->cache_end;

  dtls_ = args->dtls;

}



void ThreadStart(u32 tid, tid_t os_id, ThreadType thread_type) {

  OnStartedArgs args;

  uptr stack_size = 0;

  uptr tls_size = 0;

  GetThreadStackAndTls(tid == 0, &args.stack_begin, &stack_size,

                       &args.tls_begin, &tls_size);

  args.stack_end = args.stack_begin + stack_size;

  args.tls_end = args.tls_begin + tls_size;

  GetAllocatorCacheRange(&args.cache_begin, &args.cache_end);

  args.dtls = DTLS_Get();

  ThreadContextLsanBase::ThreadStart(tid, os_id, thread_type, &args);

}



bool GetThreadRangesLocked(tid_t os_id, uptr *stack_begin, uptr *stack_end,

                           uptr *tls_begin, uptr *tls_end, uptr *cache_begin,

                           uptr *cache_end, DTLS **dtls) {

  ThreadContext *context = static_cast<ThreadContext *>(

      GetThreadRegistryLocked()->FindThreadContextByOsIDLocked(os_id));

  if (!context)

    return false;

  *stack_begin = context->stack_begin();

  *stack_end = context->stack_end();

  *tls_begin = context->tls_begin();

  *tls_end = context->tls_end();

  *cache_begin = context->cache_begin();

  *cache_end = context->cache_end();

  *dtls = context->dtls();

  return true;

}



void InitializeMainThread() {

  u32 tid = ThreadCreate(0, 0, true);

  CHECK_EQ(tid, 0);

  ThreadStart(tid, GetTid());

}



}  // namespace __lsan



#endif  // SANITIZER_POSIX