Bug 1312883 - Remove all thread context processing from ThreadStackHelper. r=jchen
☠☠ backed out by 453711cd7f0e ☠ ☠
authorMike Conley <mconley@mozilla.com>
Fri, 17 Feb 2017 17:13:57 -0500
changeset 373741 d6b3328c9573b41782a444ed610da4b71c7e0b37
parent 373740 42f0a217197da34ca4371b8f3aa32dc06249f520
child 373742 fddfc0739043abbd14d9f2099157128c7d58f143
push id10863
push userjlorenzo@mozilla.com
push dateMon, 06 Mar 2017 23:02:23 +0000
treeherdermozilla-aurora@0931190cd725 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjchen
bugs1312883
milestone54.0a1
Bug 1312883 - Remove all thread context processing from ThreadStackHelper. r=jchen MozReview-Commit-ID: LpMSf6bSLy8
xpcom/threads/ThreadStackHelper.cpp
xpcom/threads/ThreadStackHelper.h
--- a/xpcom/threads/ThreadStackHelper.cpp
+++ b/xpcom/threads/ThreadStackHelper.cpp
@@ -59,18 +59,17 @@
 #endif
 #ifndef SYS_rt_tgsigqueueinfo
 #define SYS_rt_tgsigqueueinfo __NR_rt_tgsigqueueinfo
 #endif
 #endif
 
 #ifdef MOZ_THREADSTACKHELPER_NATIVE
 #if defined(MOZ_THREADSTACKHELPER_X86) || \
-    defined(MOZ_THREADSTACKHELPER_X64) || \
-    defined(MOZ_THREADSTACKHELPER_ARM)
+    defined(MOZ_THREADSTACKHELPER_X64)
 // On these architectures, the stack grows downwards (toward lower addresses).
 #define MOZ_THREADSTACKHELPER_STACK_GROWS_DOWN
 #else
 #error "Unsupported architecture"
 #endif
 #endif // MOZ_THREADSTACKHELPER_NATIVE
 
 namespace mozilla {
@@ -111,19 +110,16 @@ ThreadStackHelper::Shutdown()
   sInitialized--;
 #endif
 }
 
 ThreadStackHelper::ThreadStackHelper()
   : mStackToFill(nullptr)
 #ifdef MOZ_THREADSTACKHELPER_PSEUDO
   , mPseudoStack(profiler_get_pseudo_stack())
-#ifdef MOZ_THREADSTACKHELPER_NATIVE
-  , mContextToFill(nullptr)
-#endif
   , mMaxStackSize(Stack::sMaxInlineStorage)
   , mMaxBufferSize(512)
 #endif
 {
 #if defined(XP_LINUX)
   MOZ_ALWAYS_TRUE(!::sem_init(&mSem, 0, 0));
   mThreadID = ::syscall(SYS_gettid);
 #elif defined(XP_WIN)
@@ -134,72 +130,29 @@ ThreadStackHelper::ThreadStackHelper()
 #ifdef MOZ_THREADSTACKHELPER_NATIVE
     | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION
 #endif
     , FALSE, 0);
   MOZ_ASSERT(mInitialized);
 #elif defined(XP_MACOSX)
   mThreadID = mach_thread_self();
 #endif
-
-#ifdef MOZ_THREADSTACKHELPER_NATIVE
-  GetThreadStackBase();
-#endif
 }
 
 ThreadStackHelper::~ThreadStackHelper()
 {
 #if defined(XP_LINUX)
   MOZ_ALWAYS_TRUE(!::sem_destroy(&mSem));
 #elif defined(XP_WIN)
   if (mInitialized) {
     MOZ_ALWAYS_TRUE(!!::CloseHandle(mThreadID));
   }
 #endif
 }
 
