blob: 619cf950f186cfea1769da3f04196a941b966c34 [file] [log] [blame]
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/android/reached_code_profiler.h"
#include <signal.h>
#include <sys/time.h>
#include <ucontext.h>
#include <unistd.h>
#include <atomic>
#include "base/android/library_loader/anchor_functions.h"
#include "base/android/orderfile/orderfile_buildflags.h"
#include "base/android/reached_addresses_bitset.h"
#include "base/base_switches.h"
#include "base/command_line.h"
#include "base/feature_list.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/important_file_writer.h"
#include "base/functional/bind.h"
#include "base/linux_util.h"
#include "base/logging.h"
#include "base/no_destructor.h"
#include "base/path_service.h"
#include "base/scoped_generic.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_piece.h"
#include "base/strings/stringprintf.h"
#include "base/synchronization/lock.h"
#include "base/task/single_thread_task_runner.h"
#include "base/threading/thread.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
#include "build/build_config.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#if !BUILDFLAG(SUPPORTS_CODE_ORDERING)
#error Code ordering support is required for the reached code profiler.
#endif
namespace base {
namespace android {
namespace {
#if !defined(NDEBUG) || defined(COMPONENT_BUILD) || defined(OFFICIAL_BUILD)
// Always disabled for debug builds to avoid hitting a limit of signal
// interrupts that can get delivered into a single HANDLE_EINTR. Also
// debugging experience would be bad if there are a lot of signals flying
// around.
// Always disabled for component builds because in this case the code is not
// organized in one contiguous region which is required for the reached code
// profiler.
// Disabled for official builds because `g_text_bitfield` isn't included in
// official builds.
constexpr const bool kConfigurationSupported = false;
#else
constexpr const bool kConfigurationSupported = true;
#endif
constexpr const char kDumpToFileFlag[] = "reached-code-profiler-dump-to-file";
constexpr uint64_t kIterationsBeforeSkipping = 50;
constexpr uint64_t kIterationsBetweenUpdates = 100;
constexpr int kProfilerSignal = SIGWINCH;
constexpr base::TimeDelta kSamplingInterval = base::Milliseconds(10);
constexpr base::TimeDelta kDumpInterval = base::Seconds(30);
void HandleSignal(int signal, siginfo_t* info, void* context) {
if (signal != kProfilerSignal)
return;
ucontext_t* ucontext = reinterpret_cast<ucontext_t*>(context);
#if defined(ARCH_CPU_ARM64)
uintptr_t address = ucontext->uc_mcontext.pc;
#else
uintptr_t address = ucontext->uc_mcontext.arm_pc;
#endif
ReachedAddressesBitset::GetTextBitset()->RecordAddress(address);
}
struct ScopedTimerCloseTraits {
static absl::optional<timer_t> InvalidValue() { return absl::nullopt; }
static void Free(absl::optional<timer_t> x) { timer_delete(*x); }
};
// RAII object holding an interval timer.
using ScopedTimer =
base::ScopedGeneric<absl::optional<timer_t>, ScopedTimerCloseTraits>;
void DumpToFile(const base::FilePath& path,
scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
DCHECK(task_runner->BelongsToCurrentThread());
auto dir_path = path.DirName();
if (!base::DirectoryExists(dir_path) && !base::CreateDirectory(dir_path)) {
PLOG(ERROR) << "Could not create " << dir_path;
return;
}
std::vector<uint32_t> reached_offsets =
ReachedAddressesBitset::GetTextBitset()->GetReachedOffsets();
base::StringPiece contents(
reinterpret_cast<const char*>(reached_offsets.data()),
reached_offsets.size());
if (!base::ImportantFileWriter::WriteFileAtomically(path, contents,
"ReachedDump")) {
LOG(ERROR) << "Could not write reached dump into " << path;
}
task_runner->PostDelayedTask(
FROM_HERE, base::BindOnce(&DumpToFile, path, task_runner), kDumpInterval);
}
class ReachedCodeProfiler {
public:
static ReachedCodeProfiler* GetInstance() {
static base::NoDestructor<ReachedCodeProfiler> instance;
return instance.get();
}
ReachedCodeProfiler(const ReachedCodeProfiler&) = delete;
ReachedCodeProfiler& operator=(const ReachedCodeProfiler&) = delete;
// Starts to periodically send |kProfilerSignal| to all threads.
void Start(LibraryProcessType library_process_type,
base::TimeDelta sampling_interval) {
if (is_enabled_)
return;
// Set |kProfilerSignal| signal handler.
// TODO(crbug.com/916263): consider restoring |old_handler| after the
// profiler gets stopped.
struct sigaction old_handler;
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_sigaction = &HandleSignal;
sa.sa_flags = SA_RESTART | SA_SIGINFO;
int ret = sigaction(kProfilerSignal, &sa, &old_handler);
if (ret) {
PLOG(ERROR) << "Error setting signal handler. The reached code profiler "
"is disabled";
return;
}
// Create a new interval timer.
struct sigevent sevp;
memset(&sevp, 0, sizeof(sevp));
sevp.sigev_notify = SIGEV_THREAD;
sevp.sigev_notify_function = &OnTimerNotify;
timer_t timerid;
ret = timer_create(CLOCK_PROCESS_CPUTIME_ID, &sevp, &timerid);
if (ret) {
PLOG(ERROR)
<< "timer_create() failed. The reached code profiler is disabled";
return;
}
timer_.reset(timerid);
// Start the interval timer.
struct itimerspec its;
memset(&its, 0, sizeof(its));
its.it_interval.tv_nsec =
checked_cast<long>(sampling_interval.InNanoseconds());
its.it_value = its.it_interval;
ret = timer_settime(timerid, 0, &its, nullptr);
if (ret) {
PLOG(ERROR)
<< "timer_settime() failed. The reached code profiler is disabled";
return;
}
if (library_process_type == PROCESS_BROWSER)
StartDumpingReachedCode();
is_enabled_ = true;
}
// Stops profiling.
void Stop() {
timer_.reset();
dumping_thread_.reset();
is_enabled_ = false;
}
// Returns whether the profiler is currently enabled.
bool IsEnabled() { return is_enabled_; }
private:
ReachedCodeProfiler()
: current_pid_(getpid()), iteration_number_(0), is_enabled_(false) {}
static void OnTimerNotify(sigval_t ignored) {
ReachedCodeProfiler::GetInstance()->SendSignalToAllThreads();
}
void SendSignalToAllThreads() {
// This code should be thread-safe.
base::AutoLock scoped_lock(lock_);
++iteration_number_;
if (iteration_number_ <= kIterationsBeforeSkipping ||
iteration_number_ % kIterationsBetweenUpdates == 0) {
tids_.clear();
if (!base::GetThreadsForProcess(current_pid_, &tids_)) {
LOG(WARNING) << "Failed to get a list of threads for process "
<< current_pid_;
return;
}
}
pid_t current_tid = gettid();
for (pid_t tid : tids_) {
if (tid != current_tid)
tgkill(current_pid_, tid, kProfilerSignal);
}
}
void StartDumpingReachedCode() {
const base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
if (!cmdline->HasSwitch(kDumpToFileFlag))
return;
base::FilePath dir_path(cmdline->GetSwitchValueASCII(kDumpToFileFlag));
if (dir_path.empty()) {
if (!base::PathService::Get(base::DIR_CACHE, &dir_path)) {
LOG(WARNING) << "Failed to get cache dir path.";
return;
}
}
auto file_path =
dir_path.Append(base::StringPrintf("reached-code-%d.txt", getpid()));
dumping_thread_ =
std::make_unique<base::Thread>("ReachedCodeProfilerDumpingThread");
dumping_thread_->StartWithOptions(
base::Thread::Options(base::ThreadType::kBackground));
dumping_thread_->task_runner()->PostDelayedTask(
FROM_HERE,
base::BindOnce(&DumpToFile, file_path, dumping_thread_->task_runner()),
kDumpInterval);
}
base::Lock lock_;
std::vector<pid_t> tids_;
const pid_t current_pid_;
uint64_t iteration_number_;
ScopedTimer timer_;
std::unique_ptr<base::Thread> dumping_thread_;
bool is_enabled_;
friend class NoDestructor<ReachedCodeProfiler>;
};
bool ShouldEnableReachedCodeProfiler() {
if (!kConfigurationSupported)
return false;
const base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
return cmdline->HasSwitch(switches::kEnableReachedCodeProfiler);
}
} // namespace
void InitReachedCodeProfilerAtStartup(LibraryProcessType library_process_type) {
// The profiler shouldn't be run as part of webview.
CHECK(library_process_type == PROCESS_BROWSER ||
library_process_type == PROCESS_CHILD);
if (!ShouldEnableReachedCodeProfiler())
return;
int interval_us = 0;
base::TimeDelta sampling_interval = kSamplingInterval;
if (base::StringToInt(
base::CommandLine::ForCurrentProcess()->GetSwitchValueNative(
switches::kReachedCodeSamplingIntervalUs),
&interval_us) &&
interval_us > 0) {
sampling_interval = base::Microseconds(interval_us);
}
ReachedCodeProfiler::GetInstance()->Start(library_process_type,
sampling_interval);
}
bool IsReachedCodeProfilerEnabled() {
return ReachedCodeProfiler::GetInstance()->IsEnabled();
}
bool IsReachedCodeProfilerSupported() {
return kConfigurationSupported;
}
} // namespace android
} // namespace base