Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#include "ThreadStackHelper.h"
#include "MainThreadUtils.h"
#include "nsJSPrincipals.h"
#include "nsScriptSecurityManager.h"
#include "jsapi.h"
#include "jsfriendapi.h"
#ifdef MOZ_THREADSTACKHELPER_PROFILING_STACK
# include "js/ProfilingStack.h"
#endif
#include <utility>
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/BasePrincipal.h"
#include "mozilla/HangTypes.h"
#include "mozilla/IntegerPrintfMacros.h"
#include "mozilla/MemoryChecking.h"
#include "mozilla/Sprintf.h"
#include "mozilla/UniquePtr.h"
#include "nsThread.h"
#ifdef __GNUC__
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wshadow"
#endif
#if defined(MOZ_VALGRIND)
# include <valgrind/valgrind.h>
#endif
#include <string.h>
#include <vector>
#include <cstdlib>
#ifdef XP_LINUX
# include <ucontext.h>
# 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
# if defined(__arm__) && !defined(__NR_rt_tgsigqueueinfo)
// Some NDKs don't define this constant even though the kernel supports it.
# define __NR_rt_tgsigqueueinfo (__NR_SYSCALL_BASE + 363)
# endif
# ifndef SYS_rt_tgsigqueueinfo
# define SYS_rt_tgsigqueueinfo __NR_rt_tgsigqueueinfo
# endif
#endif
namespace mozilla {
// A character which we append to any string which gets truncated as a a
// result of trying to write it into a statically allocated buffer. This just
// makes it a little easier to know that the buffer was truncated during
// analysis.
const char kTruncationIndicator = '$';
ThreadStackHelper::ThreadStackHelper()
: mStackToFill(nullptr),
mMaxStackSize(16),
mMaxBufferSize(512),
mDesiredStackSize(0),
mDesiredBufferSize(0) {
mThreadId = profiler_current_thread_id();
}
bool ThreadStackHelper::PrepareStackBuffer(HangStack& aStack) {
// If we need to grow because we used more than we could store last time,
// increase our maximum sizes for this time.
if (mDesiredBufferSize > mMaxBufferSize) {
mMaxBufferSize = mDesiredBufferSize;
}
if (mDesiredStackSize > mMaxStackSize) {
mMaxStackSize = mDesiredStackSize;
}
mDesiredBufferSize = 0;
mDesiredStackSize = 0;
// Clear all of the stack entries.
aStack.stack().ClearAndRetainStorage();
aStack.strbuffer().ClearAndRetainStorage();
aStack.modules().Clear();
#ifdef MOZ_THREADSTACKHELPER_PROFILING_STACK
// Ensure we have enough space in our stack and string buffers for the data we
// want to collect.
if (!aStack.stack().SetCapacity(mMaxStackSize, fallible) ||
!aStack.strbuffer().SetCapacity(mMaxBufferSize, fallible)) {
return false;
}
return true;
#else
return false;
#endif
}
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(HangStack& aStack, nsACString& aRunnableName,
bool aStackWalk) {
aRunnableName.AssignLiteral("???");
if (!PrepareStackBuffer(aStack)) {
return;
}
Array<char, nsThread::kRunnableNameBufSize> runnableName;
runnableName[0] = '\0';
ScopedSetPtr<HangStack> _stackGuard(mStackToFill, &aStack);
ScopedSetPtr<Array<char, nsThread::kRunnableNameBufSize>> _runnableGuard(
mRunnableNameBuffer, &runnableName);
// XXX: We don't need to pass in ProfilerFeature::StackWalk to trigger
// stackwalking, as that is instead controlled by the last argument.
profiler_suspend_and_sample_thread(mThreadId, 0, *this, aStackWalk);
// Copy the name buffer allocation into the output string. We explicitly set
// the last byte to null in case we read in some corrupted data without a null
// terminator.
runnableName[nsThread::kRunnableNameBufSize - 1] = '\0';
aRunnableName.AssignASCII(runnableName.cbegin());
}
void ThreadStackHelper::SetIsMainThread() {
MOZ_RELEASE_ASSERT(mRunnableNameBuffer);
// NOTE: We cannot allocate any memory in this callback, as the target
// thread is suspended, so we first copy it into a stack-allocated buffer,
// and then once the target thread is resumed, we can copy it into a real
// nsCString.
//
// Currently we only store the names of runnables which are running on the
// main thread, so we only want to read sMainThreadRunnableName and copy its
// value in the case that we are currently suspending the main thread.
*mRunnableNameBuffer = nsThread::sMainThreadRunnableName;
}
void ThreadStackHelper::TryAppendFrame(HangEntry aFrame) {
MOZ_RELEASE_ASSERT(mStackToFill);
// We deduplicate identical Content, Jit, Wasm, ChromeScript and Suppressed
// frames.
switch (aFrame.type()) {
case HangEntry::THangEntryContent:
case HangEntry::THangEntryJit:
case HangEntry::THangEntryWasm:
case HangEntry::THangEntryChromeScript:
case HangEntry::THangEntrySuppressed:
if (!mStackToFill->stack().IsEmpty() &&
mStackToFill->stack().LastElement().type() == aFrame.type()) {
return;
}
break;
default:
break;
}
// Record that we _want_ to use another frame entry. If this exceeds
// mMaxStackSize, we'll allocate more room on the next hang.
mDesiredStackSize += 1;
// Perform the append if we have enough space to do so.
if (mStackToFill->stack().Capacity() > mStackToFill->stack().Length()) {
mStackToFill->stack().AppendElement(std::move(aFrame));
}
}
void ThreadStackHelper::CollectNativeLeafAddr(void* aAddr) {
MOZ_RELEASE_ASSERT(mStackToFill);
TryAppendFrame(HangEntryProgCounter(reinterpret_cast<uintptr_t>(aAddr)));
}
void ThreadStackHelper::CollectJitReturnAddr(void* aAddr) {
MOZ_RELEASE_ASSERT(mStackToFill);
TryAppendFrame(HangEntryJit());
}
void ThreadStackHelper::CollectWasmFrame(JS::ProfilingCategoryPair aCategory,
const char* aLabel) {
MOZ_RELEASE_ASSERT(mStackToFill);
// We don't want to collect WASM frames, as they are probably for content, so
// we just add a "(content wasm)" frame.
TryAppendFrame(HangEntryWasm());
}
namespace {
bool IsChromeJSScript(JSScript* aScript) {
// May be called from another thread or inside a signal handler.
// We assume querying the script is safe but we must not manipulate it.
JSPrincipals* const principals = JS_GetScriptPrincipals(aScript);
return nsJSPrincipals::get(principals)->IsSystemPrincipal();
}
// Get the full path after the URI scheme, if the URI matches the scheme.
template <size_t LEN>
const char* GetFullPathForScheme(const char* filename,
const char (&scheme)[LEN]) {
// Account for the null terminator included in LEN.
if (!strncmp(filename, scheme, LEN - 1)) {
return filename + LEN - 1;
}
return nullptr;
}
// Get the full path after a URI component, if the URI contains the component.
template <size_t LEN>
const char* GetPathAfterComponent(const char* filename,
const char (&component)[LEN]) {
const char* found = nullptr;
const char* next = strstr(filename, component);
while (next) {
// Move 'found' to end of the component, after the separator '/'.
// 'LEN - 1' accounts for the null terminator included in LEN,
found = next + LEN - 1;
// Resume searching before the separator '/'.
next = strstr(found - 1, component);
}
return found;
}
} // namespace
bool ThreadStackHelper::MaybeAppendDynamicStackFrame(Span<const char> aBuf) {
mDesiredBufferSize += aBuf.Length() + 1;
if (mStackToFill->stack().Capacity() > mStackToFill->stack().Length() &&
(mStackToFill->strbuffer().Capacity() -
mStackToFill->strbuffer().Length()) > aBuf.Length() + 1) {
// NOTE: We only increment this if we're going to successfully append.
mDesiredStackSize += 1;
uint32_t start = mStackToFill->strbuffer().Length();
mStackToFill->strbuffer().AppendElements(aBuf.Elements(), aBuf.Length());
mStackToFill->strbuffer().AppendElement('\0');
mStackToFill->stack().AppendElement(HangEntryBufOffset(start));
return true;
}
return false;
}
void ThreadStackHelper::CollectProfilingStackFrame(
const js::ProfilingStackFrame& aFrame) {
// For non-js frames, first try to get the dynamic string and fit it in,
// otherwise just get the label.
if (!aFrame.isJsFrame()) {
const char* frameLabel = aFrame.label();
if (aFrame.isNonsensitive() && aFrame.dynamicString()) {
const char* dynamicString = aFrame.dynamicString();
char buffer[128];
size_t len = SprintfLiteral(buffer, "%s %s", frameLabel, dynamicString);
if (len > sizeof(buffer)) {
buffer[sizeof(buffer) - 1] = kTruncationIndicator;
len = sizeof(buffer);
}
if (MaybeAppendDynamicStackFrame(Span(buffer, len))) {
return;
}
}
// frameLabel is a statically allocated string, so we want to store a
// reference to it without performing any allocations. This is important, as
// we aren't allowed to allocate within this function.
//
// The variant for this kind of label in our HangStack object is a
// `nsCString`, which normally contains heap allocated string data. However,
// `nsCString` has an optimization for literal strings which causes the
// backing data to not be copied when being copied between nsCString
// objects.
//
// We take advantage of that optimization by creating a nsCString object
// which has the LITERAL flag set. Without this optimization, this code
// would be incorrect.
nsCString label;
label.AssignLiteral(frameLabel, strlen(frameLabel));
// Let's make sure we don't deadlock here, by asserting that `label`'s
// backing data matches.
MOZ_RELEASE_ASSERT(label.BeginReading() == frameLabel,
"String copy performed during "
"ThreadStackHelper::CollectProfilingStackFrame");
TryAppendFrame(label);
return;
}
if (!aFrame.script()) {
TryAppendFrame(HangEntrySuppressed());
return;
}
if (!IsChromeJSScript(aFrame.script())) {
TryAppendFrame(HangEntryContent());
return;
}
// Rather than using the profiler's dynamic string, we compute our own string.
// This is because we want to do some size-saving strategies, and throw out
// information which won't help us as much.
const char* filename = JS_GetScriptFilename(aFrame.script());
char buffer[256]; // Should be enough to fit our longest js function and file
// names.
size_t len = 0;
if (JSFunction* func = aFrame.function()) {
if (JSString* str = JS_GetMaybePartialFunctionDisplayId(func)) {
JSLinearString* linear = JS_ASSERT_STRING_IS_LINEAR(str);
len = JS::GetLinearStringLength(linear);
JS::LossyCopyLinearStringChars(buffer, linear,
std::min(len, sizeof(buffer)));
// NOTE: >= so that we account for the trailing space that we'd want to
// otherwise append.
if (len >= sizeof(buffer)) {
len = sizeof(buffer);
buffer[sizeof(buffer) - 1] = kTruncationIndicator;
} else {
buffer[len++] = ' ';
}
}
}
unsigned lineno = JS_PCToLineNumber(aFrame.script(), aFrame.pc());
// Some script names are in the form "foo -> bar -> baz".
// Here we find the origin of these redirected scripts.
const char* basename = GetPathAfterComponent(filename, " -> ");
if (basename) {
filename = basename;
}
// Strip chrome:// or resource:// off of the filename if present.
basename = GetFullPathForScheme(filename, "chrome://");
if (!basename) {
basename = GetFullPathForScheme(filename, "resource://");
}
if (!basename) {
// If we're in an add-on script, 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;
}
}
len +=
SprintfBuf(buffer + len, sizeof(buffer) - len, "%s:%u", basename, lineno);
if (len > sizeof(buffer)) {
buffer[sizeof(buffer) - 1] = kTruncationIndicator;
len = sizeof(buffer);
}
if (MaybeAppendDynamicStackFrame(Span(buffer, len))) {
return;
}
TryAppendFrame(HangEntryChromeScript());
}
} // namespace mozilla