/*
|
* Copyright (C) 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 "event_type.h"
|
|
#include <inttypes.h>
|
#include <unistd.h>
|
#include <algorithm>
|
#include <string>
|
#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 "event_attr.h"
|
#include "utils.h"
|
|
#define EVENT_TYPE_TABLE_ENTRY(name, type, config, description, limited_arch) \
|
{name, type, config, description, limited_arch},
|
|
static const std::vector<EventType> static_event_type_array = {
|
#include "event_type_table.h"
|
};
|
|
static std::string tracepoint_events;
|
|
bool SetTracepointEventsFilePath(const std::string& filepath) {
|
if (!android::base::ReadFileToString(filepath, &tracepoint_events)) {
|
PLOG(ERROR) << "Failed to read " << filepath;
|
return false;
|
}
|
return true;
|
}
|
|
std::string GetTracepointEvents() {
|
std::string result;
|
for (auto& event : GetAllEventTypes()) {
|
if (event.type != PERF_TYPE_TRACEPOINT) {
|
continue;
|
}
|
if (!result.empty()) {
|
result.push_back('\n');
|
}
|
result += android::base::StringPrintf("%s %" PRIu64, event.name.c_str(), event.config);
|
}
|
return result;
|
}
|
|
static std::vector<EventType> GetTracepointEventTypesFromString(const std::string& s) {
|
std::vector<EventType> result;
|
for (auto& line : android::base::Split(s, "\n")) {
|
std::vector<std::string> items = android::base::Split(line, " ");
|
CHECK_EQ(items.size(), 2u);
|
std::string event_name = items[0];
|
uint64_t id;
|
CHECK(android::base::ParseUint(items[1].c_str(), &id));
|
result.push_back(EventType(event_name, PERF_TYPE_TRACEPOINT, id, "", ""));
|
}
|
return result;
|
}
|
|
static std::vector<EventType> GetTracepointEventTypesFromTraceFs() {
|
std::vector<EventType> result;
|
const std::string tracepoint_dirname = "/sys/kernel/debug/tracing/events";
|
for (const auto& system_name : GetSubDirs(tracepoint_dirname)) {
|
std::string system_path = tracepoint_dirname + "/" + system_name;
|
for (const auto& event_name : GetSubDirs(system_path)) {
|
std::string id_path = system_path + "/" + event_name + "/id";
|
std::string id_content;
|
if (!android::base::ReadFileToString(id_path, &id_content)) {
|
continue;
|
}
|
char* endptr;
|
uint64_t id = strtoull(id_content.c_str(), &endptr, 10);
|
if (endptr == id_content.c_str()) {
|
LOG(DEBUG) << "unexpected id '" << id_content << "' in " << id_path;
|
continue;
|
}
|
result.push_back(EventType(system_name + ":" + event_name, PERF_TYPE_TRACEPOINT, id, "", ""));
|
}
|
}
|
return result;
|
}
|
|
static std::vector<EventType> GetTracepointEventTypes() {
|
std::vector<EventType> result;
|
if (!tracepoint_events.empty()) {
|
result = GetTracepointEventTypesFromString(tracepoint_events);
|
} else {
|
result = GetTracepointEventTypesFromTraceFs();
|
}
|
std::sort(result.begin(), result.end(),
|
[](const EventType& type1, const EventType& type2) { return type1.name < type2.name; });
|
return result;
|
}
|
|
static std::set<EventType> g_event_types;
|
|
std::string ScopedEventTypes::BuildString(const std::vector<const EventType*>& event_types) {
|
std::string result;
|
for (auto type : event_types) {
|
if (!result.empty()) {
|
result.push_back('\n');
|
}
|
result += android::base::StringPrintf("%s,%u,%" PRIu64, type->name.c_str(), type->type,
|
type->config);
|
}
|
return result;
|
}
|
|
ScopedEventTypes::ScopedEventTypes(const std::string& event_type_str) {
|
saved_event_types_ = std::move(g_event_types);
|
g_event_types.clear();
|
for (auto& s : android::base::Split(event_type_str, "\n")) {
|
std::string name = s.substr(0, s.find(','));
|
uint32_t type;
|
uint64_t config;
|
sscanf(s.c_str() + name.size(), ",%u,%" PRIu64, &type, &config);
|
g_event_types.emplace(name, type, config, "", "");
|
}
|
}
|
|
ScopedEventTypes::~ScopedEventTypes() {
|
g_event_types = std::move(saved_event_types_);
|
}
|
|
const std::set<EventType>& GetAllEventTypes() {
|
if (g_event_types.empty()) {
|
g_event_types.insert(static_event_type_array.begin(), static_event_type_array.end());
|
std::vector<EventType> tracepoint_array = GetTracepointEventTypes();
|
g_event_types.insert(tracepoint_array.begin(), tracepoint_array.end());
|
}
|
return g_event_types;
|
}
|
|
const EventType* FindEventTypeByName(const std::string& name, bool report_error) {
|
const auto& event_types = GetAllEventTypes();
|
auto it = event_types.find(EventType(name, 0, 0, "", ""));
|
if (it != event_types.end()) {
|
return &*it;
|
}
|
if (!name.empty() && name[0] == 'r') {
|
char* end;
|
uint64_t config = strtoull(&name[1], &end, 16);
|
if (end != &name[1] && *end == '\0') {
|
auto result = g_event_types.emplace(name, PERF_TYPE_RAW, config, "", "");
|
CHECK(result.second);
|
return &*(result.first);
|
}
|
}
|
if (report_error) {
|
LOG(ERROR) << "Unknown event_type '" << name
|
<< "', try `simpleperf list` to list all possible event type names";
|
}
|
return nullptr;
|
}
|
|
std::unique_ptr<EventTypeAndModifier> ParseEventType(const std::string& event_type_str) {
|
static std::string modifier_characters = "ukhGHp";
|
std::unique_ptr<EventTypeAndModifier> event_type_modifier(new EventTypeAndModifier);
|
event_type_modifier->name = event_type_str;
|
std::string event_type_name = event_type_str;
|
std::string modifier;
|
size_t comm_pos = event_type_str.rfind(':');
|
if (comm_pos != std::string::npos) {
|
bool match_modifier = true;
|
for (size_t i = comm_pos + 1; i < event_type_str.size(); ++i) {
|
char c = event_type_str[i];
|
if (c != ' ' && modifier_characters.find(c) == std::string::npos) {
|
match_modifier = false;
|
break;
|
}
|
}
|
if (match_modifier) {
|
event_type_name = event_type_str.substr(0, comm_pos);
|
modifier = event_type_str.substr(comm_pos + 1);
|
}
|
}
|
const EventType* event_type = FindEventTypeByName(event_type_name);
|
if (event_type == nullptr) {
|
// Try if the modifier belongs to the event type name, like some tracepoint events.
|
if (!modifier.empty()) {
|
event_type_name = event_type_str;
|
modifier.clear();
|
event_type = FindEventTypeByName(event_type_name);
|
}
|
if (event_type == nullptr) {
|
return nullptr;
|
}
|
}
|
event_type_modifier->event_type = *event_type;
|
if (modifier.find_first_of("ukh") != std::string::npos) {
|
event_type_modifier->exclude_user = true;
|
event_type_modifier->exclude_kernel = true;
|
event_type_modifier->exclude_hv = true;
|
}
|
if (modifier.find_first_of("GH") != std::string::npos) {
|
event_type_modifier->exclude_guest = true;
|
event_type_modifier->exclude_host = true;
|
}
|
|
for (auto& c : modifier) {
|
switch (c) {
|
case 'u':
|
event_type_modifier->exclude_user = false;
|
break;
|
case 'k':
|
event_type_modifier->exclude_kernel = false;
|
break;
|
case 'h':
|
event_type_modifier->exclude_hv = false;
|
break;
|
case 'G':
|
event_type_modifier->exclude_guest = false;
|
break;
|
case 'H':
|
event_type_modifier->exclude_host = false;
|
break;
|
case 'p':
|
event_type_modifier->precise_ip++;
|
break;
|
case ' ':
|
break;
|
default:
|
LOG(ERROR) << "Unknown event type modifier '" << c << "'";
|
}
|
}
|
event_type_modifier->modifier = modifier;
|
return event_type_modifier;
|
}
|
