The Tor Browser: comparison tools/profiler/platform-linux.cc

--1:000000000000
+:0cd180e28060
+// Copyright (c) 2006-2011 The Chromium Authors. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//  * Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//  * Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in
+//    the documentation and/or other materials provided with the
+//    distribution.
+//  * Neither the name of Google, Inc. nor the names of its contributors
+//    may be used to endorse or promote products derived from this
+//    software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+// SUCH DAMAGE.
+/*
+# vim: sw=2
+*/
+#include <stdio.h>
+#include <math.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/prctl.h> // set name
+#include <stdlib.h>
+#include <sched.h>
+#ifdef ANDROID
+#include <android/log.h>
+#else
+#define __android_log_print(a, ...)
+#endif
+#include <ucontext.h>
+// Ubuntu Dapper requires memory pages to be marked as
+// executable. Otherwise, OS raises an exception when executing code
+// in that page.
+#include <sys/types.h>  // mmap & munmap
+#include <sys/mman.h>   // mmap & munmap
+#include <sys/stat.h>   // open
+#include <fcntl.h>      // open
+#include <unistd.h>     // sysconf
+#include <semaphore.h>
+#ifdef __GLIBC__
+#include <execinfo.h>   // backtrace, backtrace_symbols
+#endif  // def __GLIBC__
+#include <strings.h>    // index
+#include <errno.h>
+#include <stdarg.h>
+#include "platform.h"
+#include "GeckoProfiler.h"
+#include "mozilla/Mutex.h"
+#include "mozilla/Atomics.h"
+#include "ProfileEntry.h"
+#include "nsThreadUtils.h"
+#include "TableTicker.h"
+#include "UnwinderThread2.h"
+#if defined(__ARM_EABI__) && defined(MOZ_WIDGET_GONK)
+// Should also work on other Android and ARM Linux, but not tested there yet.
+#define USE_EHABI_STACKWALK
+#include "EHABIStackWalk.h"
+#endif
+#include <string.h>
+#include <stdio.h>
+#include <list>
+#ifdef MOZ_NUWA_PROCESS
+#include "ipc/Nuwa.h"
+#endif
+#define SIGNAL_SAVE_PROFILE SIGUSR2
+#if defined(__GLIBC__)
+// glibc doesn't implement gettid(2).
+#include <sys/syscall.h>
+pid_t gettid()
+{
+return (pid_t) syscall(SYS_gettid);
+}
+#endif
+/* static */ Thread::tid_t
+Thread::GetCurrentId()
+{
+return gettid();
+}
+#if !defined(ANDROID)
+// Keep track of when any of our threads calls fork(), so we can
+// temporarily disable signal delivery during the fork() call.  Not
+// doing so appears to cause a kind of race, in which signals keep
+// getting delivered to the thread doing fork(), which keeps causing
+// it to fail and be restarted; hence forward progress is delayed a
+// great deal.  A side effect of this is to permanently disable
+// sampling in the child process.  See bug 837390.
+// Unfortunately this is only doable on non-Android, since Bionic
+// doesn't have pthread_atfork.
+// This records the current state at the time we paused it.
+static bool was_paused = false;
+// In the parent, just before the fork, record the pausedness state,
+// and then pause.
+static void paf_prepare(void) {
+if (Sampler::GetActiveSampler()) {
+was_paused = Sampler::GetActiveSampler()->IsPaused();
+Sampler::GetActiveSampler()->SetPaused(true);
+} else {
+was_paused = false;
+}
+}
+// In the parent, just after the fork, return pausedness to the
+// pre-fork state.
+static void paf_parent(void) {
+if (Sampler::GetActiveSampler())
+Sampler::GetActiveSampler()->SetPaused(was_paused);
+}
+// Set up the fork handlers.
+static void* setup_atfork() {
+pthread_atfork(paf_prepare, paf_parent, NULL);
+return NULL;
+}
+#endif /* !defined(ANDROID) */
+struct SamplerRegistry {
+static void AddActiveSampler(Sampler *sampler) {
+ASSERT(!SamplerRegistry::sampler);
+SamplerRegistry::sampler = sampler;
+}
+static void RemoveActiveSampler(Sampler *sampler) {
+SamplerRegistry::sampler = NULL;
+}
+static Sampler *sampler;
+};
+Sampler *SamplerRegistry::sampler = NULL;
+static mozilla::Atomic<ThreadProfile*> sCurrentThreadProfile;
+static sem_t sSignalHandlingDone;
+static void ProfilerSaveSignalHandler(int signal, siginfo_t* info, void* context) {
+Sampler::GetActiveSampler()->RequestSave();
+}
+static void SetSampleContext(TickSample* sample, void* context)
+{
+// Extracting the sample from the context is extremely machine dependent.
+ucontext_t* ucontext = reinterpret_cast<ucontext_t*>(context);
+mcontext_t& mcontext = ucontext->uc_mcontext;
+#if V8_HOST_ARCH_IA32
+sample->pc = reinterpret_cast<Address>(mcontext.gregs[REG_EIP]);
+sample->sp = reinterpret_cast<Address>(mcontext.gregs[REG_ESP]);
+sample->fp = reinterpret_cast<Address>(mcontext.gregs[REG_EBP]);
+#elif V8_HOST_ARCH_X64
+sample->pc = reinterpret_cast<Address>(mcontext.gregs[REG_RIP]);
+sample->sp = reinterpret_cast<Address>(mcontext.gregs[REG_RSP]);
+sample->fp = reinterpret_cast<Address>(mcontext.gregs[REG_RBP]);
+#elif V8_HOST_ARCH_ARM
+// An undefined macro evaluates to 0, so this applies to Android's Bionic also.
+#if !defined(ANDROID) && (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ <= 3))
+sample->pc = reinterpret_cast<Address>(mcontext.gregs[R15]);
+sample->sp = reinterpret_cast<Address>(mcontext.gregs[R13]);
+sample->fp = reinterpret_cast<Address>(mcontext.gregs[R11]);
+#ifdef ENABLE_ARM_LR_SAVING
+sample->lr = reinterpret_cast<Address>(mcontext.gregs[R14]);
+#endif
+#else
+sample->pc = reinterpret_cast<Address>(mcontext.arm_pc);
+sample->sp = reinterpret_cast<Address>(mcontext.arm_sp);
+sample->fp = reinterpret_cast<Address>(mcontext.arm_fp);
+#ifdef ENABLE_ARM_LR_SAVING
+sample->lr = reinterpret_cast<Address>(mcontext.arm_lr);
+#endif
+#endif
+#elif V8_HOST_ARCH_MIPS
+// Implement this on MIPS.
+UNIMPLEMENTED();
+#endif
+}
+#ifdef ANDROID
+#define V8_HOST_ARCH_ARM 1
+#define SYS_gettid __NR_gettid
+#define SYS_tgkill __NR_tgkill
+#else
+#define V8_HOST_ARCH_X64 1
+#endif
+static void ProfilerSignalHandler(int signal, siginfo_t* info, void* context) {
+if (!Sampler::GetActiveSampler()) {
+sem_post(&sSignalHandlingDone);
+return;
+}
+TickSample sample_obj;
+TickSample* sample = &sample_obj;
+sample->context = context;
+#ifdef ENABLE_SPS_LEAF_DATA
+// If profiling, we extract the current pc and sp.
+if (Sampler::GetActiveSampler()->IsProfiling()) {
+SetSampleContext(sample, context);
+}
+#endif
+sample->threadProfile = sCurrentThreadProfile;
+sample->timestamp = mozilla::TimeStamp::Now();
+Sampler::GetActiveSampler()->Tick(sample);
+sCurrentThreadProfile = NULL;
+sem_post(&sSignalHandlingDone);
+}
+// If the Nuwa process is enabled, we need to use the wrapper of tgkill() to
+// perform the mapping of thread ID.
+#ifdef MOZ_NUWA_PROCESS
+extern "C" MFBT_API int tgkill(pid_t tgid, pid_t tid, int signalno);
+#else
+int tgkill(pid_t tgid, pid_t tid, int signalno) {
+return syscall(SYS_tgkill, tgid, tid, signalno);
+}
+#endif
+class PlatformData : public Malloced {
+public:
+PlatformData()
+{}
+};
+/* static */ PlatformData*
+Sampler::AllocPlatformData(int aThreadId)
+{
+return new PlatformData;
+}
+/* static */ void
+Sampler::FreePlatformData(PlatformData* aData)
+{
+delete aData;
+}
+static void* SignalSender(void* arg) {
+// Taken from platform_thread_posix.cc
+prctl(PR_SET_NAME, "SamplerThread", 0, 0, 0);
+#ifdef MOZ_NUWA_PROCESS
+// If the Nuwa process is enabled, we need to mark and freeze the sampler
+// thread in the Nuwa process and have this thread recreated in the spawned
+// child.
+if(IsNuwaProcess()) {
+NuwaMarkCurrentThread(nullptr, nullptr);
+// Freeze the thread here so the spawned child will get the correct tgid
+// from the getpid() call below.
+NuwaFreezeCurrentThread();
+}
+#endif
+int vm_tgid_ = getpid();
+while (SamplerRegistry::sampler->IsActive()) {
+SamplerRegistry::sampler->HandleSaveRequest();
+if (!SamplerRegistry::sampler->IsPaused()) {
+mozilla::MutexAutoLock lock(*Sampler::sRegisteredThreadsMutex);
+std::vector<ThreadInfo*> threads =
+SamplerRegistry::sampler->GetRegisteredThreads();
+for (uint32_t i = 0; i < threads.size(); i++) {
+ThreadInfo* info = threads[i];
+// This will be null if we're not interested in profiling this thread.
+if (!info->Profile())
+continue;
+PseudoStack::SleepState sleeping = info->Stack()->observeSleeping();
+if (sleeping == PseudoStack::SLEEPING_AGAIN) {
+info->Profile()->DuplicateLastSample();
+//XXX: This causes flushes regardless of jank-only mode
+info->Profile()->flush();
+continue;
+}
+// We use sCurrentThreadProfile the ThreadProfile for the
+// thread we're profiling to the signal handler
+sCurrentThreadProfile = info->Profile();
+int threadId = info->ThreadId();
+if (tgkill(vm_tgid_, threadId, SIGPROF) != 0) {
+printf_stderr("profiler failed to signal tid=%d\n", threadId);
+#ifdef DEBUG
+abort();
+#endif
+continue;
+}
+// Wait for the signal handler to run before moving on to the next one
+sem_wait(&sSignalHandlingDone);
+}
+}
+// Convert ms to us and subtract 100 us to compensate delays
+// occuring during signal delivery.
+// TODO measure and confirm this.
+int interval = floor(SamplerRegistry::sampler->interval() * 1000 + 0.5) - 100;
+if (interval <= 0) {
+interval = 1;
+}
+OS::SleepMicro(interval);
+}
+return 0;
+}
+Sampler::Sampler(double interval, bool profiling, int entrySize)
+: interval_(interval),
+profiling_(profiling),
+paused_(false),
+active_(false),
+entrySize_(entrySize) {
+}
+Sampler::~Sampler() {
+ASSERT(!signal_sender_launched_);
+}
+void Sampler::Start() {
+LOG("Sampler started");
+#ifdef USE_EHABI_STACKWALK
+mozilla::EHABIStackWalkInit();
+#endif
+SamplerRegistry::AddActiveSampler(this);
+// Initialize signal handler communication
+sCurrentThreadProfile = NULL;
+if (sem_init(&sSignalHandlingDone, /* pshared: */ 0, /* value: */ 0) != 0) {
+LOG("Error initializing semaphore");
+return;
+}
+// Request profiling signals.
+LOG("Request signal");
+struct sigaction sa;
+sa.sa_sigaction = ProfilerSignalHandler;
+sigemptyset(&sa.sa_mask);
+sa.sa_flags = SA_RESTART | SA_SIGINFO;
+if (sigaction(SIGPROF, &sa, &old_sigprof_signal_handler_) != 0) {
+LOG("Error installing signal");
+return;
+}
+// Request save profile signals
+struct sigaction sa2;
+sa2.sa_sigaction = ProfilerSaveSignalHandler;
+sigemptyset(&sa2.sa_mask);
+sa2.sa_flags = SA_RESTART | SA_SIGINFO;
+if (sigaction(SIGNAL_SAVE_PROFILE, &sa2, &old_sigsave_signal_handler_) != 0) {
+LOG("Error installing start signal");
+return;
+}
+LOG("Signal installed");
+signal_handler_installed_ = true;
+// Start a thread that sends SIGPROF signal to VM thread.
+// Sending the signal ourselves instead of relying on itimer provides
+// much better accuracy.
+SetActive(true);
+if (pthread_create(
+&signal_sender_thread_, NULL, SignalSender, NULL) == 0) {
+signal_sender_launched_ = true;
+}
+LOG("Profiler thread started");
+}
+void Sampler::Stop() {
+SetActive(false);
+// Wait for signal sender termination (it will exit after setting
+// active_ to false).
+if (signal_sender_launched_) {
+pthread_join(signal_sender_thread_, NULL);
+signal_sender_launched_ = false;
+}
+SamplerRegistry::RemoveActiveSampler(this);
+// Restore old signal handler
+if (signal_handler_installed_) {
+sigaction(SIGNAL_SAVE_PROFILE, &old_sigsave_signal_handler_, 0);
+sigaction(SIGPROF, &old_sigprof_signal_handler_, 0);
+signal_handler_installed_ = false;
+}
+}
+bool Sampler::RegisterCurrentThread(const char* aName,
+PseudoStack* aPseudoStack,
+bool aIsMainThread, void* stackTop)
+{
+if (!Sampler::sRegisteredThreadsMutex)
+return false;
+mozilla::MutexAutoLock lock(*Sampler::sRegisteredThreadsMutex);
+int id = gettid();
+for (uint32_t i = 0; i < sRegisteredThreads->size(); i++) {
+ThreadInfo* info = sRegisteredThreads->at(i);
+if (info->ThreadId() == id) {
+// Thread already registered. This means the first unregister will be
+// too early.
+ASSERT(false);
+return false;
+}
+}
+set_tls_stack_top(stackTop);
+ThreadInfo* info = new ThreadInfo(aName, id,
+aIsMainThread, aPseudoStack, stackTop);
+if (sActiveSampler) {
+sActiveSampler->RegisterThread(info);
+}
+sRegisteredThreads->push_back(info);
+uwt__register_thread_for_profiling(stackTop);
+return true;
+}
+void Sampler::UnregisterCurrentThread()
+{
+if (!Sampler::sRegisteredThreadsMutex)
+return;
+tlsStackTop.set(nullptr);
+mozilla::MutexAutoLock lock(*Sampler::sRegisteredThreadsMutex);
+int id = gettid();
+for (uint32_t i = 0; i < sRegisteredThreads->size(); i++) {
+ThreadInfo* info = sRegisteredThreads->at(i);
+if (info->ThreadId() == id) {
+delete info;
+sRegisteredThreads->erase(sRegisteredThreads->begin() + i);
+break;
+}
+}
+uwt__unregister_thread_for_profiling();
+}
+#ifdef ANDROID
+static struct sigaction old_sigstart_signal_handler;
+const int SIGSTART = SIGUSR2;
+static void freeArray(const char** array, int size) {
+for (int i = 0; i < size; i++) {
+free((void*) array[i]);
+}
+}
+static uint32_t readCSVArray(char* csvList, const char** buffer) {
+uint32_t count;
+char* savePtr;
+int newlinePos = strlen(csvList) - 1;
+if (csvList[newlinePos] == '\n') {
+csvList[newlinePos] = '\0';
+}
+char* item = strtok_r(csvList, ",", &savePtr);
+for (count = 0; item; item = strtok_r(NULL, ",", &savePtr)) {
+int length = strlen(item) + 1;  // Include \0
+char* newBuf = (char*) malloc(sizeof(char) * length);
+buffer[count] = newBuf;
+strncpy(newBuf, item, length);
+count++;
+}
+return count;
+}
+// Currently support only the env variables
+// reported in read_profiler_env
+static void ReadProfilerVars(const char* fileName, const char** features,
+uint32_t* featureCount, const char** threadNames, uint32_t* threadCount) {
+FILE* file = fopen(fileName, "r");
+const int bufferSize = 1024;
+char line[bufferSize];
+char* feature;
+char* value;
+char* savePtr;
+if (file) {
+while (fgets(line, bufferSize, file) != NULL) {
+feature = strtok_r(line, "=", &savePtr);
+value = strtok_r(NULL, "", &savePtr);
+if (strncmp(feature, PROFILER_MODE, bufferSize) == 0) {
+set_profiler_mode(value);
+} else if (strncmp(feature, PROFILER_INTERVAL, bufferSize) == 0) {
+set_profiler_interval(value);
+} else if (strncmp(feature, PROFILER_ENTRIES, bufferSize) == 0) {
+set_profiler_entries(value);
+} else if (strncmp(feature, PROFILER_STACK, bufferSize) == 0) {
+set_profiler_scan(value);
+} else if (strncmp(feature, PROFILER_FEATURES, bufferSize) == 0) {
+*featureCount = readCSVArray(value, features);
+} else if (strncmp(feature, "threads", bufferSize) == 0) {
+*threadCount = readCSVArray(value, threadNames);
+}
+}
+fclose(file);
+}
+}
+static void StartSignalHandler(int signal, siginfo_t* info, void* context) {
+// XXX: Everything we do here is NOT async signal safe. We risk nasty things
+// like deadlocks but we typically only do this once so it tends to be ok.
+// See bug 909403
+uint32_t featureCount = 0;
+uint32_t threadCount = 0;
+// Just allocate 10 features for now
+// FIXME: these don't really point to const chars*
+// So we free them later, but we don't want to change the const char**
+// declaration in profiler_start. Annoying but ok for now.
+const char* threadNames[10];
+const char* features[10];
+const char* profilerConfigFile = "/data/local/tmp/profiler.options";
+ReadProfilerVars(profilerConfigFile, features, &featureCount, threadNames, &threadCount);
+MOZ_ASSERT(featureCount < 10);
+MOZ_ASSERT(threadCount < 10);
+profiler_start(PROFILE_DEFAULT_ENTRY, 1,
+features, featureCount,
+threadNames, threadCount);
+freeArray(threadNames, threadCount);
+freeArray(features, featureCount);
+}
+void OS::Startup()
+{
+LOG("Registering start signal");
+struct sigaction sa;
+sa.sa_sigaction = StartSignalHandler;
+sigemptyset(&sa.sa_mask);
+sa.sa_flags = SA_RESTART | SA_SIGINFO;
+if (sigaction(SIGSTART, &sa, &old_sigstart_signal_handler) != 0) {
+LOG("Error installing signal");
+}
+}
+#else
+void OS::Startup() {
+// Set up the fork handlers.
+setup_atfork();
+}
+#endif
+void TickSample::PopulateContext(void* aContext)
+{
+MOZ_ASSERT(aContext);
+ucontext_t* pContext = reinterpret_cast<ucontext_t*>(aContext);
+if (!getcontext(pContext)) {
+context = pContext;
+SetSampleContext(this, aContext);
+}
+}
+// WARNING: Works with values up to 1 second
+void OS::SleepMicro(int microseconds)
+{
+struct timespec ts;
+ts.tv_sec  = 0;
+ts.tv_nsec = microseconds * 1000UL;
+while (true) {
+// in the case of interrupt we keep waiting
+// nanosleep puts the remaining to back into ts
+if (!nanosleep(&ts, &ts) || errno != EINTR) {
+return;
+}
+}
+}

The Tor Browser / file comparison

comparison: tools/profiler/platform-linux.cc

tools/profiler/platform-linux.cc