Issue 3406 - [Adblock Browser for Android] Crash after updating to Android 6.0.1

xpcom/threads/ThreadStackHelper.cpp

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "ThreadStackHelper.h"
 #include "MainThreadUtils.h"
 #include "nsJSPrincipals.h"
 #include "nsScriptSecurityManager.h"
 #include "jsfriendapi.h"
+#include "prprf.h"
 #ifdef MOZ_THREADSTACKHELPER_NATIVE
 #include "shared-libraries.h"
 #endif
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/IntegerPrintfMacros.h"
 #include "mozilla/Move.h"
 #include "mozilla/Scoped.h"
 #include "mozilla/UniquePtr.h"
 #include "mozilla/MemoryChecking.h"
-#include "mozilla/Snprintf.h"
-
-#ifdef __GNUC__
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wshadow"
+
+#ifdef MOZ_THREADSTACKHELPER_NATIVE
+#include "google_breakpad/processor/call_stack.h"
+#include "google_breakpad/processor/basic_source_line_resolver.h"
+#include "google_breakpad/processor/stack_frame_cpu.h"
+#include "processor/basic_code_module.h"
+#include "processor/basic_code_modules.h"
+#endif
+
+#if defined(MOZ_THREADSTACKHELPER_X86)
+#include "processor/stackwalker_x86.h"
+#elif defined(MOZ_THREADSTACKHELPER_X64)
+#include "processor/stackwalker_amd64.h"
+#elif defined(MOZ_THREADSTACKHELPER_ARM)
+#include "processor/stackwalker_arm.h"
 #endif
 
 #if defined(MOZ_VALGRIND)
 # include <valgrind/valgrind.h>
 #endif
 
 #include <string.h>
 #include <vector>
-#include <cstdlib>
 
 #ifdef XP_LINUX
 #ifdef ANDROID
 // Android NDK doesn't contain ucontext.h; use Breakpad's copy.
 # include "common/android/include/sys/ucontext.h"
 #else
 # include <ucontext.h>
 #endif
 #include <unistd.h>
 #include <sys/syscall.h>
-#endif
-
-#ifdef __GNUC__
-# pragma GCC diagnostic pop // -Wshadow
 #endif
 
 #if defined(XP_LINUX) || defined(XP_MACOSX)
 #include <pthread.h>
 #endif
 
 #ifdef ANDROID
 #ifndef SYS_gettid
 #define SYS_gettid __NR_gettid
 #endif
@@ skipping 142 matching lines @@
 namespace {
 template<typename T>
 class ScopedSetPtr
 {
 private:
   T*& mPtr;
 public:
   ScopedSetPtr(T*& p, T* val) : mPtr(p) { mPtr = val; }
   ~ScopedSetPtr() { mPtr = nullptr; }
 };
-} // namespace
+}
 
 void
 ThreadStackHelper::GetStack(Stack& aStack)
 {
   // Always run PrepareStackBuffer first to clear aStack
   if (!PrepareStackBuffer(aStack)) {
     // Skip and return empty aStack
     return;
   }
 
@@ skipping 49 matching lines @@
 
   FillStackBuffer();
   FillThreadContext();
 
   MOZ_ALWAYS_TRUE(::thread_resume(mThreadID) == KERN_SUCCESS);
 
 #endif
 }
 
 #ifdef MOZ_THREADSTACKHELPER_NATIVE
+class ThreadStackHelper::CodeModulesProvider
+  : public google_breakpad::CodeModules
+{
+private:
+  typedef google_breakpad::CodeModule CodeModule;
+  typedef google_breakpad::BasicCodeModule BasicCodeModule;
+
+  const SharedLibraryInfo mLibs;
+  mutable ScopedDeletePtr<BasicCodeModule> mModule;
+
+public:
+  CodeModulesProvider() : mLibs(SharedLibraryInfo::GetInfoForSelf()) {}
+  virtual ~CodeModulesProvider() {}
+
+  virtual unsigned int module_count() const
+  {
+    return mLibs.GetSize();
+  }
+
+  virtual const CodeModule* GetModuleForAddress(uint64_t aAddress) const
+  {
+    MOZ_CRASH("Not implemented");
+  }
+
+  virtual const CodeModule* GetMainModule() const
+  {
+    return nullptr;
+  }
+
+  virtual const CodeModule* GetModuleAtSequence(unsigned int aSequence) const
+  {
+    MOZ_CRASH("Not implemented");
+  }
+
+  virtual const CodeModule* GetModuleAtIndex(unsigned int aIndex) const
+  {
+    const SharedLibrary& lib = mLibs.GetEntry(aIndex);
+    mModule = new BasicCodeModule(lib.GetStart(), lib.GetEnd() - lib.GetStart(),
+                                  lib.GetName(), lib.GetBreakpadId(),
+                                  lib.GetName(), lib.GetBreakpadId(), "");
+    // Keep mModule valid until the next GetModuleAtIndex call.
+    return mModule;
+  }
+
+  virtual const CodeModules* Copy() const
+  {
+    MOZ_CRASH("Not implemented");
+  }
+};
+
 class ThreadStackHelper::ThreadContext final
