Lines Matching defs:backtrace
44 #include <backtrace/Backtrace.h>
45 #include <backtrace/BacktraceMap.h>
72 // The list of shared libaries that make up the backtrace library.
85 Backtrace* backtrace;
90 typedef Backtrace* (*create_func_t)(pid_t, pid_t, BacktraceMap*);
93 static void VerifyLevelDump(Backtrace* backtrace, create_func_t create_func = nullptr,
95 static void VerifyMaxDump(Backtrace* backtrace, create_func_t create_func = nullptr,
104 static std::string DumpFrames(Backtrace* backtrace) {
105 if (backtrace->NumFrames() == 0) {
110 for (size_t i = 0; i < backtrace->NumFrames(); i++) {
111 frame += " " + backtrace->FormatFrameData(i) + '\n';
161 static bool ReadyLevelBacktrace(Backtrace* backtrace) {
162 // See if test_level_four is in the backtrace.
164 for (Backtrace::const_iterator it = backtrace->begin(); it != backtrace->end(); ++it) {
174 static void VerifyLevelDump(Backtrace* backtrace, create_func_t, map_create_func_t) {
175 ASSERT_GT(backtrace->NumFrames(), static_cast<size_t>(0))
176 << DumpFrames(backtrace);
177 ASSERT_LT(backtrace->NumFrames(), static_cast<size_t>(MAX_BACKTRACE_FRAMES))
178 << DumpFrames(backtrace);
183 for (size_t i = backtrace->NumFrames()-1; i > 2; i--) {
184 if (backtrace->GetFrame(i)->func_name == "test_level_one") {
189 ASSERT_LT(static_cast<size_t>(0), frame_num) << DumpFrames(backtrace);
190 ASSERT_LE(static_cast<size_t>(3), frame_num) << DumpFrames(backtrace);
192 ASSERT_EQ(backtrace->GetFrame(frame_num)->func_name, "test_level_one")
193 << DumpFrames(backtrace);
194 ASSERT_EQ(backtrace->GetFrame(frame_num-1)->func_name, "test_level_two")
195 << DumpFrames(backtrace);
196 ASSERT_EQ(backtrace->GetFrame(frame_num-2)->func_name, "test_level_three")
197 << DumpFrames(backtrace);
198 ASSERT_EQ(backtrace->GetFrame(frame_num-3)->func_name, "test_level_four")
199 << DumpFrames(backtrace);
203 std::unique_ptr<Backtrace> backtrace(
204 Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
205 ASSERT_TRUE(backtrace.get() != nullptr);
206 ASSERT_TRUE(backtrace->Unwind(0));
207 VERIFY_NO_ERROR(backtrace->GetError().error_code);
209 VerifyLevelDump(backtrace.get());
212 static bool ReadyMaxBacktrace(Backtrace* backtrace) {
213 return (backtrace->NumFrames() == MAX_BACKTRACE_FRAMES);
216 static void VerifyMaxDump(Backtrace* backtrace, create_func_t, map_create_func_t) {
217 ASSERT_EQ(backtrace->NumFrames(), static_cast<size_t>(MAX_BACKTRACE_FRAMES))
218 << DumpFrames(backtrace);
220 ASSERT_EQ(backtrace->GetFrame(MAX_BACKTRACE_FRAMES-1)->func_name, "test_recursive_call")
221 << DumpFrames(backtrace);
225 std::unique_ptr<Backtrace> backtrace(
226 Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
227 ASSERT_TRUE(backtrace.get() != nullptr);
228 ASSERT_TRUE(backtrace->Unwind(0));
229 ASSERT_EQ(BACKTRACE_UNWIND_ERROR_EXCEED_MAX_FRAMES_LIMIT, backtrace->GetError().error_code);
231 VerifyMaxDump(backtrace.get());
256 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), getpid()));
257 ASSERT_TRUE(backtrace.get() != nullptr);
258 ASSERT_TRUE(backtrace->Unwind(0));
259 VERIFY_NO_ERROR(backtrace->GetError().error_code);
261 ASSERT_TRUE(backtrace->NumFrames() != 0);
262 // None of the frames should be in the backtrace libraries.
263 for (const auto& frame : *backtrace ) {
267 ASSERT_TRUE(name != lib) << DumpFrames(backtrace.get());
275 // frames within the backtrace libraries.
276 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), getpid()));
277 ASSERT_TRUE(backtrace.get() != nullptr);
278 backtrace->SetSkipFrames(false);
279 ASSERT_TRUE(backtrace->Unwind(0));
280 VERIFY_NO_ERROR(backtrace->GetError().error_code);
282 ASSERT_TRUE(backtrace->NumFrames() != 0);
284 for (const auto& frame : *backtrace) {
301 ASSERT_NE(0U, first_frame_non_backtrace_lib) << "No frames found in backtrace libraries:\n"
302 << DumpFrames(backtrace.get());
309 static void VerifyIgnoreFrames(Backtrace* bt_all, Backtrace* bt_ign1, Backtrace* bt_ign2,
311 ASSERT_EQ(bt_all->NumFrames(), bt_ign1->NumFrames() + 1) << "All backtrace:\n"
313 << "Ignore 1 backtrace:\n"
315 ASSERT_EQ(bt_all->NumFrames(), bt_ign2->NumFrames() + 2) << "All backtrace:\n"
317 << "Ignore 2 backtrace:\n"
339 std::unique_ptr<Backtrace> all(
340 Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
345 std::unique_ptr<Backtrace> ign1(
346 Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
351 std::unique_ptr<Backtrace> ign2(
352 Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
368 static void VerifyProcTest(pid_t pid, pid_t tid, bool (*ReadyFunc)(Backtrace*),
369 void (*VerifyFunc)(Backtrace*, create_func_t, map_create_func_t),
388 std::unique_ptr<Backtrace> backtrace(create_func(pid, tid, map.get()));
389 ASSERT_TRUE(backtrace.get() != nullptr);
390 ASSERT_TRUE(backtrace->Unwind(0));
391 if (ReadyFunc(backtrace.get())) {
392 VerifyFunc(backtrace.get(), create_func, map_create_func);
395 last_dump = DumpFrames(backtrace.get());
402 ASSERT_TRUE(verified) << "Last backtrace:\n" << last_dump;
412 Backtrace::Create, BacktraceMap::Create);
425 VerifyProcTest(pid, BACKTRACE_CURRENT_THREAD, ReadyMaxBacktrace, VerifyMaxDump, Backtrace::Create,
433 static void VerifyProcessIgnoreFrames(Backtrace* bt_all, create_func_t create_func,
436 std::unique_ptr<Backtrace> ign1(create_func(bt_all->Pid(), BACKTRACE_CURRENT_THREAD, map.get()));
441 std::unique_ptr<Backtrace> ign2(create_func(bt_all->Pid(), BACKTRACE_CURRENT_THREAD, map.get()));
456 Backtrace::Create, BacktraceMap::Create);
519 VerifyProcTest(pid, *it, ReadyLevelBacktrace, VerifyLevelDump, Backtrace::Create,
527 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), gettid()));
528 ASSERT_TRUE(backtrace.get() != nullptr);
529 ASSERT_TRUE(backtrace->Unwind(0));
530 VERIFY_NO_ERROR(backtrace->GetError().error_code);
532 VerifyLevelDump(backtrace.get());
540 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), gettid()));
541 ASSERT_TRUE(backtrace.get() != nullptr);
542 ASSERT_TRUE(backtrace->Unwind(0));
543 ASSERT_EQ(BACKTRACE_UNWIND_ERROR_EXCEED_MAX_FRAMES_LIMIT, backtrace->GetError().error_code);
545 VerifyMaxDump(backtrace.get());
582 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), thread_data.tid));
583 ASSERT_TRUE(backtrace.get() != nullptr);
584 ASSERT_TRUE(backtrace->Unwind(0));
585 VERIFY_NO_ERROR(backtrace->GetError().error_code);
587 VerifyLevelDump(backtrace.get());
622 std::unique_ptr<Backtrace> all(Backtrace::Create(getpid(), thread_data.tid));
627 std::unique_ptr<Backtrace> ign1(Backtrace::Create(getpid(), thread_data.tid));
632 std::unique_ptr<Backtrace> ign2(Backtrace::Create(getpid(), thread_data.tid));
663 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), thread_data.tid));
664 ASSERT_TRUE(backtrace.get() != nullptr);
665 ASSERT_TRUE(backtrace->Unwind(0));
666 ASSERT_EQ(BACKTRACE_UNWIND_ERROR_EXCEED_MAX_FRAMES_LIMIT, backtrace->GetError().error_code);
668 VerifyMaxDump(backtrace.get());
683 dump->backtrace = Backtrace::Create(getpid(), dump->thread.tid, dump->map);
684 dump->backtrace->Unwind(0);
737 ASSERT_TRUE(dumpers[i].backtrace != nullptr);
738 VerifyMaxDump(dumpers[i].backtrace);
740 delete dumpers[i].backtrace;
741 dumpers[i].backtrace = nullptr;
760 Backtrace* back1 = Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD, map1);
767 Backtrace* back2 = Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD, map2);
774 Backtrace* back3 = Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD, map3);
802 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD));
803 ASSERT_TRUE(backtrace.get() != nullptr);
820 backtrace->FormatFrameData(&frame));
833 backtrace->FormatFrameData(&frame));
846 backtrace->FormatFrameData(&frame));
859 backtrace->FormatFrameData(&frame));
868 backtrace->FormatFrameData(&frame));
877 backtrace->FormatFrameData(&frame));
888 backtrace->FormatFrameData(&frame));
897 backtrace->FormatFrameData(&frame));
1034 static void RunReadTest(Backtrace* backtrace, uint64_t read_addr) {
1043 size_t bytes_read = backtrace->Read(read_addr, data, 2 * pagesize);
1049 bytes_read = backtrace->Read(read_addr + i, data, 2 * sizeof(word_t));
1060 bytes_read = backtrace->Read(read_addr + i, data, j);
1082 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), thread_data.tid));
1083 ASSERT_TRUE(backtrace.get() != nullptr);
1085 RunReadTest(backtrace.get(), reinterpret_cast<uint64_t>(thread_data.data));
1138 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, pid));
1139 ASSERT_TRUE(backtrace.get() != nullptr);
1142 size_t bytes_read = backtrace->Read(reinterpret_cast<uint64_t>(&g_ready),
1147 bytes_read = backtrace->Read(reinterpret_cast<uint64_t>(&g_addr),
1151 RunReadTest(backtrace.get(), read_addr);
1234 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(BACKTRACE_CURRENT_PROCESS,
1236 ASSERT_TRUE(backtrace.get() != nullptr);
1239 backtrace->Unwind(0);
1246 std::string func_name = backtrace->GetFunctionName(read_addr, &offset);
1306 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, BACKTRACE_CURRENT_THREAD));
1307 ASSERT_TRUE(backtrace.get() != nullptr);
1311 backtrace->Read(reinterpret_cast<uint64_t>(&g_ready),
1315 backtrace->Read(reinterpret_cast<uint64_t>(&g_addr),
1319 backtrace->Unwind(0);
1326 std::string func_name = backtrace->GetFunctionName(read_addr, &offset);
1348 static bool FindFuncFrameInBacktrace(Backtrace* backtrace, uint64_t test_func, size_t* frame_num) {
1350 backtrace->FillInMap(test_func, &map);
1357 for (Backtrace::const_iterator it = backtrace->begin(); it != backtrace->end(); ++it) {
1367 static void VerifyUnreadableElfFrame(Backtrace* backtrace, uint64_t test_func, size_t frame_num) {
1368 ASSERT_LT(backtrace->NumFrames(), static_cast<size_t>(MAX_BACKTRACE_FRAMES))
1369 << DumpFrames(backtrace);
1371 ASSERT_TRUE(frame_num != 0) << DumpFrames(backtrace);
1373 ASSERT_LT(frame_num, backtrace->NumFrames()) << DumpFrames(backtrace);
1375 uint64_t diff = backtrace->GetFrame(frame_num)->pc - test_func;
1376 ASSERT_LT(diff, 200U) << DumpFrames(backtrace);
1380 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(BACKTRACE_CURRENT_PROCESS,
1382 ASSERT_TRUE(backtrace.get() != nullptr);
1383 ASSERT_TRUE(backtrace->Unwind(0));
1384 VERIFY_NO_ERROR(backtrace->GetError().error_code);
1388 ASSERT_TRUE(FindFuncFrameInBacktrace(backtrace.get(), test_func, &frame_num))
1389 << DumpFrames(backtrace.get());
1391 VerifyUnreadableElfFrame(backtrace.get(), test_func, frame_num);
1440 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, BACKTRACE_CURRENT_THREAD));
1441 ASSERT_TRUE(backtrace.get() != nullptr);
1442 ASSERT_TRUE(backtrace->Unwind(0));
1443 VERIFY_NO_ERROR(backtrace->GetError().error_code);
1446 if (FindFuncFrameInBacktrace(backtrace.get(), reinterpret_cast<uint64_t>(test_func),
1448 VerifyUnreadableElfFrame(backtrace.get(), reinterpret_cast<uint64_t>(test_func), frame_num);
1467 std::unique_ptr<Backtrace> backtrace(
1468 Backtrace::Create(BACKTRACE_CURRENT_PROCESS, 99999999));
1469 ASSERT_TRUE(backtrace.get() != nullptr);
1470 ASSERT_FALSE(backtrace->Unwind(0));
1471 ASSERT_EQ(BACKTRACE_UNWIND_ERROR_THREAD_DOESNT_EXIST, backtrace->GetError().error_code);
1475 std::unique_ptr<Backtrace> backtrace(
1476 Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
1477 ASSERT_TRUE(backtrace.get() != nullptr);
1482 ASSERT_NE(std::string(""), backtrace->GetFunctionName(cur_func_offset, &offset));
1490 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, pid));
1495 ASSERT_NE(std::string(""), backtrace->GetFunctionName(cur_func_offset, &offset));
1566 static void UnwindFromDevice(Backtrace* backtrace, void* device_map) {
1570 backtrace->FillInMap(device_map_uint, &map);
1576 ASSERT_EQ(std::string(""), backtrace->GetFunctionName(device_map_uint, &offset));
1577 ASSERT_EQ(std::string(""), backtrace->GetFunctionName(device_map_uint, &offset, &map));
1578 ASSERT_EQ(std::string(""), backtrace->GetFunctionName(0, &offset));
1582 backtrace->FillInMap(cur_func_offset, &map);
1584 ASSERT_NE(std::string(""), backtrace->GetFunctionName(cur_func_offset, &offset, &map));
1586 ASSERT_EQ(std::string(""), backtrace->GetFunctionName(cur_func_offset, &offset, &map));
1597 ASSERT_TRUE(backtrace->Unwind(0, &ucontext));
1600 ASSERT_EQ(1U, backtrace->NumFrames());
1601 const backtrace_frame_data_t* frame = backtrace->GetFrame(0);
1606 ASSERT_TRUE(backtrace->Unwind(1, &ucontext));
1607 ASSERT_EQ(0U, backtrace->NumFrames());
1616 ASSERT_TRUE(backtrace->Unwind(0, &ucontext));
1619 ASSERT_EQ(1U, backtrace->NumFrames());
1620 frame = backtrace->GetFrame(0);
1625 ASSERT_TRUE(backtrace->Unwind(1, &ucontext));
1626 ASSERT_EQ(0U, backtrace->NumFrames());
1634 std::unique_ptr<Backtrace> backtrace(
1635 Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
1636 ASSERT_TRUE(backtrace);
1638 UnwindFromDevice(backtrace.get(), device_map);
1647 // Fork a process to do a remote backtrace.
1652 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, pid));
1654 UnwindFromDevice(backtrace.get(), device_map);
1721 std::unique_ptr<Backtrace> backtrace(create_func(pid, pid, map.get()));
1723 size_t bytes_read = backtrace->Read(reinterpret_cast<uint64_t>(const_cast<int*>(&value)),
1737 Backtrace::const_iterator frame_iter;
1740 std::unique_ptr<Backtrace> backtrace;
1750 backtrace.reset(create_func(pid, pid, map.get()));
1751 ASSERT_TRUE(backtrace->Unwind(0));
1753 for (frame_iter = backtrace->begin(); frame_iter != backtrace->end(); ++frame_iter) {
1768 << DumpFrames(backtrace.get());
1774 for (; frame_iter != backtrace->end(); ++frame_iter) {
1780 ASSERT_NE(0U, frame) << "Unable to find test_level_four in backtrace" << std::endl
1781 << DumpFrames(backtrace.get());
1792 ASSERT_LE(frame + 2, names.size()) << DumpFrames(backtrace.get());
1793 ASSERT_LE(2U, frame) << DumpFrames(backtrace.get());
1795 ASSERT_EQ("test_signal_action", names[0]) << DumpFrames(backtrace.get());
1797 ASSERT_EQ("test_signal_handler", names[0]) << DumpFrames(backtrace.get());
1799 ASSERT_EQ("test_level_three", names[frame]) << DumpFrames(backtrace.get());
1800 ASSERT_EQ("test_level_two", names[frame + 1]) << DumpFrames(backtrace.get());
1801 ASSERT_EQ("test_level_one", names[frame + 2]) << DumpFrames(backtrace.get());
1807 UnwindThroughSignal(false, Backtrace::Create, BacktraceMap::Create);
1811 UnwindThroughSignal(true, Backtrace::Create, BacktraceMap::Create);
1816 std::unique_ptr<Backtrace> backtrace(create_func(getpid(), gettid(), map.get()));
1817 backtrace->Unwind(1);
1818 ASSERT_NE(0U, backtrace->NumFrames());
1819 ASSERT_EQ(0U, backtrace->GetFrame(0)->num);
1823 TestFrameSkipNumbering(Backtrace::Create, BacktraceMap::Create);
1836 Backtrace* backtrace = Backtrace::Create(pid, tid, map.get());
1837 ASSERT_TRUE(backtrace != nullptr);
1838 ASSERT_TRUE(backtrace->Unwind(0));
1839 VERIFY_NO_ERROR(backtrace->GetError().error_code);
1840 delete backtrace;
1847 Backtrace* backtrace = Backtrace::Create(pid, tid, map.get());
1848 ASSERT_TRUE(backtrace != nullptr);
1849 ASSERT_TRUE(backtrace->Unwind(0));
1850 VERIFY_NO_ERROR(backtrace->GetError().error_code);
1851 delete backtrace;
