/*
|
**
|
** Copyright 2015, The Android Open Source Project
|
**
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
** you may not use this file except in compliance with the License.
|
** You may obtain a copy of the License at
|
**
|
** http://www.apache.org/licenses/LICENSE-2.0
|
**
|
** Unless required by applicable law or agreed to in writing, software
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
** See the License for the specific language governing permissions and
|
** limitations under the License.
|
*/
|
|
#include "configreader.h"
|
|
#include <inttypes.h>
|
|
#include <algorithm>
|
#include <climits>
|
#include <cstdlib>
|
#include <cstring>
|
#include <map>
|
#include <sstream>
|
#include <vector>
|
|
#include <android-base/file.h>
|
#include <android-base/logging.h>
|
#include <android-base/parseint.h>
|
#include <android-base/stringprintf.h>
|
#include <android-base/strings.h>
|
|
#include "perfprofd_config.pb.h"
|
|
using android::base::StringPrintf;
|
|
//
|
// Config file path
|
//
|
static const char *config_file_path =
|
"/data/data/com.google.android.gms/files/perfprofd.conf";
|
|
struct ConfigReader::Data {
|
struct values {
|
unsigned minv;
|
unsigned maxv;
|
};
|
std::map<std::string, values> u_info;
|
std::map<std::string, unsigned> u_entries;
|
std::map<std::string, std::string> s_entries;
|
|
struct events {
|
std::vector<std::string> names;
|
unsigned period;
|
bool group;
|
};
|
std::vector<events> e_entries;
|
bool trace_config_read;
|
};
|
|
ConfigReader::ConfigReader() : data_(new ConfigReader::Data())
|
{
|
data_->trace_config_read = false;
|
addDefaultEntries();
|
}
|
|
ConfigReader::~ConfigReader()
|
{
|
}
|
|
const char *ConfigReader::getConfigFilePath()
|
{
|
return config_file_path;
|
}
|
|
void ConfigReader::setConfigFilePath(const char *path)
|
{
|
config_file_path = strdup(path);
|
LOG(INFO) << "config file path set to " << config_file_path;
|
}
|
|
//
|
// Populate the reader with the set of allowable entries
|
//
|
void ConfigReader::addDefaultEntries()
|
{
|
struct DummyConfig : public Config {
|
void Sleep(size_t seconds) override {}
|
bool IsProfilingEnabled() const override { return false; }
|
};
|
DummyConfig config;
|
|
// Average number of seconds between perf profile collections (if
|
// set to 100, then over time we want to see a perf profile
|
// collected every 100 seconds). The actual time within the interval
|
// for the collection is chosen randomly.
|
addUnsignedEntry("collection_interval", config.collection_interval_in_s, 0, UINT32_MAX);
|
|
// Use the specified fixed seed for random number generation (unit
|
// testing)
|
addUnsignedEntry("use_fixed_seed", config.use_fixed_seed, 0, UINT32_MAX);
|
|
// For testing purposes, number of times to iterate through main
|
// loop. Value of zero indicates that we should loop forever.
|
addUnsignedEntry("main_loop_iterations", config.main_loop_iterations, 0, UINT32_MAX);
|
|
// Destination directory (where to write profiles).
|
addStringEntry("destination_directory", config.destination_directory.c_str());
|
|
// Config directory (where to read configs).
|
addStringEntry("config_directory", config.config_directory.c_str());
|
|
// Full path to 'perf' executable.
|
addStringEntry("perf_path", config.perf_path.c_str());
|
|
// Desired sampling period (passed to perf -c option).
|
addUnsignedEntry("sampling_period", config.sampling_period, 0, UINT32_MAX);
|
// Desired sampling frequency (passed to perf -f option).
|
addUnsignedEntry("sampling_frequency", config.sampling_frequency, 0, UINT32_MAX);
|
|
// Length of time to collect samples (number of seconds for 'perf
|
// record -a' run).
|
addUnsignedEntry("sample_duration", config.sample_duration_in_s, 1, 600);
|
|
// If this parameter is non-zero it will cause perfprofd to
|
// exit immediately if the build type is not userdebug or eng.
|
// Currently defaults to 1 (true).
|
addUnsignedEntry("only_debug_build", config.only_debug_build ? 1 : 0, 0, 1);
|
|
// If the "mpdecision" service is running at the point we are ready
|
// to kick off a profiling run, then temporarily disable the service
|
// and hard-wire all cores on prior to the collection run, provided
|
// that the duration of the recording is less than or equal to the value of
|
// 'hardwire_cpus_max_duration'.
|
addUnsignedEntry("hardwire_cpus", config.hardwire_cpus, 0, 1);
|
addUnsignedEntry("hardwire_cpus_max_duration",
|
config.hardwire_cpus_max_duration_in_s,
|
1,
|
UINT32_MAX);
|
|
// Maximum number of unprocessed profiles we can accumulate in the
|
// destination directory. Once we reach this limit, we continue
|
// to collect, but we just overwrite the most recent profile.
|
addUnsignedEntry("max_unprocessed_profiles", config.max_unprocessed_profiles, 1, UINT32_MAX);
|
|
// If set to 1, pass the -g option when invoking 'perf' (requests
|
// stack traces as opposed to flat profile).
|
addUnsignedEntry("stack_profile", config.stack_profile ? 1 : 0, 0, 1);
|
|
// For unit testing only: if set to 1, emit info messages on config
|
// file parsing.
|
addUnsignedEntry("trace_config_read", config.trace_config_read ? 1 : 0, 0, 1);
|
|
// Control collection of various additional profile tags
|
addUnsignedEntry("collect_cpu_utilization", config.collect_cpu_utilization ? 1 : 0, 0, 1);
|
addUnsignedEntry("collect_charging_state", config.collect_charging_state ? 1 : 0, 0, 1);
|
addUnsignedEntry("collect_booting", config.collect_booting ? 1 : 0, 0, 1);
|
addUnsignedEntry("collect_camera_active", config.collect_camera_active ? 1 : 0, 0, 1);
|
|
// If true, use an ELF symbolizer to on-device symbolize.
|
addUnsignedEntry("use_elf_symbolizer", config.use_elf_symbolizer ? 1 : 0, 0, 1);
|
// Whether to symbolize everything. If false, objects with build ID will be skipped.
|
addUnsignedEntry("symbolize_everything", config.symbolize_everything ? 1 : 0, 0, 1);
|
|
// If true, use libz to compress the output proto.
|
addUnsignedEntry("compress", config.compress ? 1 : 0, 0, 1);
|
|
// If true, send the proto to dropbox instead of to a file.
|
addUnsignedEntry("dropbox", config.send_to_dropbox ? 1 : 0, 0, 1);
|
|
// The pid of the process to profile. May be negative, in which case
|
// the whole system will be profiled.
|
addUnsignedEntry("process", static_cast<uint32_t>(-1), 0, UINT32_MAX);
|
|
// Whether to fail or strip unsupported events.
|
addUnsignedEntry("fail_on_unsupported_events", config.fail_on_unsupported_events ? 1 : 0, 0, 1);
|
}
|
|
void ConfigReader::addUnsignedEntry(const char *key,
|
unsigned default_value,
|
unsigned min_value,
|
unsigned max_value)
|
{
|
std::string ks(key);
|
CHECK(data_->u_entries.find(ks) == data_->u_entries.end() &&
|
data_->s_entries.find(ks) == data_->s_entries.end())
|
<< "internal error -- duplicate entry for key " << key;
|
Data::values vals;
|
vals.minv = min_value;
|
vals.maxv = max_value;
|
data_->u_info[ks] = vals;
|
data_->u_entries[ks] = default_value;
|
}
|
|
void ConfigReader::addStringEntry(const char *key, const char *default_value)
|
{
|
std::string ks(key);
|
CHECK(data_->u_entries.find(ks) == data_->u_entries.end() &&
|
data_->s_entries.find(ks) == data_->s_entries.end())
|
<< "internal error -- duplicate entry for key " << key;
|
CHECK(default_value != nullptr) << "internal error -- bad default value for key " << key;
|
data_->s_entries[ks] = std::string(default_value);
|
}
|
|
unsigned ConfigReader::getUnsignedValue(const char *key) const
|
{
|
std::string ks(key);
|
auto it = data_->u_entries.find(ks);
|
CHECK(it != data_->u_entries.end());
|
return it->second;
|
}
|
|
bool ConfigReader::getBoolValue(const char *key) const
|
{
|
std::string ks(key);
|
auto it = data_->u_entries.find(ks);
|
CHECK(it != data_->u_entries.end());
|
return it->second != 0;
|
}
|
|
std::string ConfigReader::getStringValue(const char *key) const
|
{
|
std::string ks(key);
|
auto it = data_->s_entries.find(ks);
|
CHECK(it != data_->s_entries.end());
|
return it->second;
|
}
|
|
void ConfigReader::overrideUnsignedEntry(const char *key, unsigned new_value)
|
{
|
std::string ks(key);
|
auto it = data_->u_entries.find(ks);
|
CHECK(it != data_->u_entries.end());
|
Data::values vals;
|
auto iit = data_->u_info.find(key);
|
CHECK(iit != data_->u_info.end());
|
vals = iit->second;
|
CHECK(new_value >= vals.minv && new_value <= vals.maxv);
|
it->second = new_value;
|
LOG(INFO) << "option " << key << " overridden to " << new_value;
|
}
|
|
|
//
|
// Parse a key=value pair read from the config file. This will issue
|
// warnings or errors to the system logs if the line can't be
|
// interpreted properly.
|
//
|
bool ConfigReader::parseLine(const std::string& key,
|
const std::string& value,
|
unsigned linecount,
|
std::string* error_msg)
|
{
|
if (key.empty()) {
|
*error_msg = StringPrintf("line %u: Key is empty", linecount);
|
return false;
|
}
|
if (value.empty()) {
|
*error_msg = StringPrintf("line %u: Value for %s is empty", linecount, key.c_str());
|
return false;
|
}
|
|
auto uit = data_->u_entries.find(key);
|
if (uit != data_->u_entries.end()) {
|
uint64_t conv;
|
if (!android::base::ParseUint(value, &conv)) {
|
*error_msg = StringPrintf("line %u: value %s cannot be parsed", linecount, value.c_str());
|
return false;
|
}
|
Data::values vals;
|
auto iit = data_->u_info.find(key);
|
DCHECK(iit != data_->u_info.end());
|
vals = iit->second;
|
if (conv < vals.minv || conv > vals.maxv) {
|
*error_msg = StringPrintf("line %u: "
|
"specified value %" PRIu64 " for '%s' "
|
"outside permitted range [%u %u]",
|
linecount,
|
conv,
|
key.c_str(),
|
vals.minv,
|
vals.maxv);
|
return false;
|
} else {
|
if (data_->trace_config_read) {
|
LOG(INFO) << "option " << key << " set to " << conv;
|
}
|
uit->second = static_cast<unsigned>(conv);
|
}
|
data_->trace_config_read = (getUnsignedValue("trace_config_read") != 0);
|
return true;
|
}
|
|
auto sit = data_->s_entries.find(key);
|
if (sit != data_->s_entries.end()) {
|
if (data_->trace_config_read) {
|
LOG(INFO) << "option " << key << " set to " << value;
|
}
|
sit->second = std::string(value);
|
return true;
|
}
|
|
// Check whether this follows event syntax, and create an event entry, if necessary.
|
// -e_evtname(,evtname)*=period
|
// -g_evtname(,evtname)*=period
|
{
|
bool event_key = android::base::StartsWith(key, "-e_");
|
bool group_key = android::base::StartsWith(key, "-g_");
|
if (event_key || group_key) {
|
Data::events events;
|
events.group = group_key;
|
|
uint64_t conv;
|
if (!android::base::ParseUint(value, &conv)) {
|
*error_msg = StringPrintf("line %u: key %s cannot be parsed", linecount, key.c_str());
|
return false;
|
}
|
if (conv > std::numeric_limits<unsigned>::max()) {
|
*error_msg = StringPrintf("line %u: key %s: period too large", linecount, key.c_str());
|
return false;
|
}
|
events.period = static_cast<unsigned>(conv);
|
|
events.names = android::base::Split(key.substr(3), ",");
|
data_->e_entries.push_back(events);
|
return true;
|
}
|
}
|
|
*error_msg = StringPrintf("line %u: unknown option '%s'", linecount, key.c_str());
|
return false;
|
}
|
|
static bool isblank(const std::string &line)
|
{
|
auto non_space = [](char c) { return isspace(c) == 0; };
|
return std::find_if(line.begin(), line.end(), non_space) == line.end();
|
}
|
|
|
|
bool ConfigReader::readFile()
|
{
|
std::string contents;
|
if (! android::base::ReadFileToString(config_file_path, &contents)) {
|
return false;
|
}
|
std::string error_msg;
|
if (!Read(contents, /* fail_on_error */ false, &error_msg)) {
|
LOG(ERROR) << error_msg;
|
return false;
|
}
|
if (!error_msg.empty()) {
|
LOG(WARNING) << error_msg;
|
}
|
return true;
|
}
|
|
bool ConfigReader::Read(const std::string& content, bool fail_on_error, std::string* error_msg) {
|
std::stringstream ss(content);
|
std::string line;
|
|
auto append_error = [error_msg](const std::string& tmp) {
|
if (!error_msg->empty()) {
|
error_msg->append("\n");
|
error_msg->append(tmp);
|
} else {
|
*error_msg = tmp;
|
}
|
};
|
|
for (unsigned linecount = 1;
|
std::getline(ss,line,'\n');
|
linecount += 1)
|
{
|
|
// comment line?
|
if (line[0] == '#') {
|
continue;
|
}
|
|
// blank line?
|
if (isblank(line)) {
|
continue;
|
}
|
|
// look for X=Y assignment
|
auto efound = line.find('=');
|
if (efound == std::string::npos) {
|
append_error(StringPrintf("line %u: line malformed (no '=' found)", linecount));
|
if (fail_on_error) {
|
return false;
|
}
|
continue;
|
}
|
|
std::string key(line.substr(0, efound));
|
std::string value(line.substr(efound+1, std::string::npos));
|
|
std::string local_error_msg;
|
bool parse_success = parseLine(key, value, linecount, &local_error_msg);
|
if (!parse_success) {
|
append_error(local_error_msg);
|
if (fail_on_error) {
|
return false;
|
}
|
}
|
}
|
|
return true;
|
}
|
|
void ConfigReader::FillConfig(Config* config) {
|
config->collection_interval_in_s = getUnsignedValue("collection_interval");
|
|
config->use_fixed_seed = getUnsignedValue("use_fixed_seed");
|
|
config->main_loop_iterations = getUnsignedValue("main_loop_iterations");
|
|
config->destination_directory = getStringValue("destination_directory");
|
|
config->config_directory = getStringValue("config_directory");
|
|
config->perf_path = getStringValue("perf_path");
|
|
config->sampling_period = getUnsignedValue("sampling_period");
|
config->sampling_frequency = getUnsignedValue("sampling_frequency");
|
|
config->sample_duration_in_s = getUnsignedValue("sample_duration");
|
|
config->only_debug_build = getBoolValue("only_debug_build");
|
|
config->hardwire_cpus = getBoolValue("hardwire_cpus");
|
config->hardwire_cpus_max_duration_in_s = getUnsignedValue("hardwire_cpus_max_duration");
|
|
config->max_unprocessed_profiles = getUnsignedValue("max_unprocessed_profiles");
|
|
config->stack_profile = getBoolValue("stack_profile");
|
|
config->trace_config_read = getBoolValue("trace_config_read");
|
|
config->collect_cpu_utilization = getBoolValue("collect_cpu_utilization");
|
config->collect_charging_state = getBoolValue("collect_charging_state");
|
config->collect_booting = getBoolValue("collect_booting");
|
config->collect_camera_active = getBoolValue("collect_camera_active");
|
|
config->process = static_cast<int32_t>(getUnsignedValue("process"));
|
config->use_elf_symbolizer = getBoolValue("use_elf_symbolizer");
|
config->symbolize_everything = getBoolValue("symbolize_everything");
|
config->compress = getBoolValue("compress");
|
config->send_to_dropbox = getBoolValue("dropbox");
|
config->fail_on_unsupported_events = getBoolValue("fail_on_unsupported_events");
|
|
config->event_config.clear();
|
for (const auto& event : data_->e_entries) {
|
Config::PerfCounterConfigElem elem;
|
elem.events = event.names;
|
elem.group = event.group;
|
elem.sampling_period = event.period;
|
config->event_config.push_back(std::move(elem));
|
}
|
}
|
|
namespace {
|
|
template <typename T>
|
struct OssFormatter {
|
};
|
|
template <>
|
struct OssFormatter<std::string> {
|
void Add(std::ostream& os, const std::string& val) {
|
os << val;
|
}
|
};
|
|
template <>
|
struct OssFormatter<uint32_t> {
|
void Add(std::ostream& os, const uint32_t& val) {
|
os << val;
|
}
|
};
|
|
template <>
|
struct OssFormatter<int32_t> {
|
void Add(std::ostream& os, const int32_t& val) {
|
os << val;
|
}
|
};
|
|
template <>
|
struct OssFormatter<bool> {
|
void Add(std::ostream& os, const bool& val) {
|
os << (val ? 1 : 0);
|
}
|
};
|
|
|
} // namespace
|
|
std::string ConfigReader::ConfigToString(const Config& config) {
|
std::ostringstream oss;
|
|
auto add = [&oss](const char* str, auto val) {
|
if (oss.tellp() != 0) {
|
oss << ' ';
|
}
|
oss << str << '=';
|
OssFormatter<decltype(val)> fmt;
|
fmt.Add(oss, val);
|
};
|
|
add("collection_interval", config.collection_interval_in_s);
|
add("use_fixed_seed", config.use_fixed_seed);
|
add("main_loop_iterations", config.main_loop_iterations);
|
|
add("destination_directory", config.destination_directory); // TODO: Escape.
|
add("config_directory", config.config_directory); // TODO: Escape.
|
add("perf_path", config.perf_path); // TODO: Escape.
|
|
add("sampling_period", config.sampling_period);
|
add("sampling_frequency", config.sampling_frequency);
|
|
add("sample_duration", config.sample_duration_in_s);
|
|
add("only_debug_build", config.only_debug_build);
|
|
add("hardwire_cpus", config.hardwire_cpus);
|
|
add("hardwire_cpus_max_duration", config.hardwire_cpus_max_duration_in_s);
|
|
add("max_unprocessed_profiles", config.max_unprocessed_profiles);
|
|
add("stack_profile", config.stack_profile);
|
|
add("trace_config_read", config.trace_config_read);
|
|
add("collect_cpu_utilization", config.collect_cpu_utilization);
|
add("collect_charging_state", config.collect_charging_state);
|
add("collect_booting", config.collect_booting);
|
add("collect_camera_active", config.collect_camera_active);
|
|
add("process", config.process);
|
add("use_elf_symbolizer", config.use_elf_symbolizer);
|
add("symbolize_everything", config.symbolize_everything);
|
add("compress", config.compress);
|
add("dropbox", config.send_to_dropbox);
|
add("fail_on_unsupported_events", config.fail_on_unsupported_events);
|
|
for (const auto& elem : config.event_config) {
|
std::ostringstream oss_elem;
|
oss_elem << '-' << (elem.group ? 'g' : 'e') << '_';
|
bool first = true;
|
for (const auto& event : elem.events) {
|
if (!first) {
|
oss_elem << ',';
|
}
|
oss_elem << event;
|
first = false;
|
}
|
add(oss_elem.str().c_str(), elem.sampling_period);
|
}
|
|
return oss.str();
|
}
|
|
void ConfigReader::ProtoToConfig(const android::perfprofd::ProfilingConfig& in, Config* out) {
|
// Copy base proto values.
|
#define CHECK_AND_COPY_FROM_PROTO(name) \
|
if (in.has_ ## name()) { \
|
out->name = in.name(); \
|
}
|
CHECK_AND_COPY_FROM_PROTO(collection_interval_in_s)
|
CHECK_AND_COPY_FROM_PROTO(use_fixed_seed)
|
CHECK_AND_COPY_FROM_PROTO(main_loop_iterations)
|
CHECK_AND_COPY_FROM_PROTO(destination_directory)
|
CHECK_AND_COPY_FROM_PROTO(config_directory)
|
CHECK_AND_COPY_FROM_PROTO(perf_path)
|
CHECK_AND_COPY_FROM_PROTO(sampling_period)
|
CHECK_AND_COPY_FROM_PROTO(sampling_frequency)
|
CHECK_AND_COPY_FROM_PROTO(sample_duration_in_s)
|
CHECK_AND_COPY_FROM_PROTO(only_debug_build)
|
CHECK_AND_COPY_FROM_PROTO(hardwire_cpus)
|
CHECK_AND_COPY_FROM_PROTO(hardwire_cpus_max_duration_in_s)
|
CHECK_AND_COPY_FROM_PROTO(max_unprocessed_profiles)
|
CHECK_AND_COPY_FROM_PROTO(stack_profile)
|
CHECK_AND_COPY_FROM_PROTO(collect_cpu_utilization)
|
CHECK_AND_COPY_FROM_PROTO(collect_charging_state)
|
CHECK_AND_COPY_FROM_PROTO(collect_booting)
|
CHECK_AND_COPY_FROM_PROTO(collect_camera_active)
|
CHECK_AND_COPY_FROM_PROTO(process)
|
CHECK_AND_COPY_FROM_PROTO(use_elf_symbolizer)
|
CHECK_AND_COPY_FROM_PROTO(symbolize_everything)
|
CHECK_AND_COPY_FROM_PROTO(send_to_dropbox)
|
CHECK_AND_COPY_FROM_PROTO(compress)
|
CHECK_AND_COPY_FROM_PROTO(fail_on_unsupported_events)
|
#undef CHECK_AND_COPY_FROM_PROTO
|
|
// Convert counters.
|
for (const auto& event_config : in.event_config()) {
|
Config::PerfCounterConfigElem config_elem;
|
|
if (event_config.counters_size() == 0) {
|
LOG(WARNING) << "Missing counters.";
|
continue;
|
}
|
config_elem.events.reserve(event_config.counters_size());
|
for (const std::string& str : event_config.counters()) {
|
config_elem.events.push_back(str);
|
}
|
config_elem.group = event_config.has_as_group() ? event_config.as_group() : false;
|
config_elem.sampling_period = event_config.has_sampling_period()
|
? event_config.sampling_period()
|
: 0;
|
out->event_config.push_back(std::move(config_elem));
|
}
|
}
|