+  : public google_breakpad::MemoryRegion
 {
 public:
-  // TODO: provide per-platform definition of Context.
-  typedef struct {} Context;
-
+#if defined(MOZ_THREADSTACKHELPER_X86)
+  typedef MDRawContextX86 Context;
+#elif defined(MOZ_THREADSTACKHELPER_X64)
+  typedef MDRawContextAMD64 Context;
+#elif defined(MOZ_THREADSTACKHELPER_ARM)
+  typedef MDRawContextARM Context;
+#endif
   // 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) {}
+  virtual ~ThreadContext() {}
+
+  virtual uint64_t GetBase() const { return uint64_t(mStackBase); }
+  virtual uint32_t GetSize() const { return mStackSize; }
+  virtual bool GetMemoryAtAddress(uint64_t aAddress, uint8_t* aValue) const
+  {
+    return GetMemoryAtAddressInternal(aAddress, aValue);
+  }
+  virtual bool GetMemoryAtAddress(uint64_t aAddress, uint16_t* aValue) const
+  {
+    return GetMemoryAtAddressInternal(aAddress, aValue);
+  }
+  virtual bool GetMemoryAtAddress(uint64_t aAddress, uint32_t* aValue) const
+  {
+    return GetMemoryAtAddressInternal(aAddress, aValue);
+  }
+  virtual bool GetMemoryAtAddress(uint64_t aAddress, uint64_t* aValue) const
+  {
+    return GetMemoryAtAddressInternal(aAddress, aValue);
+  }
+
+private:
+  template<typename T>
+  bool GetMemoryAtAddressInternal(uint64_t aAddress, T* aValue) const
+  {
+    const intptr_t offset = intptr_t(aAddress) - intptr_t(GetBase());
+    if (offset < 0 || uintptr_t(offset) > (GetSize() - sizeof(T))) {
+      return false;
+    }
+    *aValue = *reinterpret_cast<const T*>(&mStack[offset]);
+    return true;
+  }
 };
 #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;
 int ThreadStackHelper::sFillStackSignum;
 
 void
 ThreadStackHelper::FillStackHandler(int aSignal, siginfo_t* aInfo,
@@ skipping 117 matching lines @@
     }
     if (!basename) {
       // If the (add-on) script is located under the {profile}/extensions
       // directory, extract the path after the /extensions/ part.
       basename = GetPathAfterComponent(filename, "/extensions/");
     }
     if (!basename) {
       // Only keep the file base name for paths outside the above formats.
       basename = strrchr(filename, '/');
       basename = basename ? basename + 1 : filename;
-      // Look for Windows path separator as well.
-      filename = strrchr(basename, '\\');
-      if (filename) {
-        basename = filename + 1;
-      }
-    }
-
-    size_t len = snprintf_literal(buffer, "%s:%u", basename, lineno);
+    }
+
+    size_t len = PR_snprintf(buffer, sizeof(buffer), "%s:%u", basename, lineno);
     if (len < sizeof(buffer)) {
       if (mStackToFill->IsSameAsEntry(aPrevLabel, buffer)) {
         return aPrevLabel;
       }
 
       // Keep track of the required buffer size
       aAvailableBufferSize -= (len + 1);
       if (aAvailableBufferSize >= 0) {
         // Buffer is big enough.
         return mStackToFill->InfallibleAppendViaBuffer(buffer, len);
@@ skipping 67 matching lines @@
 }
 
 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];
@@ skipping 137 matching lines @@
   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
-