simpleperf/tracing.cpp

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "tracing.h"
  18
  19 #include <string.h>
  20
  21 #include <map>
  22 #include <string>
  23 #include <vector>
  24
  25 #include <android-base/file.h>
  26 #include <android-base/logging.h>
  27 #include <android-base/stringprintf.h>
  28 #include <android-base/strings.h>
  29
  30 #include "perf_event.h"
  31 #include "utils.h"
  32
  33 const char TRACING_INFO_MAGIC[10] = {23,  8,   68,  't', 'r',
  34                                      'a', 'c', 'i', 'n', 'g'};
  35
  36 template <class T>
  37 void AppendData(std::vector<char>& data, const T& s) {
  38   const char* p = reinterpret_cast<const char*>(&s);
  39   data.insert(data.end(), p, p + sizeof(T));
  40 }
  41
  42 static void AppendData(std::vector<char>& data, const char* s) {
  43   data.insert(data.end(), s, s + strlen(s) + 1);
  44 }
  45
  46 template <>
  47 void AppendData(std::vector<char>& data, const std::string& s) {
  48   data.insert(data.end(), s.c_str(), s.c_str() + s.size() + 1);
  49 }
  50
  51 template <>
  52 void MoveFromBinaryFormat(std::string& data, const char*& p) {
  53   data.clear();
  54   while (*p != '\0') {
  55     data.push_back(*p++);
  56   }
  57   p++;
  58 }
  59
  60 static void AppendFile(std::vector<char>& data, const std::string& file,
  61                        uint32_t file_size_bytes = 8) {
  62   if (file_size_bytes == 8) {
  63     uint64_t file_size = file.size();
  64     AppendData(data, file_size);
  65   } else if (file_size_bytes == 4) {
  66     uint32_t file_size = file.size();
  67     AppendData(data, file_size);
  68   }
  69   data.insert(data.end(), file.begin(), file.end());
  70 }
  71
  72 static void DetachFile(const char*& p, std::string& file,
  73                        uint32_t file_size_bytes = 8) {
  74   uint64_t file_size = ConvertBytesToValue(p, file_size_bytes);
  75   p += file_size_bytes;
  76   file.clear();
  77   file.insert(file.end(), p, p + file_size);
  78   p += file_size;
  79 }
  80
  81 struct TraceType {
  82   std::string system;
  83   std::string name;
  84 };
  85
  86 class TracingFile {
  87  public:
  88   TracingFile();
  89   bool RecordHeaderFiles();
  90   void RecordFtraceFiles(const std::vector<TraceType>& trace_types);
  91   bool RecordEventFiles(const std::vector<TraceType>& trace_types);
  92   bool RecordKallsymsFile();
  93   bool RecordPrintkFormatsFile();
  94   std::vector<char> BinaryFormat() const;
  95   void LoadFromBinary(const std::vector<char>& data);
  96   void Dump(size_t indent) const;
  97   std::vector<TracingFormat> LoadTracingFormatsFromEventFiles() const;
  98   const std::string& GetKallsymsFile() const { return kallsyms_file; }
  99   uint32_t GetPageSize() const { return page_size; }
 100
 101  private:
 102   char magic[10];
 103   std::string version;
 104   char endian;
 105   uint8_t size_of_long;
 106   uint32_t page_size;
 107   std::string header_page_file;
 108   std::string header_event_file;
 109
 110   std::vector<std::string> ftrace_format_files;
 111   // pair of system, format_file_data.
 112   std::vector<std::pair<std::string, std::string>> event_format_files;
 113
 114   std::string kallsyms_file;
 115   std::string printk_formats_file;
 116 };
 117
 118 TracingFile::TracingFile() {
 119   memcpy(magic, TRACING_INFO_MAGIC, sizeof(TRACING_INFO_MAGIC));
 120   version = "0.5";
 121   endian = 0;
 122   size_of_long = static_cast<int>(sizeof(long));
 123   page_size = static_cast<uint32_t>(::GetPageSize());
 124 }
 125
 126 bool TracingFile::RecordHeaderFiles() {
 127   if (!android::base::ReadFileToString(
 128           "/sys/kernel/debug/tracing/events/header_page", &header_page_file)) {
 129     PLOG(ERROR)
 130         << "failed to read /sys/kernel/debug/tracing/events/header_page";
 131     return false;
 132   }
 133   if (!android::base::ReadFileToString(
 134           "/sys/kernel/debug/tracing/events/header_event",
 135           &header_event_file)) {
 136     PLOG(ERROR)
 137         << "failed to read /sys/kernel/debug/tracing/events/header_event";
 138     return false;
 139   }
 140   return true;
 141 }
 142
 143 void TracingFile::RecordFtraceFiles(const std::vector<TraceType>& trace_types) {
 144   for (const auto& type : trace_types) {
 145     std::string format_path = android::base::StringPrintf(
 146         "/sys/kernel/debug/tracing/events/ftrace/%s/format", type.name.c_str());
 147     std::string format_data;
 148     if (android::base::ReadFileToString(format_path, &format_data)) {
 149       ftrace_format_files.push_back(std::move(format_data));
 150     }
 151   }
 152 }
 153
 154 bool TracingFile::RecordEventFiles(const std::vector<TraceType>& trace_types) {
 155   for (const auto& type : trace_types) {
 156     std::string format_path = android::base::StringPrintf(
 157         "/sys/kernel/debug/tracing/events/%s/%s/format", type.system.c_str(),
 158         type.name.c_str());
 159     std::string format_data;
 160     if (!android::base::ReadFileToString(format_path, &format_data)) {
 161       PLOG(ERROR) << "failed to read " << format_path;
 162       return false;
 163     }
 164     event_format_files.push_back(
 165         std::make_pair(type.system, std::move(format_data)));
 166   }
 167   return true;
 168 }
 169
 170 bool TracingFile::RecordPrintkFormatsFile() {
 171   if (!android::base::ReadFileToString(
 172           "/sys/kernel/debug/tracing/printk_formats", &printk_formats_file)) {
 173     PLOG(ERROR) << "failed to read /sys/kernel/debug/tracing/printk_formats";
 174     return false;
 175   }
 176   return true;
 177 }
 178
 179 std::vector<char> TracingFile::BinaryFormat() const {
 180   std::vector<char> ret;
 181   ret.insert(ret.end(), magic, magic + sizeof(magic));
 182   AppendData(ret, version);
 183   ret.push_back(endian);
 184   AppendData(ret, size_of_long);
 185   AppendData(ret, page_size);
 186   AppendData(ret, "header_page");
 187   AppendFile(ret, header_page_file);
 188   AppendData(ret, "header_event");
 189   AppendFile(ret, header_event_file);
 190   int count = static_cast<int>(ftrace_format_files.size());
 191   AppendData(ret, count);
 192   for (const auto& format : ftrace_format_files) {
 193     AppendFile(ret, format);
 194   }
 195   count = static_cast<int>(event_format_files.size());
 196   AppendData(ret, count);
 197   for (const auto& pair : event_format_files) {
 198     AppendData(ret, pair.first);
 199     AppendData(ret, 1);
 200     AppendFile(ret, pair.second);
 201   }
 202   AppendFile(ret, kallsyms_file, 4);
 203   AppendFile(ret, printk_formats_file, 4);
 204   return ret;
 205 }
 206
 207 void TracingFile::LoadFromBinary(const std::vector<char>& data) {
 208   const char* p = data.data();
 209   const char* end = data.data() + data.size();
 210   CHECK(memcmp(p, magic, sizeof(magic)) == 0);
 211   p += sizeof(magic);
 212   MoveFromBinaryFormat(version, p);
 213   MoveFromBinaryFormat(endian, p);
 214   MoveFromBinaryFormat(size_of_long, p);
 215   MoveFromBinaryFormat(page_size, p);
 216   std::string filename;
 217   MoveFromBinaryFormat(filename, p);
 218   CHECK_EQ(filename, "header_page");
 219   DetachFile(p, header_page_file);
 220   MoveFromBinaryFormat(filename, p);
 221   CHECK_EQ(filename, "header_event");
 222   DetachFile(p, header_event_file);
 223   uint32_t count;
 224   MoveFromBinaryFormat(count, p);
 225   ftrace_format_files.resize(count);
 226   for (uint32_t i = 0; i < count; ++i) {
 227     DetachFile(p, ftrace_format_files[i]);
 228   }
 229   MoveFromBinaryFormat(count, p);
 230   event_format_files.clear();
 231   for (uint32_t i = 0; i < count; ++i) {
 232     std::string system;
 233     MoveFromBinaryFormat(system, p);
 234     uint32_t count_in_system;
 235     MoveFromBinaryFormat(count_in_system, p);
 236     for (uint32_t i = 0; i < count_in_system; ++i) {
 237       std::string format;
 238       DetachFile(p, format);
 239       event_format_files.push_back(std::make_pair(system, std::move(format)));
 240     }
 241   }
 242   DetachFile(p, kallsyms_file, 4);
 243   DetachFile(p, printk_formats_file, 4);
 244   CHECK_EQ(p, end);
 245 }
 246
 247 void TracingFile::Dump(size_t indent) const {
 248   PrintIndented(indent, "tracing data:\n");
 249   PrintIndented(indent + 1, "magic: ");
 250   for (size_t i = 0; i < 3u; ++i) {
 251     printf("0x%x ", magic[i]);
 252   }
 253   for (size_t i = 3; i < sizeof(magic); ++i) {
 254     printf("%c", magic[i]);
 255   }
 256   printf("\n");
 257   PrintIndented(indent + 1, "version: %s\n", version.c_str());
 258   PrintIndented(indent + 1, "endian: %d\n", endian);
 259   PrintIndented(indent + 1, "header_page:\n%s\n\n", header_page_file.c_str());
 260   PrintIndented(indent + 1, "header_event:\n%s\n\n", header_event_file.c_str());
 261   for (size_t i = 0; i < ftrace_format_files.size(); ++i) {
 262     PrintIndented(indent + 1, "ftrace format file %zu/%zu:\n%s\n\n", i + 1,
 263                   ftrace_format_files.size(), ftrace_format_files[i].c_str());
 264   }
 265   for (size_t i = 0; i < event_format_files.size(); ++i) {
 266     PrintIndented(indent + 1, "event format file %zu/%zu %s:\n%s\n\n", i + 1,
 267                   event_format_files.size(),
 268                   event_format_files[i].first.c_str(),
 269                   event_format_files[i].second.c_str());
 270   }
 271   PrintIndented(indent + 1, "kallsyms:\n%s\n\n", kallsyms_file.c_str());
 272   PrintIndented(indent + 1, "printk_formats:\n%s\n\n",
 273                 printk_formats_file.c_str());
 274 }
 275
 276 enum class FormatParsingState {
 277   READ_NAME,
 278   READ_ID,
 279   READ_FIELDS,
 280   READ_PRINTFMT,
 281 };
 282
 283 // Parse lines like: field:char comm[16]; offset:8; size:16;  signed:1;
 284 static TracingField ParseTracingField(const std::string& s) {
 285   TracingField field;
 286   size_t start = 0;
 287   std::string name;
 288   std::string value;
 289   for (size_t i = 0; i < s.size(); ++i) {
 290     if (!isspace(s[i]) && (i == 0 || isspace(s[i - 1]))) {
 291       start = i;
 292     } else if (s[i] == ':') {
 293       name = s.substr(start, i - start);
 294       start = i + 1;
 295     } else if (s[i] == ';') {
 296       value = s.substr(start, i - start);
 297       if (name == "field") {
 298         size_t pos = value.find_first_of('[');
 299         if (pos == std::string::npos) {
 300           field.name = value;
 301           field.elem_count = 1;
 302         } else {
 303           field.name = value.substr(0, pos);
 304           field.elem_count =
 305               static_cast<size_t>(strtoull(&value[pos + 1], nullptr, 10));
 306         }
 307       } else if (name == "offset") {
 308         field.offset =
 309             static_cast<size_t>(strtoull(value.c_str(), nullptr, 10));
 310       } else if (name == "size") {
 311         size_t size = static_cast<size_t>(strtoull(value.c_str(), nullptr, 10));
 312         CHECK_EQ(size % field.elem_count, 0u);
 313         field.elem_size = size / field.elem_count;
 314       } else if (name == "signed") {
 315         int is_signed = static_cast<int>(strtoull(value.c_str(), nullptr, 10));
 316         field.is_signed = (is_signed == 1);
 317       }
 318     }
 319   }
 320   return field;
 321 }
 322
 323 std::vector<TracingFormat> TracingFile::LoadTracingFormatsFromEventFiles()
 324     const {
 325   std::vector<TracingFormat> formats;
 326   for (const auto& pair : event_format_files) {
 327     TracingFormat format;
 328     format.system_name = pair.first;
 329     std::vector<std::string> strs = android::base::Split(pair.second, "\n");
 330     FormatParsingState state = FormatParsingState::READ_NAME;
 331     for (const auto& s : strs) {
 332       if (state == FormatParsingState::READ_NAME) {
 333         size_t pos = s.find_first_of("name:");
 334         if (pos != std::string::npos) {
 335           format.name = android::base::Trim(s.substr(pos + strlen("name:")));
 336           state = FormatParsingState::READ_ID;
 337         }
 338       } else if (state == FormatParsingState::READ_ID) {
 339         size_t pos = s.find_first_of("ID:");
 340         if (pos != std::string::npos) {
 341           format.id =
 342               strtoull(s.substr(pos + strlen("ID:")).c_str(), nullptr, 10);
 343           state = FormatParsingState::READ_FIELDS;
 344         }
 345       } else if (state == FormatParsingState::READ_FIELDS) {
 346         size_t pos = s.find_first_of("field:");
 347         if (pos != std::string::npos) {
 348           TracingField field = ParseTracingField(s);
 349           format.fields.push_back(field);
 350         }
 351       }
 352     }
 353     formats.push_back(format);
 354   }
 355   return formats;
 356 }
 357
 358 Tracing::Tracing(const std::vector<char>& data) {
 359   tracing_file_ = new TracingFile;
 360   tracing_file_->LoadFromBinary(data);
 361 }
 362
 363 Tracing::~Tracing() { delete tracing_file_; }
 364
 365 void Tracing::Dump(size_t indent) { tracing_file_->Dump(indent); }
 366
 367 TracingFormat Tracing::GetTracingFormatHavingId(uint64_t trace_event_id) {
 368   if (tracing_formats_.empty()) {
 369     tracing_formats_ = tracing_file_->LoadTracingFormatsFromEventFiles();
 370   }
 371   for (const auto& format : tracing_formats_) {
 372     if (format.id == trace_event_id) {
 373       return format;
 374     }
 375   }
 376   LOG(FATAL) << "no tracing format for id " << trace_event_id;
 377   return TracingFormat();
 378 }
 379
 380 std::string Tracing::GetTracingEventNameHavingId(uint64_t trace_event_id) {
 381   if (tracing_formats_.empty()) {
 382     tracing_formats_ = tracing_file_->LoadTracingFormatsFromEventFiles();
 383   }
 384   for (const auto& format : tracing_formats_) {
 385     if (format.id == trace_event_id) {
 386       return android::base::StringPrintf("%s:%s", format.system_name.c_str(),
 387                                          format.name.c_str());
 388     }
 389   }
 390   return "";
 391 }
 392
 393 const std::string& Tracing::GetKallsyms() const {
 394   return tracing_file_->GetKallsymsFile();
 395 }
 396
 397 uint32_t Tracing::GetPageSize() const { return tracing_file_->GetPageSize(); }
 398
 399 bool GetTracingData(const std::vector<const EventType*>& event_types,
 400                     std::vector<char>* data) {
 401   data->clear();
 402   std::vector<TraceType> trace_types;
 403   for (const auto& type : event_types) {
 404     CHECK_EQ(PERF_TYPE_TRACEPOINT, type->type);
 405     size_t pos = type->name.find(':');
 406     TraceType trace_type;
 407     trace_type.system = type->name.substr(0, pos);
 408     trace_type.name = type->name.substr(pos + 1);
 409     trace_types.push_back(trace_type);
 410   }
 411   TracingFile tracing_file;
 412   if (!tracing_file.RecordHeaderFiles()) {
 413     return false;
 414   }
 415   tracing_file.RecordFtraceFiles(trace_types);
 416   if (!tracing_file.RecordEventFiles(trace_types)) {
 417     return false;
 418   }
 419   // Don't record /proc/kallsyms here, as it will be contained in
 420   // KernelSymbolRecord.
 421   if (!tracing_file.RecordPrintkFormatsFile()) {
 422     return false;
 423   }
 424   *data = tracing_file.BinaryFormat();
 425   return true;
 426 }