-#ifdef MOZ_THREADSTACKHELPER_NATIVE
-void ThreadStackHelper::GetThreadStackBase()
-{
-  mThreadStackBase = 0;
-
-#if defined(XP_LINUX)
-  void* stackAddr;
-  size_t stackSize;
-  ::pthread_t pthr = ::pthread_self();
-  ::pthread_attr_t pthr_attr;
-  NS_ENSURE_TRUE_VOID(!::pthread_getattr_np(pthr, &pthr_attr));
-  if (!::pthread_attr_getstack(&pthr_attr, &stackAddr, &stackSize)) {
-#ifdef MOZ_THREADSTACKHELPER_STACK_GROWS_DOWN
-    mThreadStackBase = intptr_t(stackAddr) + stackSize;
-#else
-    mThreadStackBase = intptr_t(stackAddr);
-#endif
-  }
-  MOZ_ALWAYS_TRUE(!::pthread_attr_destroy(&pthr_attr));
-
-#elif defined(XP_WIN)
-  ::MEMORY_BASIC_INFORMATION meminfo = {};
-  NS_ENSURE_TRUE_VOID(::VirtualQuery(&meminfo, &meminfo, sizeof(meminfo)));
-#ifdef MOZ_THREADSTACKHELPER_STACK_GROWS_DOWN
-  mThreadStackBase = intptr_t(meminfo.BaseAddress) + meminfo.RegionSize;
-#else
-  mThreadStackBase = intptr_t(meminfo.AllocationBase);
-#endif
-
-#elif defined(XP_MACOSX)
-  ::pthread_t pthr = ::pthread_self();
-  mThreadStackBase = intptr_t(::pthread_get_stackaddr_np(pthr));
-
-#else
-  #error "Unsupported platform"
-#endif // platform
-}
-#endif // MOZ_THREADSTACKHELPER_NATIVE
-
 namespace {
 template<typename T>
 class ScopedSetPtr
 {
 private:
   T*& mPtr;
 public:
   ScopedSetPtr(T*& p, T* val) : mPtr(p) { mPtr = val; }
@@ -249,17 +202,16 @@ ThreadStackHelper::GetStack(Stack& aStac
 
   // SuspendThread is asynchronous, so the thread may still be running. Use
   // GetThreadContext to ensure it's really suspended.
   // See https://blogs.msdn.microsoft.com/oldnewthing/20150205-00/?p=44743.
   CONTEXT context;
   context.ContextFlags = CONTEXT_CONTROL;
   if (::GetThreadContext(mThreadID, &context)) {
     FillStackBuffer();
-    FillThreadContext();
   }
 
   MOZ_ALWAYS_TRUE(::ResumeThread(mThreadID) != DWORD(-1));
 
 #elif defined(XP_MACOSX)
 # if defined(MOZ_VALGRIND) && defined(RUNNING_ON_VALGRIND)
   if (RUNNING_ON_VALGRIND) {
     /* thread_suspend and thread_resume sometimes hang runs on Valgrind,
@@ -269,67 +221,28 @@ ThreadStackHelper::GetStack(Stack& aStac
 # endif
 
   if (::thread_suspend(mThreadID) != KERN_SUCCESS) {
     MOZ_ASSERT(false);
     return;
   }
 
   FillStackBuffer();
-  FillThreadContext();
 
   MOZ_ALWAYS_TRUE(::thread_resume(mThreadID) == KERN_SUCCESS);
 
 #endif
 }
 
-#ifdef MOZ_THREADSTACKHELPER_NATIVE
-class ThreadStackHelper::ThreadContext final
-{
-public:
-  // TODO: provide per-platform definition of Context.
-  typedef struct {} Context;
-
-  // Limit copied stack to 4kB
-  static const size_t kMaxStackSize = 0x1000;
-  // Limit unwound stack to 32 frames
-  static const unsigned int kMaxStackFrames = 32;
-  // Whether this structure contains valid data
-  bool mValid;
-  // Processor context
-  Context mContext;
-  // Stack area
-  UniquePtr<uint8_t[]> mStack;
-  // Start of stack area
-  uintptr_t mStackBase;
-  // Size of stack area
-  size_t mStackSize;
-  // End of stack area
-  const void* mStackEnd;
-
-  ThreadContext()
-    : mValid(false)
-    , mStackBase(0)
-    , mStackSize(0)
-    , mStackEnd(nullptr) {}
-};
-#endif // MOZ_THREADSTACKHELPER_NATIVE
-
 void
 ThreadStackHelper::GetNativeStack(Stack& aStack)
 {
 #ifdef MOZ_THREADSTACKHELPER_NATIVE
-  ThreadContext context;
-  context.mStack = MakeUnique<uint8_t[]>(ThreadContext::kMaxStackSize);
-
-  ScopedSetPtr<ThreadContext> contextPtr(mContextToFill, &context);
-
   // Get pseudostack first and fill the thread context.
   GetStack(aStack);
-  NS_ENSURE_TRUE_VOID(context.mValid);
 
   // TODO: walk the saved stack frames.
 #endif // MOZ_THREADSTACKHELPER_NATIVE
 }
 
 #ifdef XP_LINUX
 
 int ThreadStackHelper::sInitialized;
@@ -337,17 +250,16 @@ int ThreadStackHelper::sFillStackSignum;
 
 void
 ThreadStackHelper::FillStackHandler(int aSignal, siginfo_t* aInfo,
                                     void* aContext)
 {
   ThreadStackHelper* const helper =
     reinterpret_cast<ThreadStackHelper*>(aInfo->si_value.sival_ptr);
   helper->FillStackBuffer();
-  helper->FillThreadContext(aContext);
   ::sem_post(&helper->mSem);
 }
 
 #endif // XP_LINUX
 
 bool
 ThreadStackHelper::PrepareStackBuffer(Stack& aStack)
 {
@@ -522,21 +434,16 @@ ThreadStackHelper::FillStackBuffer()
        because we only want static labels in the hang stack. */
     if (entry->isCopyLabel()) {
       continue;
     }
     if (entry->isJs()) {
       prevLabel = AppendJSEntry(entry, availableBufferSize, prevLabel);
       continue;
     }
-#ifdef MOZ_THREADSTACKHELPER_NATIVE
-    if (mContextToFill) {
-      mContextToFill->mStackEnd = entry->stackAddress();
-    }
-#endif
     const char* const label = entry->label();
     if (mStackToFill->IsSameAsEntry(prevLabel, label)) {
       // Avoid duplicate labels to save space in the stack.
       continue;
     }
     mStackToFill->infallibleAppend(label);
     prevLabel = label;
   }
@@ -548,179 +455,9 @@ ThreadStackHelper::FillStackBuffer()
   // availableBufferSize < 0 if we needed a larger buffer than we reserved.
   // Calculate a new reserve size for next time.
   if (availableBufferSize < 0) {
     mMaxBufferSize = reservedBufferSize - availableBufferSize;
   }
 #endif
 }
 
-MOZ_ASAN_BLACKLIST void
-ThreadStackHelper::FillThreadContext(void* aContext)
-{
-#ifdef MOZ_THREADSTACKHELPER_NATIVE
-  if (!mContextToFill) {
-    return;
-  }
-
-#if 0 // TODO: remove dependency on Breakpad structs.
-#if defined(XP_LINUX)
-  const ucontext_t& context = *reinterpret_cast<ucontext_t*>(aContext);
-#if defined(MOZ_THREADSTACKHELPER_X86)
-  mContextToFill->mContext.context_flags = MD_CONTEXT_X86_FULL;
-  mContextToFill->mContext.edi = context.uc_mcontext.gregs[REG_EDI];
-  mContextToFill->mContext.esi = context.uc_mcontext.gregs[REG_ESI];
-  mContextToFill->mContext.ebx = context.uc_mcontext.gregs[REG_EBX];
-  mContextToFill->mContext.edx = context.uc_mcontext.gregs[REG_EDX];
-  mContextToFill->mContext.ecx = context.uc_mcontext.gregs[REG_ECX];
-  mContextToFill->mContext.eax = context.uc_mcontext.gregs[REG_EAX];
-  mContextToFill->mContext.ebp = context.uc_mcontext.gregs[REG_EBP];
-  mContextToFill->mContext.eip = context.uc_mcontext.gregs[REG_EIP];
-  mContextToFill->mContext.eflags = context.uc_mcontext.gregs[REG_EFL];
-  mContextToFill->mContext.esp = context.uc_mcontext.gregs[REG_ESP];
-#elif defined(MOZ_THREADSTACKHELPER_X64)
-  mContextToFill->mContext.context_flags = MD_CONTEXT_AMD64_FULL;
-  mContextToFill->mContext.eflags = uint32_t(context.uc_mcontext.gregs[REG_EFL]);
-  mContextToFill->mContext.rax = context.uc_mcontext.gregs[REG_RAX];
-  mContextToFill->mContext.rcx = context.uc_mcontext.gregs[REG_RCX];
-  mContextToFill->mContext.rdx = context.uc_mcontext.gregs[REG_RDX];
-  mContextToFill->mContext.rbx = context.uc_mcontext.gregs[REG_RBX];
-  mContextToFill->mContext.rsp = context.uc_mcontext.gregs[REG_RSP];
-  mContextToFill->mContext.rbp = context.uc_mcontext.gregs[REG_RBP];
-  mContextToFill->mContext.rsi = context.uc_mcontext.gregs[REG_RSI];
-  mContextToFill->mContext.rdi = context.uc_mcontext.gregs[REG_RDI];
-  memcpy(&mContextToFill->mContext.r8,
-         &context.uc_mcontext.gregs[REG_R8], 8 * sizeof(int64_t));
-  mContextToFill->mContext.rip = context.uc_mcontext.gregs[REG_RIP];
-#elif defined(MOZ_THREADSTACKHELPER_ARM)
-  mContextToFill->mContext.context_flags = MD_CONTEXT_ARM_FULL;
-  memcpy(&mContextToFill->mContext.iregs[0],
-         &context.uc_mcontext.arm_r0, 17 * sizeof(int32_t));
-#else
-  #error "Unsupported architecture"
-#endif // architecture
-
-#elif defined(XP_WIN)
-  // Breakpad context struct is based off of the Windows CONTEXT struct,
-  // so we assume they are the same; do some sanity checks to make sure.
-  static_assert(sizeof(ThreadContext::Context) == sizeof(::CONTEXT),
-                "Context struct mismatch");
-  static_assert(offsetof(ThreadContext::Context, context_flags) ==
-                offsetof(::CONTEXT, ContextFlags),
-                "Context struct mismatch");
-  mContextToFill->mContext.context_flags = CONTEXT_FULL;
-  NS_ENSURE_TRUE_VOID(::GetThreadContext(mThreadID,
-      reinterpret_cast<::CONTEXT*>(&mContextToFill->mContext)));
-
-#elif defined(XP_MACOSX)
-#if defined(MOZ_THREADSTACKHELPER_X86)
-  const thread_state_flavor_t flavor = x86_THREAD_STATE32;
-  x86_thread_state32_t state = {};
-  mach_msg_type_number_t count = x86_THREAD_STATE32_COUNT;
-#elif defined(MOZ_THREADSTACKHELPER_X64)
-  const thread_state_flavor_t flavor = x86_THREAD_STATE64;
-  x86_thread_state64_t state = {};
-  mach_msg_type_number_t count = x86_THREAD_STATE64_COUNT;
-#elif defined(MOZ_THREADSTACKHELPER_ARM)
-  const thread_state_flavor_t flavor = ARM_THREAD_STATE;
-  arm_thread_state_t state = {};
-  mach_msg_type_number_t count = ARM_THREAD_STATE_COUNT;
-#endif
-  NS_ENSURE_TRUE_VOID(KERN_SUCCESS == ::thread_get_state(
-    mThreadID, flavor, reinterpret_cast<thread_state_t>(&state), &count));
-#if __DARWIN_UNIX03
-#define GET_REGISTER(s, r) ((s).__##r)
-#else
-#define GET_REGISTER(s, r) ((s).r)
-#endif
-#if defined(MOZ_THREADSTACKHELPER_X86)
-  mContextToFill->mContext.context_flags = MD_CONTEXT_X86_FULL;
-  mContextToFill->mContext.edi = GET_REGISTER(state, edi);
-  mContextToFill->mContext.esi = GET_REGISTER(state, esi);
-  mContextToFill->mContext.ebx = GET_REGISTER(state, ebx);
-  mContextToFill->mContext.edx = GET_REGISTER(state, edx);
-  mContextToFill->mContext.ecx = GET_REGISTER(state, ecx);
-  mContextToFill->mContext.eax = GET_REGISTER(state, eax);
-  mContextToFill->mContext.ebp = GET_REGISTER(state, ebp);
-  mContextToFill->mContext.eip = GET_REGISTER(state, eip);
-  mContextToFill->mContext.eflags = GET_REGISTER(state, eflags);
-  mContextToFill->mContext.esp = GET_REGISTER(state, esp);
-#elif defined(MOZ_THREADSTACKHELPER_X64)
-  mContextToFill->mContext.context_flags = MD_CONTEXT_AMD64_FULL;
-  mContextToFill->mContext.eflags = uint32_t(GET_REGISTER(state, rflags));
-  mContextToFill->mContext.rax = GET_REGISTER(state, rax);
-  mContextToFill->mContext.rcx = GET_REGISTER(state, rcx);
-  mContextToFill->mContext.rdx = GET_REGISTER(state, rdx);
-  mContextToFill->mContext.rbx = GET_REGISTER(state, rbx);
-  mContextToFill->mContext.rsp = GET_REGISTER(state, rsp);
-  mContextToFill->mContext.rbp = GET_REGISTER(state, rbp);
-  mContextToFill->mContext.rsi = GET_REGISTER(state, rsi);
-  mContextToFill->mContext.rdi = GET_REGISTER(state, rdi);
-  memcpy(&mContextToFill->mContext.r8,
-         &GET_REGISTER(state, r8), 8 * sizeof(int64_t));
-  mContextToFill->mContext.rip = GET_REGISTER(state, rip);
-#elif defined(MOZ_THREADSTACKHELPER_ARM)
-  mContextToFill->mContext.context_flags = MD_CONTEXT_ARM_FULL;
-  memcpy(mContextToFill->mContext.iregs,
-         GET_REGISTER(state, r), 17 * sizeof(int32_t));
-#else
-  #error "Unsupported architecture"
-#endif // architecture
-#undef GET_REGISTER
-
-#else
-  #error "Unsupported platform"
-#endif // platform
-
-  intptr_t sp = 0;
-#if defined(MOZ_THREADSTACKHELPER_X86)
-  sp = mContextToFill->mContext.esp;
-#elif defined(MOZ_THREADSTACKHELPER_X64)
-  sp = mContextToFill->mContext.rsp;
-#elif defined(MOZ_THREADSTACKHELPER_ARM)
-  sp = mContextToFill->mContext.iregs[13];
-#else
-  #error "Unsupported architecture"
-#endif // architecture
-  NS_ENSURE_TRUE_VOID(sp);
-  NS_ENSURE_TRUE_VOID(mThreadStackBase);
-
-  size_t stackSize = std::min(intptr_t(ThreadContext::kMaxStackSize),
-                              std::abs(sp - mThreadStackBase));
-
-  if (mContextToFill->mStackEnd) {
-    // Limit the start of stack to a certain location if specified.
-    stackSize = std::min(intptr_t(stackSize),
-      std::abs(sp - intptr_t(mContextToFill->mStackEnd)));
-  }
-
-#ifndef MOZ_THREADSTACKHELPER_STACK_GROWS_DOWN
-  // If if the stack grows upwards, and we need to recalculate our
-  // stack copy's base address. Subtract sizeof(void*) so that the
-  // location pointed to by sp is included.
-  sp -= stackSize - sizeof(void*);
-#endif
-
-#ifndef MOZ_ASAN
-  memcpy(mContextToFill->mStack.get(), reinterpret_cast<void*>(sp), stackSize);
-  // Valgrind doesn't care about the access outside the stack frame, but
-  // the presence of uninitialised values on the stack does cause it to
-  // later report a lot of false errors when Breakpad comes to unwind it.
-  // So mark the extracted data as defined.
-  MOZ_MAKE_MEM_DEFINED(mContextToFill->mStack.get(), stackSize);
-#else
-  // ASan will flag memcpy for access outside of stack frames,
-  // so roll our own memcpy here.
-  intptr_t* dst = reinterpret_cast<intptr_t*>(&mContextToFill->mStack[0]);
-  const intptr_t* src = reinterpret_cast<intptr_t*>(sp);
-  for (intptr_t len = stackSize; len > 0; len -= sizeof(*src)) {
-    *(dst++) = *(src++);
-  }
-#endif
-
-  mContextToFill->mStackBase = uintptr_t(sp);
-  mContextToFill->mStackSize = stackSize;
-  mContextToFill->mValid = true;
-#endif
-#endif // MOZ_THREADSTACKHELPER_NATIVE
-}
-
 } // namespace mozilla
--- a/xpcom/threads/ThreadStackHelper.h
+++ b/xpcom/threads/ThreadStackHelper.h
@@ -59,37 +59,27 @@ class ThreadStackHelper
 {
 public:
   typedef Telemetry::HangStack Stack;
 
 private:
   Stack* mStackToFill;
 #ifdef MOZ_THREADSTACKHELPER_PSEUDO
   const PseudoStack* const mPseudoStack;
-#ifdef MOZ_THREADSTACKHELPER_NATIVE
-  class ThreadContext;
-  // Set to non-null if GetStack should get the thread context.
-  ThreadContext* mContextToFill;
-  intptr_t mThreadStackBase;
-#endif
   size_t mMaxStackSize;
   size_t mMaxBufferSize;
 #endif
 
   bool PrepareStackBuffer(Stack& aStack);
   void FillStackBuffer();
-  void FillThreadContext(void* aContext = nullptr);
 #ifdef MOZ_THREADSTACKHELPER_PSEUDO
   const char* AppendJSEntry(const volatile js::ProfileEntry* aEntry,
                             intptr_t& aAvailableBufferSize,
                             const char* aPrevLabel);
 #endif
-#ifdef MOZ_THREADSTACKHELPER_NATIVE
-  void GetThreadStackBase();
-#endif
 
 public:
   /**
    * Initialize ThreadStackHelper. Must be called from main thread.
    */
   static void Startup();
   /**
    * Uninitialize ThreadStackHelper. Must be called from main thread.