1 /* 2 * Copyright (C) 2015 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 "record.h" 18 19 #include <inttypes.h> 20 #include <algorithm> 21 #include <unordered_map> 22 23 #include <android-base/logging.h> 24 #include <android-base/stringprintf.h> 25 26 #include "dso.h" 27 #include "OfflineUnwinder.h" 28 #include "perf_regs.h" 29 #include "tracing.h" 30 #include "utils.h" 31 32 using namespace simpleperf; 33 34 static std::string RecordTypeToString(int record_type) { 35 static std::unordered_map<int, std::string> record_type_names = { 36 {PERF_RECORD_MMAP, "mmap"}, 37 {PERF_RECORD_LOST, "lost"}, 38 {PERF_RECORD_COMM, "comm"}, 39 {PERF_RECORD_EXIT, "exit"}, 40 {PERF_RECORD_THROTTLE, "throttle"}, 41 {PERF_RECORD_UNTHROTTLE, "unthrottle"}, 42 {PERF_RECORD_FORK, "fork"}, 43 {PERF_RECORD_READ, "read"}, 44 {PERF_RECORD_SAMPLE, "sample"}, 45 {PERF_RECORD_BUILD_ID, "build_id"}, 46 {PERF_RECORD_MMAP2, "mmap2"}, 47 {PERF_RECORD_TRACING_DATA, "tracing_data"}, 48 {SIMPLE_PERF_RECORD_KERNEL_SYMBOL, "kernel_symbol"}, 49 {SIMPLE_PERF_RECORD_DSO, "dso"}, 50 {SIMPLE_PERF_RECORD_SYMBOL, "symbol"}, 51 {SIMPLE_PERF_RECORD_EVENT_ID, "event_id"}, 52 {SIMPLE_PERF_RECORD_CALLCHAIN, "callchain"}, 53 {SIMPLE_PERF_RECORD_UNWINDING_RESULT, "unwinding_result"}, 54 }; 55 56 auto it = record_type_names.find(record_type); 57 if (it != record_type_names.end()) { 58 return it->second; 59 } 60 return android::base::StringPrintf("unknown(%d)", record_type); 61 } 62 63 template <> 64 void MoveToBinaryFormat(const RecordHeader& data, char*& p) { 65 data.MoveToBinaryFormat(p); 66 } 67 68 SampleId::SampleId() { memset(this, 0, sizeof(SampleId)); } 69 70 // Return sample_id size in binary format. 71 size_t SampleId::CreateContent(const perf_event_attr& attr, uint64_t event_id) { 72 sample_id_all = attr.sample_id_all; 73 sample_type = attr.sample_type; 74 id_data.id = event_id; 75 // Other data are not necessary. TODO: Set missing SampleId data. 76 return Size(); 77 } 78 79 void SampleId::ReadFromBinaryFormat(const perf_event_attr& attr, const char* p, 80 const char* end) { 81 sample_id_all = attr.sample_id_all; 82 sample_type = attr.sample_type; 83 if (sample_id_all) { 84 if (sample_type & PERF_SAMPLE_TID) { 85 MoveFromBinaryFormat(tid_data, p); 86 } 87 if (sample_type & PERF_SAMPLE_TIME) { 88 MoveFromBinaryFormat(time_data, p); 89 } 90 if (sample_type & PERF_SAMPLE_ID) { 91 MoveFromBinaryFormat(id_data, p); 92 } 93 if (sample_type & PERF_SAMPLE_STREAM_ID) { 94 MoveFromBinaryFormat(stream_id_data, p); 95 } 96 if (sample_type & PERF_SAMPLE_CPU) { 97 MoveFromBinaryFormat(cpu_data, p); 98 } 99 if (sample_type & PERF_SAMPLE_IDENTIFIER) { 100 MoveFromBinaryFormat(id_data, p); 101 } 102 } 103 CHECK_LE(p, end); 104 if (p < end) { 105 LOG(DEBUG) << "Record SampleId part has " << end - p << " bytes left\n"; 106 } 107 } 108 109 void SampleId::WriteToBinaryFormat(char*& p) const { 110 if (sample_id_all) { 111 if (sample_type & PERF_SAMPLE_TID) { 112 MoveToBinaryFormat(tid_data, p); 113 } 114 if (sample_type & PERF_SAMPLE_TIME) { 115 MoveToBinaryFormat(time_data, p); 116 } 117 if (sample_type & PERF_SAMPLE_ID) { 118 MoveToBinaryFormat(id_data, p); 119 } 120 if (sample_type & PERF_SAMPLE_STREAM_ID) { 121 MoveToBinaryFormat(stream_id_data, p); 122 } 123 if (sample_type & PERF_SAMPLE_CPU) { 124 MoveToBinaryFormat(cpu_data, p); 125 } 126 } 127 } 128 129 void SampleId::Dump(size_t indent) const { 130 if (sample_id_all) { 131 if (sample_type & PERF_SAMPLE_TID) { 132 PrintIndented(indent, "sample_id: pid %u, tid %u\n", tid_data.pid, 133 tid_data.tid); 134 } 135 if (sample_type & PERF_SAMPLE_TIME) { 136 PrintIndented(indent, "sample_id: time %" PRId64 "\n", time_data.time); 137 } 138 if (sample_type & (PERF_SAMPLE_ID | PERF_SAMPLE_IDENTIFIER)) { 139 PrintIndented(indent, "sample_id: id %" PRId64 "\n", id_data.id); 140 } 141 if (sample_type & PERF_SAMPLE_STREAM_ID) { 142 PrintIndented(indent, "sample_id: stream_id %" PRId64 "\n", 143 stream_id_data.stream_id); 144 } 145 if (sample_type & PERF_SAMPLE_CPU) { 146 PrintIndented(indent, "sample_id: cpu %u, res %u\n", cpu_data.cpu, 147 cpu_data.res); 148 } 149 } 150 } 151 152 size_t SampleId::Size() const { 153 size_t size = 0; 154 if (sample_id_all) { 155 if (sample_type & PERF_SAMPLE_TID) { 156 size += sizeof(PerfSampleTidType); 157 } 158 if (sample_type & PERF_SAMPLE_TIME) { 159 size += sizeof(PerfSampleTimeType); 160 } 161 if (sample_type & PERF_SAMPLE_ID) { 162 size += sizeof(PerfSampleIdType); 163 } 164 if (sample_type & PERF_SAMPLE_STREAM_ID) { 165 size += sizeof(PerfSampleStreamIdType); 166 } 167 if (sample_type & PERF_SAMPLE_CPU) { 168 size += sizeof(PerfSampleCpuType); 169 } 170 if (sample_type & PERF_SAMPLE_IDENTIFIER) { 171 size += sizeof(PerfSampleIdType); 172 } 173 } 174 return size; 175 } 176 177 Record::Record(Record&& other) { 178 header = other.header; 179 sample_id = other.sample_id; 180 binary_ = other.binary_; 181 own_binary_ = other.own_binary_; 182 other.binary_ = nullptr; 183 other.own_binary_ = false; 184 } 185 186 void Record::Dump(size_t indent) const { 187 PrintIndented(indent, "record %s: type %u, misc %u, size %u\n", 188 RecordTypeToString(type()).c_str(), type(), misc(), size()); 189 DumpData(indent + 1); 190 sample_id.Dump(indent + 1); 191 } 192 193 uint64_t Record::Timestamp() const { return sample_id.time_data.time; } 194 uint32_t Record::Cpu() const { return sample_id.cpu_data.cpu; } 195 uint64_t Record::Id() const { return sample_id.id_data.id; } 196 197 void Record::UpdateBinary(char* new_binary) { 198 if (own_binary_) { 199 delete[] binary_; 200 } 201 own_binary_ = true; 202 binary_ = new_binary; 203 } 204 205 MmapRecord::MmapRecord(const perf_event_attr& attr, char* p) : Record(p) { 206 const char* end = p + size(); 207 p += header_size(); 208 data = reinterpret_cast<const MmapRecordDataType*>(p); 209 p += sizeof(*data); 210 filename = p; 211 p += Align(strlen(filename) + 1, 8); 212 CHECK_LE(p, end); 213 sample_id.ReadFromBinaryFormat(attr, p, end); 214 } 215 216 MmapRecord::MmapRecord(const perf_event_attr& attr, bool in_kernel, 217 uint32_t pid, uint32_t tid, uint64_t addr, uint64_t len, 218 uint64_t pgoff, const std::string& filename, 219 uint64_t event_id, uint64_t time) { 220 SetTypeAndMisc(PERF_RECORD_MMAP, 221 in_kernel ? PERF_RECORD_MISC_KERNEL : PERF_RECORD_MISC_USER); 222 sample_id.CreateContent(attr, event_id); 223 sample_id.time_data.time = time; 224 MmapRecordDataType data; 225 data.pid = pid; 226 data.tid = tid; 227 data.addr = addr; 228 data.len = len; 229 data.pgoff = pgoff; 230 SetDataAndFilename(data, filename); 231 } 232 233 void MmapRecord::SetDataAndFilename(const MmapRecordDataType& data, 234 const std::string& filename) { 235 SetSize(header_size() + sizeof(data) + Align(filename.size() + 1, 8) + 236 sample_id.Size()); 237 char* new_binary = new char[size()]; 238 char* p = new_binary; 239 MoveToBinaryFormat(header, p); 240 this->data = reinterpret_cast<MmapRecordDataType*>(p); 241 MoveToBinaryFormat(data, p); 242 this->filename = p; 243 strcpy(p, filename.c_str()); 244 p += Align(filename.size() + 1, 8); 245 sample_id.WriteToBinaryFormat(p); 246 UpdateBinary(new_binary); 247 } 248 249 void MmapRecord::DumpData(size_t indent) const { 250 PrintIndented(indent, 251 "pid %u, tid %u, addr 0x%" PRIx64 ", len 0x%" PRIx64 "\n", 252 data->pid, data->tid, data->addr, data->len); 253 PrintIndented(indent, "pgoff 0x%" PRIx64 ", filename %s\n", data->pgoff, 254 filename); 255 } 256 257 Mmap2Record::Mmap2Record(const perf_event_attr& attr, char* p) : Record(p) { 258 const char* end = p + size(); 259 p += header_size(); 260 data = reinterpret_cast<const Mmap2RecordDataType*>(p); 261 p += sizeof(*data); 262 filename = p; 263 p += Align(strlen(filename) + 1, 8); 264 CHECK_LE(p, end); 265 sample_id.ReadFromBinaryFormat(attr, p, end); 266 } 267 268 void Mmap2Record::SetDataAndFilename(const Mmap2RecordDataType& data, 269 const std::string& filename) { 270 SetSize(header_size() + sizeof(data) + Align(filename.size() + 1, 8) + 271 sample_id.Size()); 272 char* new_binary = new char[size()]; 273 char* p = new_binary; 274 MoveToBinaryFormat(header, p); 275 this->data = reinterpret_cast<Mmap2RecordDataType*>(p); 276 MoveToBinaryFormat(data, p); 277 this->filename = p; 278 strcpy(p, filename.c_str()); 279 p += Align(filename.size() + 1, 8); 280 sample_id.WriteToBinaryFormat(p); 281 UpdateBinary(new_binary); 282 } 283 284 void Mmap2Record::DumpData(size_t indent) const { 285 PrintIndented(indent, 286 "pid %u, tid %u, addr 0x%" PRIx64 ", len 0x%" PRIx64 "\n", 287 data->pid, data->tid, data->addr, data->len); 288 PrintIndented(indent, "pgoff 0x" PRIx64 ", maj %u, min %u, ino %" PRId64 289 ", ino_generation %" PRIu64 "\n", 290 data->pgoff, data->maj, data->min, data->ino, 291 data->ino_generation); 292 PrintIndented(indent, "prot %u, flags %u, filenames %s\n", data->prot, 293 data->flags, filename); 294 } 295 296 CommRecord::CommRecord(const perf_event_attr& attr, char* p) : Record(p) { 297 const char* end = p + size(); 298 p += header_size(); 299 data = reinterpret_cast<const CommRecordDataType*>(p); 300 p += sizeof(*data); 301 comm = p; 302 p += Align(strlen(p) + 1, 8); 303 CHECK_LE(p, end); 304 sample_id.ReadFromBinaryFormat(attr, p, end); 305 } 306 307 CommRecord::CommRecord(const perf_event_attr& attr, uint32_t pid, uint32_t tid, 308 const std::string& comm, uint64_t event_id, uint64_t time) { 309 SetTypeAndMisc(PERF_RECORD_COMM, 0); 310 CommRecordDataType data; 311 data.pid = pid; 312 data.tid = tid; 313 size_t sample_id_size = sample_id.CreateContent(attr, event_id); 314 sample_id.time_data.time = time; 315 SetSize(header_size() + sizeof(data) + Align(comm.size() + 1, 8) + 316 sample_id_size); 317 char* new_binary = new char[size()]; 318 char* p = new_binary; 319 MoveToBinaryFormat(header, p); 320 this->data = reinterpret_cast<CommRecordDataType*>(p); 321 MoveToBinaryFormat(data, p); 322 this->comm = p; 323 strcpy(p, comm.c_str()); 324 p += Align(comm.size() + 1, 8); 325 sample_id.WriteToBinaryFormat(p); 326 UpdateBinary(new_binary); 327 } 328 329 void CommRecord::DumpData(size_t indent) const { 330 PrintIndented(indent, "pid %u, tid %u, comm %s\n", data->pid, data->tid, 331 comm); 332 } 333 334 ExitOrForkRecord::ExitOrForkRecord(const perf_event_attr& attr, char* p) 335 : Record(p) { 336 const char* end = p + size(); 337 p += header_size(); 338 data = reinterpret_cast<const ExitOrForkRecordDataType*>(p); 339 p += sizeof(*data); 340 CHECK_LE(p, end); 341 sample_id.ReadFromBinaryFormat(attr, p, end); 342 } 343 344 void ExitOrForkRecord::DumpData(size_t indent) const { 345 PrintIndented(indent, "pid %u, ppid %u, tid %u, ptid %u\n", data->pid, 346 data->ppid, data->tid, data->ptid); 347 } 348 349 ForkRecord::ForkRecord(const perf_event_attr& attr, uint32_t pid, uint32_t tid, 350 uint32_t ppid, uint32_t ptid, uint64_t event_id) { 351 SetTypeAndMisc(PERF_RECORD_FORK, 0); 352 ExitOrForkRecordDataType data; 353 data.pid = pid; 354 data.ppid = ppid; 355 data.tid = tid; 356 data.ptid = ptid; 357 data.time = 0; 358 size_t sample_id_size = sample_id.CreateContent(attr, event_id); 359 SetSize(header_size() + sizeof(data) + sample_id_size); 360 char* new_binary = new char[size()]; 361 char* p = new_binary; 362 MoveToBinaryFormat(header, p); 363 this->data = reinterpret_cast<ExitOrForkRecordDataType*>(p); 364 MoveToBinaryFormat(data, p); 365 sample_id.WriteToBinaryFormat(p); 366 UpdateBinary(new_binary); 367 } 368 369 LostRecord::LostRecord(const perf_event_attr& attr, char* p) : Record(p) { 370 const char* end = p + size(); 371 p += header_size(); 372 MoveFromBinaryFormat(id, p); 373 MoveFromBinaryFormat(lost, p); 374 CHECK_LE(p, end); 375 sample_id.ReadFromBinaryFormat(attr, p, end); 376 } 377 378 void LostRecord::DumpData(size_t indent) const { 379 PrintIndented(indent, "id %" PRIu64 ", lost %" PRIu64 "\n", id, lost); 380 } 381 382 SampleRecord::SampleRecord(const perf_event_attr& attr, char* p) : Record(p) { 383 const char* end = p + size(); 384 p += header_size(); 385 sample_type = attr.sample_type; 386 387 // Set a default id value to report correctly even if ID is not recorded. 388 id_data.id = 0; 389 if (sample_type & PERF_SAMPLE_IDENTIFIER) { 390 MoveFromBinaryFormat(id_data, p); 391 } 392 if (sample_type & PERF_SAMPLE_IP) { 393 MoveFromBinaryFormat(ip_data, p); 394 } 395 if (sample_type & PERF_SAMPLE_TID) { 396 MoveFromBinaryFormat(tid_data, p); 397 } 398 if (sample_type & PERF_SAMPLE_TIME) { 399 MoveFromBinaryFormat(time_data, p); 400 } 401 if (sample_type & PERF_SAMPLE_ADDR) { 402 MoveFromBinaryFormat(addr_data, p); 403 } 404 if (sample_type & PERF_SAMPLE_ID) { 405 MoveFromBinaryFormat(id_data, p); 406 } 407 if (sample_type & PERF_SAMPLE_STREAM_ID) { 408 MoveFromBinaryFormat(stream_id_data, p); 409 } 410 if (sample_type & PERF_SAMPLE_CPU) { 411 MoveFromBinaryFormat(cpu_data, p); 412 } 413 if (sample_type & PERF_SAMPLE_PERIOD) { 414 MoveFromBinaryFormat(period_data, p); 415 } 416 if (sample_type & PERF_SAMPLE_CALLCHAIN) { 417 MoveFromBinaryFormat(callchain_data.ip_nr, p); 418 callchain_data.ips = reinterpret_cast<uint64_t*>(p); 419 p += callchain_data.ip_nr * sizeof(uint64_t); 420 } 421 if (sample_type & PERF_SAMPLE_RAW) { 422 MoveFromBinaryFormat(raw_data.size, p); 423 raw_data.data = p; 424 p += raw_data.size; 425 } 426 if (sample_type & PERF_SAMPLE_BRANCH_STACK) { 427 MoveFromBinaryFormat(branch_stack_data.stack_nr, p); 428 branch_stack_data.stack = reinterpret_cast<BranchStackItemType*>(p); 429 p += branch_stack_data.stack_nr * sizeof(BranchStackItemType); 430 } 431 if (sample_type & PERF_SAMPLE_REGS_USER) { 432 MoveFromBinaryFormat(regs_user_data.abi, p); 433 if (regs_user_data.abi == 0) { 434 regs_user_data.reg_mask = 0; 435 } else { 436 regs_user_data.reg_mask = attr.sample_regs_user; 437 size_t bit_nr = 0; 438 for (size_t i = 0; i < 64; ++i) { 439 if ((regs_user_data.reg_mask >> i) & 1) { 440 bit_nr++; 441 } 442 } 443 regs_user_data.reg_nr = bit_nr; 444 regs_user_data.regs = reinterpret_cast<uint64_t*>(p); 445 p += bit_nr * sizeof(uint64_t); 446 } 447 } 448 if (sample_type & PERF_SAMPLE_STACK_USER) { 449 MoveFromBinaryFormat(stack_user_data.size, p); 450 if (stack_user_data.size == 0) { 451 stack_user_data.dyn_size = 0; 452 } else { 453 stack_user_data.data = p; 454 p += stack_user_data.size; 455 MoveFromBinaryFormat(stack_user_data.dyn_size, p); 456 } 457 } 458 // TODO: Add parsing of other PERF_SAMPLE_*. 459 CHECK_LE(p, end); 460 if (p < end) { 461 LOG(DEBUG) << "Record has " << end - p << " bytes left\n"; 462 } 463 } 464 465 SampleRecord::SampleRecord(const perf_event_attr& attr, uint64_t id, 466 uint64_t ip, uint32_t pid, uint32_t tid, 467 uint64_t time, uint32_t cpu, uint64_t period, 468 const std::vector<uint64_t>& ips) { 469 SetTypeAndMisc(PERF_RECORD_SAMPLE, PERF_RECORD_MISC_USER); 470 sample_type = attr.sample_type; 471 CHECK_EQ(0u, sample_type & ~(PERF_SAMPLE_IP | PERF_SAMPLE_TID 472 | PERF_SAMPLE_TIME | PERF_SAMPLE_ID | PERF_SAMPLE_CPU 473 | PERF_SAMPLE_PERIOD | PERF_SAMPLE_CALLCHAIN | PERF_SAMPLE_REGS_USER 474 | PERF_SAMPLE_STACK_USER)); 475 ip_data.ip = ip; 476 tid_data.pid = pid; 477 tid_data.tid = tid; 478 time_data.time = time; 479 id_data.id = id; 480 cpu_data.cpu = cpu; 481 cpu_data.res = 0; 482 period_data.period = period; 483 callchain_data.ip_nr = ips.size(); 484 raw_data.size = 0; 485 branch_stack_data.stack_nr = 0; 486 regs_user_data.abi = 0; 487 regs_user_data.reg_mask = 0; 488 stack_user_data.size = 0; 489 490 uint32_t size = header_size(); 491 if (sample_type & PERF_SAMPLE_IP) { 492 size += sizeof(ip_data); 493 } 494 if (sample_type & PERF_SAMPLE_TID) { 495 size += sizeof(tid_data); 496 } 497 if (sample_type & PERF_SAMPLE_TIME) { 498 size += sizeof(time_data); 499 } 500 if (sample_type & PERF_SAMPLE_ID) { 501 size += sizeof(id_data); 502 } 503 if (sample_type & PERF_SAMPLE_CPU) { 504 size += sizeof(cpu_data); 505 } 506 if (sample_type & PERF_SAMPLE_PERIOD) { 507 size += sizeof(period_data); 508 } 509 if (sample_type & PERF_SAMPLE_CALLCHAIN) { 510 size += sizeof(uint64_t) * (ips.size() + 1); 511 } 512 if (sample_type & PERF_SAMPLE_REGS_USER) { 513 size += sizeof(uint64_t); 514 } 515 if (sample_type & PERF_SAMPLE_STACK_USER) { 516 size += sizeof(uint64_t); 517 } 518 519 SetSize(size); 520 char* new_binary = new char[size]; 521 char* p = new_binary; 522 MoveToBinaryFormat(header, p); 523 if (sample_type & PERF_SAMPLE_IP) { 524 MoveToBinaryFormat(ip_data, p); 525 } 526 if (sample_type & PERF_SAMPLE_TID) { 527 MoveToBinaryFormat(tid_data, p); 528 } 529 if (sample_type & PERF_SAMPLE_TIME) { 530 MoveToBinaryFormat(time_data, p); 531 } 532 if (sample_type & PERF_SAMPLE_ID) { 533 MoveToBinaryFormat(id_data, p); 534 } 535 if (sample_type & PERF_SAMPLE_CPU) { 536 MoveToBinaryFormat(cpu_data, p); 537 } 538 if (sample_type & PERF_SAMPLE_PERIOD) { 539 MoveToBinaryFormat(period_data, p); 540 } 541 if (sample_type & PERF_SAMPLE_CALLCHAIN) { 542 MoveToBinaryFormat(callchain_data.ip_nr, p); 543 callchain_data.ips = reinterpret_cast<uint64_t*>(p); 544 MoveToBinaryFormat(ips.data(), ips.size(), p); 545 } 546 if (sample_type & PERF_SAMPLE_REGS_USER) { 547 MoveToBinaryFormat(regs_user_data.abi, p); 548 } 549 if (sample_type & PERF_SAMPLE_STACK_USER) { 550 MoveToBinaryFormat(stack_user_data.size, p); 551 } 552 CHECK_EQ(p, new_binary + size); 553 UpdateBinary(new_binary); 554 } 555 556 void SampleRecord::ReplaceRegAndStackWithCallChain( 557 const std::vector<uint64_t>& ips) { 558 uint32_t size_added_in_callchain = sizeof(uint64_t) * (ips.size() + 1); 559 uint32_t size_reduced_in_reg_stack = 560 regs_user_data.reg_nr * sizeof(uint64_t) + stack_user_data.size + 561 sizeof(uint64_t); 562 CHECK_LE(size_added_in_callchain, size_reduced_in_reg_stack); 563 uint32_t size_reduced = size_reduced_in_reg_stack - size_added_in_callchain; 564 SetSize(size() - size_reduced); 565 char* p = binary_; 566 MoveToBinaryFormat(header, p); 567 p = (stack_user_data.data + stack_user_data.size + sizeof(uint64_t)) - 568 (size_reduced_in_reg_stack - size_added_in_callchain); 569 stack_user_data.size = 0; 570 regs_user_data.abi = 0; 571 p -= sizeof(uint64_t); 572 *reinterpret_cast<uint64_t*>(p) = stack_user_data.size; 573 p -= sizeof(uint64_t); 574 *reinterpret_cast<uint64_t*>(p) = regs_user_data.abi; 575 if (sample_type & PERF_SAMPLE_BRANCH_STACK) { 576 p -= branch_stack_data.stack_nr * sizeof(BranchStackItemType); 577 memmove(p, branch_stack_data.stack, 578 branch_stack_data.stack_nr * sizeof(BranchStackItemType)); 579 p -= sizeof(uint64_t); 580 *reinterpret_cast<uint64_t*>(p) = branch_stack_data.stack_nr; 581 } 582 if (sample_type & PERF_SAMPLE_RAW) { 583 p -= raw_data.size; 584 memmove(p, raw_data.data, raw_data.size); 585 p -= sizeof(uint32_t); 586 *reinterpret_cast<uint32_t*>(p) = raw_data.size; 587 } 588 p -= ips.size() * sizeof(uint64_t); 589 memcpy(p, ips.data(), ips.size() * sizeof(uint64_t)); 590 p -= sizeof(uint64_t); 591 *reinterpret_cast<uint64_t*>(p) = PERF_CONTEXT_USER; 592 p -= sizeof(uint64_t) * (callchain_data.ip_nr); 593 callchain_data.ips = reinterpret_cast<uint64_t*>(p); 594 callchain_data.ip_nr += ips.size() + 1; 595 p -= sizeof(uint64_t); 596 *reinterpret_cast<uint64_t*>(p) = callchain_data.ip_nr; 597 } 598 599 size_t SampleRecord::ExcludeKernelCallChain() { 600 size_t user_callchain_length = 0u; 601 if (sample_type & PERF_SAMPLE_CALLCHAIN) { 602 size_t i; 603 for (i = 0; i < callchain_data.ip_nr; ++i) { 604 if (callchain_data.ips[i] == PERF_CONTEXT_USER) { 605 i++; 606 if (i < callchain_data.ip_nr) { 607 ip_data.ip = callchain_data.ips[i]; 608 if (sample_type & PERF_SAMPLE_IP) { 609 *reinterpret_cast<uint64_t*>(binary_ + header_size()) = ip_data.ip; 610 } 611 header.misc = (header.misc & ~PERF_RECORD_MISC_KERNEL) | PERF_RECORD_MISC_USER; 612 reinterpret_cast<perf_event_header*>(binary_)->misc = header.misc; 613 } 614 break; 615 } else { 616 callchain_data.ips[i] = PERF_CONTEXT_USER; 617 } 618 } 619 user_callchain_length = callchain_data.ip_nr - i; 620 } 621 return user_callchain_length; 622 } 623 624 bool SampleRecord::HasUserCallChain() const { 625 if ((sample_type & PERF_SAMPLE_CALLCHAIN) == 0) { 626 return false; 627 } 628 bool in_user_context = !InKernel(); 629 for (size_t i = 0; i < callchain_data.ip_nr; ++i) { 630 if (in_user_context && callchain_data.ips[i] < PERF_CONTEXT_MAX) { 631 return true; 632 } 633 if (callchain_data.ips[i] == PERF_CONTEXT_USER) { 634 in_user_context = true; 635 } 636 } 637 return false; 638 } 639 640 void SampleRecord::UpdateUserCallChain(const std::vector<uint64_t>& user_ips) { 641 std::vector<uint64_t> kernel_ips; 642 for (size_t i = 0; i < callchain_data.ip_nr; ++i) { 643 if (callchain_data.ips[i] == PERF_CONTEXT_USER) { 644 break; 645 } 646 kernel_ips.push_back(callchain_data.ips[i]); 647 } 648 kernel_ips.push_back(PERF_CONTEXT_USER); 649 size_t new_size = size() - callchain_data.ip_nr * sizeof(uint64_t) + 650 (kernel_ips.size() + user_ips.size()) * sizeof(uint64_t); 651 if (new_size == size()) { 652 return; 653 } 654 char* new_binary = new char[new_size]; 655 char* p = new_binary; 656 SetSize(new_size); 657 MoveToBinaryFormat(header, p); 658 if (sample_type & PERF_SAMPLE_IDENTIFIER) { 659 MoveToBinaryFormat(id_data, p); 660 } 661 if (sample_type & PERF_SAMPLE_IP) { 662 MoveToBinaryFormat(ip_data, p); 663 } 664 if (sample_type & PERF_SAMPLE_TID) { 665 MoveToBinaryFormat(tid_data, p); 666 } 667 if (sample_type & PERF_SAMPLE_TIME) { 668 MoveToBinaryFormat(time_data, p); 669 } 670 if (sample_type & PERF_SAMPLE_ADDR) { 671 MoveToBinaryFormat(addr_data, p); 672 } 673 if (sample_type & PERF_SAMPLE_ID) { 674 MoveToBinaryFormat(id_data, p); 675 } 676 if (sample_type & PERF_SAMPLE_STREAM_ID) { 677 MoveToBinaryFormat(stream_id_data, p); 678 } 679 if (sample_type & PERF_SAMPLE_CPU) { 680 MoveToBinaryFormat(cpu_data, p); 681 } 682 if (sample_type & PERF_SAMPLE_PERIOD) { 683 MoveToBinaryFormat(period_data, p); 684 } 685 if (sample_type & PERF_SAMPLE_CALLCHAIN) { 686 callchain_data.ip_nr = kernel_ips.size() + user_ips.size(); 687 MoveToBinaryFormat(callchain_data.ip_nr, p); 688 callchain_data.ips = reinterpret_cast<uint64_t*>(p); 689 MoveToBinaryFormat(kernel_ips.data(), kernel_ips.size(), p); 690 MoveToBinaryFormat(user_ips.data(), user_ips.size(), p); 691 } 692 if (sample_type & PERF_SAMPLE_RAW) { 693 MoveToBinaryFormat(raw_data.size, p); 694 MoveToBinaryFormat(raw_data.data, raw_data.size, p); 695 raw_data.data = p - raw_data.size; 696 } 697 if (sample_type & PERF_SAMPLE_BRANCH_STACK) { 698 MoveToBinaryFormat(branch_stack_data.stack_nr, p); 699 char* old_p = p; 700 MoveToBinaryFormat(branch_stack_data.stack, branch_stack_data.stack_nr, p); 701 branch_stack_data.stack = reinterpret_cast<BranchStackItemType*>(old_p); 702 } 703 if (sample_type & PERF_SAMPLE_REGS_USER) { 704 MoveToBinaryFormat(regs_user_data.abi, p); 705 CHECK_EQ(regs_user_data.abi, 0u); 706 } 707 if (sample_type & PERF_SAMPLE_STACK_USER) { 708 MoveToBinaryFormat(stack_user_data.size, p); 709 CHECK_EQ(stack_user_data.size, 0u); 710 } 711 CHECK_EQ(p, new_binary + new_size) << "sample_type = " << std::hex << sample_type; 712 UpdateBinary(new_binary); 713 } 714 715 // When simpleperf requests the kernel to dump 64K stack per sample, it will allocate 64K space in 716 // each sample to store stack data. However, a thread may use less stack than 64K. So not all the 717 // 64K stack data in a sample is valid. And this function is used to remove invalid stack data in 718 // a sample, which can save time and disk space when storing samples in file. 719 void SampleRecord::RemoveInvalidStackData() { 720 if (sample_type & PERF_SAMPLE_STACK_USER) { 721 uint64_t valid_stack_size = GetValidStackSize(); 722 if (stack_user_data.size > valid_stack_size) { 723 // Shrink stack size to valid_stack_size, and update it in binary. 724 stack_user_data.size = valid_stack_size; 725 char* p = stack_user_data.data - sizeof(stack_user_data.size); 726 MoveToBinaryFormat(stack_user_data.size, p); 727 p += valid_stack_size; 728 // Update dyn_size in binary. 729 if (valid_stack_size != 0u) { 730 MoveToBinaryFormat(stack_user_data.dyn_size, p); 731 } 732 // Update sample size. 733 header.size = p - binary_; 734 p = binary_; 735 header.MoveToBinaryFormat(p); 736 } 737 } 738 } 739 740 void SampleRecord::DumpData(size_t indent) const { 741 PrintIndented(indent, "sample_type: 0x%" PRIx64 "\n", sample_type); 742 if (sample_type & PERF_SAMPLE_IP) { 743 PrintIndented(indent, "ip %p\n", reinterpret_cast<void*>(ip_data.ip)); 744 } 745 if (sample_type & PERF_SAMPLE_TID) { 746 PrintIndented(indent, "pid %u, tid %u\n", tid_data.pid, tid_data.tid); 747 } 748 if (sample_type & PERF_SAMPLE_TIME) { 749 PrintIndented(indent, "time %" PRId64 "\n", time_data.time); 750 } 751 if (sample_type & PERF_SAMPLE_ADDR) { 752 PrintIndented(indent, "addr %p\n", reinterpret_cast<void*>(addr_data.addr)); 753 } 754 if (sample_type & (PERF_SAMPLE_ID | PERF_SAMPLE_IDENTIFIER)) { 755 PrintIndented(indent, "id %" PRId64 "\n", id_data.id); 756 } 757 if (sample_type & PERF_SAMPLE_STREAM_ID) { 758 PrintIndented(indent, "stream_id %" PRId64 "\n", stream_id_data.stream_id); 759 } 760 if (sample_type & PERF_SAMPLE_CPU) { 761 PrintIndented(indent, "cpu %u, res %u\n", cpu_data.cpu, cpu_data.res); 762 } 763 if (sample_type & PERF_SAMPLE_PERIOD) { 764 PrintIndented(indent, "period %" PRId64 "\n", period_data.period); 765 } 766 if (sample_type & PERF_SAMPLE_CALLCHAIN) { 767 PrintIndented(indent, "callchain nr=%" PRIu64 "\n", callchain_data.ip_nr); 768 for (uint64_t i = 0; i < callchain_data.ip_nr; ++i) { 769 PrintIndented(indent + 1, "0x%" PRIx64 "\n", callchain_data.ips[i]); 770 } 771 } 772 if (sample_type & PERF_SAMPLE_RAW) { 773 PrintIndented(indent, "raw size=%zu\n", raw_data.size); 774 const uint32_t* data = reinterpret_cast<const uint32_t*>(raw_data.data); 775 size_t size = raw_data.size / sizeof(uint32_t); 776 for (size_t i = 0; i < size; ++i) { 777 PrintIndented(indent + 1, "0x%08x (%zu)\n", data[i], data[i]); 778 } 779 } 780 if (sample_type & PERF_SAMPLE_BRANCH_STACK) { 781 PrintIndented(indent, "branch_stack nr=%" PRIu64 "\n", 782 branch_stack_data.stack_nr); 783 for (uint64_t i = 0; i < branch_stack_data.stack_nr; ++i) { 784 auto& item = branch_stack_data.stack[i]; 785 PrintIndented(indent + 1, "from 0x%" PRIx64 ", to 0x%" PRIx64 786 ", flags 0x%" PRIx64 "\n", 787 item.from, item.to, item.flags); 788 } 789 } 790 if (sample_type & PERF_SAMPLE_REGS_USER) { 791 PrintIndented(indent, "user regs: abi=%" PRId64 "\n", regs_user_data.abi); 792 for (size_t i = 0, pos = 0; i < 64; ++i) { 793 if ((regs_user_data.reg_mask >> i) & 1) { 794 PrintIndented( 795 indent + 1, "reg (%s) 0x%016" PRIx64 "\n", 796 GetRegName(i, ScopedCurrentArch::GetCurrentArch()).c_str(), 797 regs_user_data.regs[pos++]); 798 } 799 } 800 } 801 if (sample_type & PERF_SAMPLE_STACK_USER) { 802 PrintIndented(indent, "user stack: size %zu dyn_size %" PRIu64 "\n", 803 stack_user_data.size, stack_user_data.dyn_size); 804 const uint64_t* p = reinterpret_cast<const uint64_t*>(stack_user_data.data); 805 const uint64_t* end = p + (stack_user_data.size / sizeof(uint64_t)); 806 while (p < end) { 807 PrintIndented(indent + 1, ""); 808 for (size_t i = 0; i < 4 && p < end; ++i, ++p) { 809 printf(" %016" PRIx64, *p); 810 } 811 printf("\n"); 812 } 813 printf("\n"); 814 } 815 } 816 817 uint64_t SampleRecord::Timestamp() const { return time_data.time; } 818 uint32_t SampleRecord::Cpu() const { return cpu_data.cpu; } 819 uint64_t SampleRecord::Id() const { return id_data.id; } 820 821 void SampleRecord::AdjustCallChainGeneratedByKernel() { 822 // The kernel stores return addrs in the callchain, but we want the addrs of call instructions 823 // along the callchain. 824 uint64_t* ips = callchain_data.ips; 825 bool first_frame = true; 826 for (uint64_t i = 0; i < callchain_data.ip_nr; ++i) { 827 if (ips[i] > 0 && ips[i] < PERF_CONTEXT_MAX) { 828 if (first_frame) { 829 first_frame = false; 830 } else { 831 // Here we want to change the return addr to the addr of the previous instruction. We don't 832 // need to find the exact start addr of the previous instruction. A location in 833 // [start_addr_of_call_inst, start_addr_of_next_inst) is enough. 834 #if defined(__arm__) || defined(__aarch64__) 835 // If we are built for arm/aarch64, this may be a callchain of thumb code. For thumb code, 836 // the real instruction addr is (ip & ~1), and ip - 2 can used to hit the address range 837 // of the previous instruction. For non thumb code, any addr in [ip - 4, ip - 1] is fine. 838 ips[i] -= 2; 839 #else 840 ips[i]--; 841 #endif 842 } 843 } 844 } 845 } 846 847 BuildIdRecord::BuildIdRecord(char* p) : Record(p) { 848 const char* end = p + size(); 849 p += header_size(); 850 MoveFromBinaryFormat(pid, p); 851 build_id = BuildId(p, BUILD_ID_SIZE); 852 p += Align(build_id.Size(), 8); 853 filename = p; 854 p += Align(strlen(filename) + 1, 64); 855 CHECK_EQ(p, end); 856 } 857 858 void BuildIdRecord::DumpData(size_t indent) const { 859 PrintIndented(indent, "pid %u\n", pid); 860 PrintIndented(indent, "build_id %s\n", build_id.ToString().c_str()); 861 PrintIndented(indent, "filename %s\n", filename); 862 } 863 864 BuildIdRecord::BuildIdRecord(bool in_kernel, pid_t pid, const BuildId& build_id, 865 const std::string& filename) { 866 SetTypeAndMisc(PERF_RECORD_BUILD_ID, 867 in_kernel ? PERF_RECORD_MISC_KERNEL : PERF_RECORD_MISC_USER); 868 this->pid = pid; 869 this->build_id = build_id; 870 SetSize(header_size() + sizeof(pid) + Align(build_id.Size(), 8) + 871 Align(filename.size() + 1, 64)); 872 char* new_binary = new char[size()]; 873 char* p = new_binary; 874 MoveToBinaryFormat(header, p); 875 MoveToBinaryFormat(pid, p); 876 memcpy(p, build_id.Data(), build_id.Size()); 877 p += Align(build_id.Size(), 8); 878 this->filename = p; 879 strcpy(p, filename.c_str()); 880 UpdateBinary(new_binary); 881 } 882 883 KernelSymbolRecord::KernelSymbolRecord(char* p) : Record(p) { 884 const char* end = p + size(); 885 p += header_size(); 886 MoveFromBinaryFormat(kallsyms_size, p); 887 kallsyms = p; 888 p += Align(kallsyms_size, 8); 889 CHECK_EQ(p, end); 890 } 891 892 void KernelSymbolRecord::DumpData(size_t indent) const { 893 PrintIndented(indent, "kallsyms: %s\n", 894 std::string(kallsyms, kallsyms + kallsyms_size).c_str()); 895 } 896 897 KernelSymbolRecord::KernelSymbolRecord(const std::string& kallsyms) { 898 SetTypeAndMisc(SIMPLE_PERF_RECORD_KERNEL_SYMBOL, 0); 899 kallsyms_size = kallsyms.size(); 900 SetSize(header_size() + 4 + Align(kallsyms.size(), 8)); 901 char* new_binary = new char[size()]; 902 char* p = new_binary; 903 MoveToBinaryFormat(header, p); 904 MoveToBinaryFormat(kallsyms_size, p); 905 this->kallsyms = p; 906 memcpy(p, kallsyms.data(), kallsyms_size); 907 UpdateBinary(new_binary); 908 } 909 910 DsoRecord::DsoRecord(char* p) : Record(p) { 911 const char* end = p + size(); 912 p += header_size(); 913 MoveFromBinaryFormat(dso_type, p); 914 MoveFromBinaryFormat(dso_id, p); 915 MoveFromBinaryFormat(min_vaddr, p); 916 dso_name = p; 917 p += Align(strlen(dso_name) + 1, 8); 918 CHECK_EQ(p, end); 919 } 920 921 DsoRecord::DsoRecord(uint64_t dso_type, uint64_t dso_id, 922 const std::string& dso_name, uint64_t min_vaddr) { 923 SetTypeAndMisc(SIMPLE_PERF_RECORD_DSO, 0); 924 this->dso_type = dso_type; 925 this->dso_id = dso_id; 926 this->min_vaddr = min_vaddr; 927 SetSize(header_size() + 3 * sizeof(uint64_t) + Align(dso_name.size() + 1, 8)); 928 char* new_binary = new char[size()]; 929 char* p = new_binary; 930 MoveToBinaryFormat(header, p); 931 MoveToBinaryFormat(dso_type, p); 932 MoveToBinaryFormat(dso_id, p); 933 MoveToBinaryFormat(min_vaddr, p); 934 this->dso_name = p; 935 strcpy(p, dso_name.c_str()); 936 UpdateBinary(new_binary); 937 } 938 939 void DsoRecord::DumpData(size_t indent) const { 940 PrintIndented(indent, "dso_type: %s(%" PRIu64 ")\n", 941 DsoTypeToString(static_cast<DsoType>(dso_type)), dso_type); 942 PrintIndented(indent, "dso_id: %" PRIu64 "\n", dso_id); 943 PrintIndented(indent, "min_vaddr: 0x%" PRIx64 "\n", min_vaddr); 944 PrintIndented(indent, "dso_name: %s\n", dso_name); 945 } 946 947 SymbolRecord::SymbolRecord(char* p) : Record(p) { 948 const char* end = p + size(); 949 p += header_size(); 950 MoveFromBinaryFormat(addr, p); 951 MoveFromBinaryFormat(len, p); 952 MoveFromBinaryFormat(dso_id, p); 953 name = p; 954 p += Align(strlen(name) + 1, 8); 955 CHECK_EQ(p, end); 956 } 957 958 SymbolRecord::SymbolRecord(uint64_t addr, uint64_t len, const std::string& name, 959 uint64_t dso_id) { 960 SetTypeAndMisc(SIMPLE_PERF_RECORD_SYMBOL, 0); 961 this->addr = addr; 962 this->len = len; 963 this->dso_id = dso_id; 964 SetSize(header_size() + 3 * sizeof(uint64_t) + Align(name.size() + 1, 8)); 965 char* new_binary = new char[size()]; 966 char* p = new_binary; 967 MoveToBinaryFormat(header, p); 968 MoveToBinaryFormat(addr, p); 969 MoveToBinaryFormat(len, p); 970 MoveToBinaryFormat(dso_id, p); 971 this->name = p; 972 strcpy(p, name.c_str()); 973 UpdateBinary(new_binary); 974 } 975 976 void SymbolRecord::DumpData(size_t indent) const { 977 PrintIndented(indent, "name: %s\n", name); 978 PrintIndented(indent, "addr: 0x%" PRIx64 "\n", addr); 979 PrintIndented(indent, "len: 0x%" PRIx64 "\n", len); 980 PrintIndented(indent, "dso_id: %" PRIu64 "\n", dso_id); 981 } 982 983 TracingDataRecord::TracingDataRecord(char* p) : Record(p) { 984 const char* end = p + size(); 985 p += header_size(); 986 MoveFromBinaryFormat(data_size, p); 987 data = p; 988 p += Align(data_size, 64); 989 CHECK_EQ(p, end); 990 } 991 992 TracingDataRecord::TracingDataRecord(const std::vector<char>& tracing_data) { 993 SetTypeAndMisc(PERF_RECORD_TRACING_DATA, 0); 994 data_size = tracing_data.size(); 995 SetSize(header_size() + sizeof(uint32_t) + Align(tracing_data.size(), 64)); 996 char* new_binary = new char[size()]; 997 char* p = new_binary; 998 MoveToBinaryFormat(header, p); 999 MoveToBinaryFormat(data_size, p); 1000 data = p; 1001 memcpy(p, tracing_data.data(), data_size); 1002 UpdateBinary(new_binary); 1003 } 1004 1005 void TracingDataRecord::DumpData(size_t indent) const { 1006 Tracing tracing(std::vector<char>(data, data + data_size)); 1007 tracing.Dump(indent); 1008 } 1009 1010 EventIdRecord::EventIdRecord(char* p) : Record(p) { 1011 const char* end = p + size(); 1012 p += header_size(); 1013 MoveFromBinaryFormat(count, p); 1014 data = reinterpret_cast<const EventIdData*>(p); 1015 p += sizeof(data[0]) * count; 1016 CHECK_EQ(p, end); 1017 } 1018 1019 EventIdRecord::EventIdRecord(const std::vector<uint64_t>& data) { 1020 SetTypeAndMisc(SIMPLE_PERF_RECORD_EVENT_ID, 0); 1021 SetSize(header_size() + sizeof(uint64_t) * (1 + data.size())); 1022 char* new_binary = new char[size()]; 1023 char* p = new_binary; 1024 MoveToBinaryFormat(header, p); 1025 count = data.size() / 2; 1026 MoveToBinaryFormat(count, p); 1027 this->data = reinterpret_cast<EventIdData*>(p); 1028 memcpy(p, data.data(), sizeof(uint64_t) * data.size()); 1029 UpdateBinary(new_binary); 1030 } 1031 1032 void EventIdRecord::DumpData(size_t indent) const { 1033 PrintIndented(indent, "count: %" PRIu64 "\n", count); 1034 for (size_t i = 0; i < count; ++i) { 1035 PrintIndented(indent, "attr_id[%" PRIu64 "]: %" PRIu64 "\n", i, 1036 data[i].attr_id); 1037 PrintIndented(indent, "event_id[%" PRIu64 "]: %" PRIu64 "\n", i, 1038 data[i].event_id); 1039 } 1040 } 1041 1042 CallChainRecord::CallChainRecord(char* p) : Record(p) { 1043 const char* end = p + size(); 1044 p += header_size(); 1045 MoveFromBinaryFormat(pid, p); 1046 MoveFromBinaryFormat(tid, p); 1047 MoveFromBinaryFormat(chain_type, p); 1048 MoveFromBinaryFormat(time, p); 1049 MoveFromBinaryFormat(ip_nr, p); 1050 ips = reinterpret_cast<uint64_t*>(p); 1051 p += ip_nr * sizeof(uint64_t); 1052 sps = reinterpret_cast<uint64_t*>(p); 1053 p += ip_nr * sizeof(uint64_t); 1054 CHECK_EQ(p, end); 1055 } 1056 1057 CallChainRecord::CallChainRecord(pid_t pid, pid_t tid, CallChainJoiner::ChainType type, 1058 uint64_t time, const std::vector<uint64_t>& ips, 1059 const std::vector<uint64_t>& sps) { 1060 CHECK_EQ(ips.size(), sps.size()); 1061 SetTypeAndMisc(SIMPLE_PERF_RECORD_CALLCHAIN, 0); 1062 this->pid = pid; 1063 this->tid = tid; 1064 this->chain_type = static_cast<int>(type); 1065 this->time = time; 1066 this->ip_nr = ips.size(); 1067 SetSize(header_size() + (4 + ips.size() * 2) * sizeof(uint64_t)); 1068 char* new_binary = new char[size()]; 1069 char* p = new_binary; 1070 MoveToBinaryFormat(header, p); 1071 MoveToBinaryFormat(this->pid, p); 1072 MoveToBinaryFormat(this->tid, p); 1073 MoveToBinaryFormat(this->chain_type, p); 1074 MoveToBinaryFormat(this->time, p); 1075 MoveToBinaryFormat(this->ip_nr, p); 1076 this->ips = reinterpret_cast<uint64_t*>(p); 1077 MoveToBinaryFormat(ips.data(), ips.size(), p); 1078 this->sps = reinterpret_cast<uint64_t*>(p); 1079 MoveToBinaryFormat(sps.data(), sps.size(), p); 1080 UpdateBinary(new_binary); 1081 } 1082 1083 void CallChainRecord::DumpData(size_t indent) const { 1084 const char* type_name = ""; 1085 switch (chain_type) { 1086 case CallChainJoiner::ORIGINAL_OFFLINE: type_name = "ORIGINAL_OFFLINE"; break; 1087 case CallChainJoiner::ORIGINAL_REMOTE: type_name = "ORIGINAL_REMOTE"; break; 1088 case CallChainJoiner::JOINED_OFFLINE: type_name = "JOINED_OFFLINE"; break; 1089 case CallChainJoiner::JOINED_REMOTE: type_name = "JOINED_REMOTE"; break; 1090 } 1091 PrintIndented(indent, "pid %u\n", pid); 1092 PrintIndented(indent, "tid %u\n", tid); 1093 PrintIndented(indent, "chain_type %s\n", type_name); 1094 PrintIndented(indent, "time %" PRIu64 "\n", time); 1095 PrintIndented(indent, "ip_nr %" PRIu64 "\n", ip_nr); 1096 for (size_t i = 0; i < ip_nr; ++i) { 1097 PrintIndented(indent + 1, "ip 0x%" PRIx64 ", sp 0x%" PRIx64 "\n", ips[i], sps[i]); 1098 } 1099 } 1100 1101 UnwindingResultRecord::UnwindingResultRecord(char* p) : Record(p) { 1102 const char* end = p + size(); 1103 p += header_size(); 1104 MoveFromBinaryFormat(time, p); 1105 MoveFromBinaryFormat(unwinding_result.used_time, p); 1106 uint64_t stop_reason; 1107 MoveFromBinaryFormat(stop_reason, p); 1108 unwinding_result.stop_reason = static_cast<decltype(unwinding_result.stop_reason)>(stop_reason); 1109 MoveFromBinaryFormat(unwinding_result.stop_info, p); 1110 MoveFromBinaryFormat(unwinding_result.stack_start, p); 1111 MoveFromBinaryFormat(unwinding_result.stack_end, p); 1112 CHECK_EQ(p, end); 1113 } 1114 1115 UnwindingResultRecord::UnwindingResultRecord(uint64_t time, 1116 const UnwindingResult& unwinding_result) { 1117 SetTypeAndMisc(SIMPLE_PERF_RECORD_UNWINDING_RESULT, 0); 1118 SetSize(header_size() + 6 * sizeof(uint64_t)); 1119 this->time = time; 1120 this->unwinding_result = unwinding_result; 1121 char* new_binary = new char[size()]; 1122 char* p = new_binary; 1123 MoveToBinaryFormat(header, p); 1124 MoveToBinaryFormat(this->time, p); 1125 MoveToBinaryFormat(unwinding_result.used_time, p); 1126 uint64_t stop_reason = unwinding_result.stop_reason; 1127 MoveToBinaryFormat(stop_reason, p); 1128 MoveToBinaryFormat(unwinding_result.stop_info, p); 1129 MoveToBinaryFormat(unwinding_result.stack_start, p); 1130 MoveToBinaryFormat(unwinding_result.stack_end, p); 1131 UpdateBinary(new_binary); 1132 } 1133 1134 void UnwindingResultRecord::DumpData(size_t indent) const { 1135 PrintIndented(indent, "time %" PRIu64 "\n", time); 1136 PrintIndented(indent, "used_time %" PRIu64 "\n", unwinding_result.used_time); 1137 static std::unordered_map<int, std::string> map = { 1138 {UnwindingResult::UNKNOWN_REASON, "UNKNOWN_REASON"}, 1139 {UnwindingResult::EXCEED_MAX_FRAMES_LIMIT, "EXCEED_MAX_FRAME_LIMIT"}, 1140 {UnwindingResult::ACCESS_REG_FAILED, "ACCESS_REG_FAILED"}, 1141 {UnwindingResult::ACCESS_STACK_FAILED, "ACCESS_STACK_FAILED"}, 1142 {UnwindingResult::ACCESS_MEM_FAILED, "ACCESS_MEM_FAILED"}, 1143 {UnwindingResult::FIND_PROC_INFO_FAILED, "FIND_PROC_INFO_FAILED"}, 1144 {UnwindingResult::EXECUTE_DWARF_INSTRUCTION_FAILED, "EXECUTE_DWARF_INSTRUCTION_FAILED"}, 1145 {UnwindingResult::DIFFERENT_ARCH, "DIFFERENT_ARCH"}, 1146 {UnwindingResult::MAP_MISSING, "MAP_MISSING"}, 1147 }; 1148 PrintIndented(indent, "stop_reason %s\n", map[unwinding_result.stop_reason].c_str()); 1149 if (unwinding_result.stop_reason == UnwindingResult::ACCESS_REG_FAILED) { 1150 PrintIndented(indent, "regno %" PRIu64 "\n", unwinding_result.stop_info); 1151 } else if (unwinding_result.stop_reason == UnwindingResult::ACCESS_STACK_FAILED || 1152 unwinding_result.stop_reason == UnwindingResult::ACCESS_MEM_FAILED) { 1153 PrintIndented(indent, "addr 0x%" PRIx64 "\n", unwinding_result.stop_info); 1154 } 1155 PrintIndented(indent, "stack_start 0x%" PRIx64 "\n", unwinding_result.stack_start); 1156 PrintIndented(indent, "stack_end 0x%" PRIx64 "\n", unwinding_result.stack_end); 1157 } 1158 1159 UnknownRecord::UnknownRecord(char* p) : Record(p) { 1160 p += header_size(); 1161 data = p; 1162 } 1163 1164 void UnknownRecord::DumpData(size_t) const {} 1165 1166 std::unique_ptr<Record> ReadRecordFromBuffer(const perf_event_attr& attr, uint32_t type, char* p) { 1167 switch (type) { 1168 case PERF_RECORD_MMAP: 1169 return std::unique_ptr<Record>(new MmapRecord(attr, p)); 1170 case PERF_RECORD_MMAP2: 1171 return std::unique_ptr<Record>(new Mmap2Record(attr, p)); 1172 case PERF_RECORD_COMM: 1173 return std::unique_ptr<Record>(new CommRecord(attr, p)); 1174 case PERF_RECORD_EXIT: 1175 return std::unique_ptr<Record>(new ExitRecord(attr, p)); 1176 case PERF_RECORD_FORK: 1177 return std::unique_ptr<Record>(new ForkRecord(attr, p)); 1178 case PERF_RECORD_LOST: 1179 return std::unique_ptr<Record>(new LostRecord(attr, p)); 1180 case PERF_RECORD_SAMPLE: 1181 return std::unique_ptr<Record>(new SampleRecord(attr, p)); 1182 case PERF_RECORD_TRACING_DATA: 1183 return std::unique_ptr<Record>(new TracingDataRecord(p)); 1184 case SIMPLE_PERF_RECORD_KERNEL_SYMBOL: 1185 return std::unique_ptr<Record>(new KernelSymbolRecord(p)); 1186 case SIMPLE_PERF_RECORD_DSO: 1187 return std::unique_ptr<Record>(new DsoRecord(p)); 1188 case SIMPLE_PERF_RECORD_SYMBOL: 1189 return std::unique_ptr<Record>(new SymbolRecord(p)); 1190 case SIMPLE_PERF_RECORD_EVENT_ID: 1191 return std::unique_ptr<Record>(new EventIdRecord(p)); 1192 case SIMPLE_PERF_RECORD_CALLCHAIN: 1193 return std::unique_ptr<Record>(new CallChainRecord(p)); 1194 case SIMPLE_PERF_RECORD_UNWINDING_RESULT: 1195 return std::unique_ptr<Record>(new UnwindingResultRecord(p)); 1196 default: 1197 return std::unique_ptr<Record>(new UnknownRecord(p)); 1198 } 1199 } 1200 1201 std::unique_ptr<Record> ReadRecordFromOwnedBuffer(const perf_event_attr& attr, 1202 uint32_t type, char* p) { 1203 std::unique_ptr<Record> record = ReadRecordFromBuffer(attr, type, p); 1204 if (record != nullptr) { 1205 record->OwnBinary(); 1206 } else { 1207 delete[] p; 1208 } 1209 return record; 1210 } 1211 1212 std::vector<std::unique_ptr<Record>> ReadRecordsFromBuffer( 1213 const perf_event_attr& attr, char* buf, size_t buf_size) { 1214 std::vector<std::unique_ptr<Record>> result; 1215 char* p = buf; 1216 char* end = buf + buf_size; 1217 while (p < end) { 1218 RecordHeader header(p); 1219 CHECK_LE(p + header.size, end); 1220 CHECK_NE(0u, header.size); 1221 result.push_back(ReadRecordFromBuffer(attr, header.type, p)); 1222 p += header.size; 1223 } 1224 return result; 1225 } 1226 1227 std::unique_ptr<Record> ReadRecordFromBuffer(const perf_event_attr& attr, char* p) { 1228 auto header = reinterpret_cast<const perf_event_header*>(p); 1229 return ReadRecordFromBuffer(attr, header->type, p); 1230 } 1231 1232 bool RecordCache::RecordWithSeq::IsHappensBefore( 1233 const RecordWithSeq& other) const { 1234 bool is_sample = (record->type() == PERF_RECORD_SAMPLE); 1235 bool is_other_sample = (other.record->type() == PERF_RECORD_SAMPLE); 1236 uint64_t time = record->Timestamp(); 1237 uint64_t other_time = other.record->Timestamp(); 1238 // The record with smaller time happens first. 1239 if (time != other_time) { 1240 return time < other_time; 1241 } 1242 // If happening at the same time, make non-sample records before sample 1243 // records, because non-sample records may contain useful information to 1244 // parse sample records. 1245 if (is_sample != is_other_sample) { 1246 return is_sample ? false : true; 1247 } 1248 // Otherwise, use the same order as they enter the cache. 1249 return seq < other.seq; 1250 } 1251 1252 bool RecordCache::RecordComparator::operator()(const RecordWithSeq& r1, 1253 const RecordWithSeq& r2) { 1254 return r2.IsHappensBefore(r1); 1255 } 1256 1257 RecordCache::RecordCache(bool has_timestamp, size_t min_cache_size, 1258 uint64_t min_time_diff_in_ns) 1259 : has_timestamp_(has_timestamp), 1260 min_cache_size_(min_cache_size), 1261 min_time_diff_in_ns_(min_time_diff_in_ns), 1262 last_time_(0), 1263 cur_seq_(0), 1264 queue_(RecordComparator()) {} 1265 1266 RecordCache::~RecordCache() { PopAll(); } 1267 1268 void RecordCache::Push(std::unique_ptr<Record> record) { 1269 if (has_timestamp_) { 1270 last_time_ = std::max(last_time_, record->Timestamp()); 1271 } 1272 queue_.push(RecordWithSeq(cur_seq_++, record.release())); 1273 } 1274 1275 void RecordCache::Push(std::vector<std::unique_ptr<Record>> records) { 1276 for (auto& r : records) { 1277 Push(std::move(r)); 1278 } 1279 } 1280 1281 std::unique_ptr<Record> RecordCache::Pop() { 1282 if (queue_.size() < min_cache_size_) { 1283 return nullptr; 1284 } 1285 Record* r = queue_.top().record; 1286 if (has_timestamp_) { 1287 if (r->Timestamp() + min_time_diff_in_ns_ > last_time_) { 1288 return nullptr; 1289 } 1290 } 1291 queue_.pop(); 1292 return std::unique_ptr<Record>(r); 1293 } 1294 1295 std::vector<std::unique_ptr<Record>> RecordCache::PopAll() { 1296 std::vector<std::unique_ptr<Record>> result; 1297 while (!queue_.empty()) { 1298 result.emplace_back(queue_.top().record); 1299 queue_.pop(); 1300 } 1301 return result; 1302 } 1303 1304 std::unique_ptr<Record> RecordCache::ForcedPop() { 1305 if (queue_.empty()) { 1306 return nullptr; 1307 } 1308 Record* r = queue_.top().record; 1309 queue_.pop(); 1310 return std::unique_ptr<Record>(r); 1311 } 1312
