1 /*
2  * Copyright (C) 2013 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 #define _GNU_SOURCE 1
18 #include <dirent.h>
19 #include <dlfcn.h>
20 #include <errno.h>
21 #include <fcntl.h>
22 #include <inttypes.h>
23 #include <pthread.h>
24 #include <signal.h>
25 #include <stdint.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <sys/ptrace.h>
30 #include <sys/stat.h>
31 #include <sys/types.h>
32 #include <sys/wait.h>
33 #include <time.h>
34 #include <unistd.h>
35 
36 #include <algorithm>
37 #include <list>
38 #include <memory>
39 #include <string>
40 #include <vector>
41 
42 #include <backtrace/Backtrace.h>
43 #include <backtrace/BacktraceMap.h>
44 
45 #include <base/stringprintf.h>
46 #include <cutils/atomic.h>
47 #include <cutils/threads.h>
48 
49 #include <gtest/gtest.h>
50 
51 // For the THREAD_SIGNAL definition.
52 #include "BacktraceCurrent.h"
53 #include "thread_utils.h"
54 
55 // Number of microseconds per milliseconds.
56 #define US_PER_MSEC             1000
57 
58 // Number of nanoseconds in a second.
59 #define NS_PER_SEC              1000000000ULL
60 
61 // Number of simultaneous dumping operations to perform.
62 #define NUM_THREADS  40
63 
64 // Number of simultaneous threads running in our forked process.
65 #define NUM_PTRACE_THREADS 5
66 
67 struct thread_t {
68   pid_t tid;
69   int32_t state;
70   pthread_t threadId;
71   void* data;
72 };
73 
74 struct dump_thread_t {
75   thread_t thread;
76   Backtrace* backtrace;
77   int32_t* now;
78   int32_t done;
79 };
80 
81 extern "C" {
82 // Prototypes for functions in the test library.
83 int test_level_one(int, int, int, int, void (*)(void*), void*);
84 
85 int test_recursive_call(int, void (*)(void*), void*);
86 }
87 
NanoTime()88 uint64_t NanoTime() {
89   struct timespec t = { 0, 0 };
90   clock_gettime(CLOCK_MONOTONIC, &t);
91   return static_cast<uint64_t>(t.tv_sec * NS_PER_SEC + t.tv_nsec);
92 }
93 
DumpFrames(Backtrace * backtrace)94 std::string DumpFrames(Backtrace* backtrace) {
95   if (backtrace->NumFrames() == 0) {
96     return "   No frames to dump.\n";
97   }
98 
99   std::string frame;
100   for (size_t i = 0; i < backtrace->NumFrames(); i++) {
101     frame += "   " + backtrace->FormatFrameData(i) + '\n';
102   }
103   return frame;
104 }
105 
WaitForStop(pid_t pid)106 void WaitForStop(pid_t pid) {
107   uint64_t start = NanoTime();
108 
109   siginfo_t si;
110   while (ptrace(PTRACE_GETSIGINFO, pid, 0, &si) < 0 && (errno == EINTR || errno == ESRCH)) {
111     if ((NanoTime() - start) > NS_PER_SEC) {
112       printf("The process did not get to a stopping point in 1 second.\n");
113       break;
114     }
115     usleep(US_PER_MSEC);
116   }
117 }
118 
ReadyLevelBacktrace(Backtrace * backtrace)119 bool ReadyLevelBacktrace(Backtrace* backtrace) {
120   // See if test_level_four is in the backtrace.
121   bool found = false;
122   for (Backtrace::const_iterator it = backtrace->begin(); it != backtrace->end(); ++it) {
123     if (it->func_name == "test_level_four") {
124       found = true;
125       break;
126     }
127   }
128 
129   return found;
130 }
131 
VerifyLevelDump(Backtrace * backtrace)132 void VerifyLevelDump(Backtrace* backtrace) {
133   ASSERT_GT(backtrace->NumFrames(), static_cast<size_t>(0))
134     << DumpFrames(backtrace);
135   ASSERT_LT(backtrace->NumFrames(), static_cast<size_t>(MAX_BACKTRACE_FRAMES))
136     << DumpFrames(backtrace);
137 
138   // Look through the frames starting at the highest to find the
139   // frame we want.
140   size_t frame_num = 0;
141   for (size_t i = backtrace->NumFrames()-1; i > 2; i--) {
142     if (backtrace->GetFrame(i)->func_name == "test_level_one") {
143       frame_num = i;
144       break;
145     }
146   }
147   ASSERT_LT(static_cast<size_t>(0), frame_num) << DumpFrames(backtrace);
148   ASSERT_LE(static_cast<size_t>(3), frame_num) << DumpFrames(backtrace);
149 
150   ASSERT_EQ(backtrace->GetFrame(frame_num)->func_name, "test_level_one")
151     << DumpFrames(backtrace);
152   ASSERT_EQ(backtrace->GetFrame(frame_num-1)->func_name, "test_level_two")
153     << DumpFrames(backtrace);
154   ASSERT_EQ(backtrace->GetFrame(frame_num-2)->func_name, "test_level_three")
155     << DumpFrames(backtrace);
156   ASSERT_EQ(backtrace->GetFrame(frame_num-3)->func_name, "test_level_four")
157     << DumpFrames(backtrace);
158 }
159 
VerifyLevelBacktrace(void *)160 void VerifyLevelBacktrace(void*) {
161   std::unique_ptr<Backtrace> backtrace(
162       Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
163   ASSERT_TRUE(backtrace.get() != nullptr);
164   ASSERT_TRUE(backtrace->Unwind(0));
165 
166   VerifyLevelDump(backtrace.get());
167 }
168 
ReadyMaxBacktrace(Backtrace * backtrace)169 bool ReadyMaxBacktrace(Backtrace* backtrace) {
170   return (backtrace->NumFrames() == MAX_BACKTRACE_FRAMES);
171 }
172 
VerifyMaxDump(Backtrace * backtrace)173 void VerifyMaxDump(Backtrace* backtrace) {
174   ASSERT_EQ(backtrace->NumFrames(), static_cast<size_t>(MAX_BACKTRACE_FRAMES))
175     << DumpFrames(backtrace);
176   // Verify that the last frame is our recursive call.
177   ASSERT_EQ(backtrace->GetFrame(MAX_BACKTRACE_FRAMES-1)->func_name, "test_recursive_call")
178     << DumpFrames(backtrace);
179 }
180 
VerifyMaxBacktrace(void *)181 void VerifyMaxBacktrace(void*) {
182   std::unique_ptr<Backtrace> backtrace(
183       Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
184   ASSERT_TRUE(backtrace.get() != nullptr);
185   ASSERT_TRUE(backtrace->Unwind(0));
186 
187   VerifyMaxDump(backtrace.get());
188 }
189 
ThreadSetState(void * data)190 void ThreadSetState(void* data) {
191   thread_t* thread = reinterpret_cast<thread_t*>(data);
192   android_atomic_acquire_store(1, &thread->state);
193   volatile int i = 0;
194   while (thread->state) {
195     i++;
196   }
197 }
198 
VerifyThreadTest(pid_t tid,void (* VerifyFunc)(Backtrace *))199 void VerifyThreadTest(pid_t tid, void (*VerifyFunc)(Backtrace*)) {
200   std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), tid));
201   ASSERT_TRUE(backtrace.get() != nullptr);
202   ASSERT_TRUE(backtrace->Unwind(0));
203 
204   VerifyFunc(backtrace.get());
205 }
206 
WaitForNonZero(int32_t * value,uint64_t seconds)207 bool WaitForNonZero(int32_t* value, uint64_t seconds) {
208   uint64_t start = NanoTime();
209   do {
210     if (android_atomic_acquire_load(value)) {
211       return true;
212     }
213   } while ((NanoTime() - start) < seconds * NS_PER_SEC);
214   return false;
215 }
216 
TEST(libbacktrace,local_no_unwind_frames)217 TEST(libbacktrace, local_no_unwind_frames) {
218   // Verify that a local unwind does not include any frames within
219   // libunwind or libbacktrace.
220   std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), getpid()));
221   ASSERT_TRUE(backtrace.get() != nullptr);
222   ASSERT_TRUE(backtrace->Unwind(0));
223 
224   ASSERT_TRUE(backtrace->NumFrames() != 0);
225   for (const auto& frame : *backtrace ) {
226     if (BacktraceMap::IsValid(frame.map)) {
227       const std::string name = basename(frame.map.name.c_str());
228       ASSERT_TRUE(name != "libunwind.so" && name != "libbacktrace.so")
229         << DumpFrames(backtrace.get());
230     }
231     break;
232   }
233 }
234 
TEST(libbacktrace,local_trace)235 TEST(libbacktrace, local_trace) {
236   ASSERT_NE(test_level_one(1, 2, 3, 4, VerifyLevelBacktrace, nullptr), 0);
237 }
238 
VerifyIgnoreFrames(Backtrace * bt_all,Backtrace * bt_ign1,Backtrace * bt_ign2,const char * cur_proc)239 void VerifyIgnoreFrames(
240     Backtrace* bt_all, Backtrace* bt_ign1,
241     Backtrace* bt_ign2, const char* cur_proc) {
242   EXPECT_EQ(bt_all->NumFrames(), bt_ign1->NumFrames() + 1)
243     << "All backtrace:\n" << DumpFrames(bt_all) << "Ignore 1 backtrace:\n" << DumpFrames(bt_ign1);
244   EXPECT_EQ(bt_all->NumFrames(), bt_ign2->NumFrames() + 2)
245     << "All backtrace:\n" << DumpFrames(bt_all) << "Ignore 2 backtrace:\n" << DumpFrames(bt_ign2);
246 
247   // Check all of the frames are the same > the current frame.
248   bool check = (cur_proc == nullptr);
249   for (size_t i = 0; i < bt_ign2->NumFrames(); i++) {
250     if (check) {
251       EXPECT_EQ(bt_ign2->GetFrame(i)->pc, bt_ign1->GetFrame(i+1)->pc);
252       EXPECT_EQ(bt_ign2->GetFrame(i)->sp, bt_ign1->GetFrame(i+1)->sp);
253       EXPECT_EQ(bt_ign2->GetFrame(i)->stack_size, bt_ign1->GetFrame(i+1)->stack_size);
254 
255       EXPECT_EQ(bt_ign2->GetFrame(i)->pc, bt_all->GetFrame(i+2)->pc);
256       EXPECT_EQ(bt_ign2->GetFrame(i)->sp, bt_all->GetFrame(i+2)->sp);
257       EXPECT_EQ(bt_ign2->GetFrame(i)->stack_size, bt_all->GetFrame(i+2)->stack_size);
258     }
259     if (!check && bt_ign2->GetFrame(i)->func_name == cur_proc) {
260       check = true;
261     }
262   }
263 }
264 
VerifyLevelIgnoreFrames(void *)265 void VerifyLevelIgnoreFrames(void*) {
266   std::unique_ptr<Backtrace> all(
267       Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
268   ASSERT_TRUE(all.get() != nullptr);
269   ASSERT_TRUE(all->Unwind(0));
270 
271   std::unique_ptr<Backtrace> ign1(
272       Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
273   ASSERT_TRUE(ign1.get() != nullptr);
274   ASSERT_TRUE(ign1->Unwind(1));
275 
276   std::unique_ptr<Backtrace> ign2(
277       Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
278   ASSERT_TRUE(ign2.get() != nullptr);
279   ASSERT_TRUE(ign2->Unwind(2));
280 
281   VerifyIgnoreFrames(all.get(), ign1.get(), ign2.get(), "VerifyLevelIgnoreFrames");
282 }
283 
TEST(libbacktrace,local_trace_ignore_frames)284 TEST(libbacktrace, local_trace_ignore_frames) {
285   ASSERT_NE(test_level_one(1, 2, 3, 4, VerifyLevelIgnoreFrames, nullptr), 0);
286 }
287 
TEST(libbacktrace,local_max_trace)288 TEST(libbacktrace, local_max_trace) {
289   ASSERT_NE(test_recursive_call(MAX_BACKTRACE_FRAMES+10, VerifyMaxBacktrace, nullptr), 0);
290 }
291 
VerifyProcTest(pid_t pid,pid_t tid,bool share_map,bool (* ReadyFunc)(Backtrace *),void (* VerifyFunc)(Backtrace *))292 void VerifyProcTest(pid_t pid, pid_t tid, bool share_map,
293                     bool (*ReadyFunc)(Backtrace*),
294                     void (*VerifyFunc)(Backtrace*)) {
295   pid_t ptrace_tid;
296   if (tid < 0) {
297     ptrace_tid = pid;
298   } else {
299     ptrace_tid = tid;
300   }
301   uint64_t start = NanoTime();
302   bool verified = false;
303   std::string last_dump;
304   do {
305     usleep(US_PER_MSEC);
306     if (ptrace(PTRACE_ATTACH, ptrace_tid, 0, 0) == 0) {
307       // Wait for the process to get to a stopping point.
308       WaitForStop(ptrace_tid);
309 
310       std::unique_ptr<BacktraceMap> map;
311       if (share_map) {
312         map.reset(BacktraceMap::Create(pid));
313       }
314       std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, tid, map.get()));
315       ASSERT_TRUE(backtrace.get() != nullptr);
316       ASSERT_TRUE(backtrace->Unwind(0));
317       if (ReadyFunc(backtrace.get())) {
318         VerifyFunc(backtrace.get());
319         verified = true;
320       } else {
321         last_dump = DumpFrames(backtrace.get());
322       }
323 
324       ASSERT_TRUE(ptrace(PTRACE_DETACH, ptrace_tid, 0, 0) == 0);
325     }
326     // If 5 seconds have passed, then we are done.
327   } while (!verified && (NanoTime() - start) <= 5 * NS_PER_SEC);
328   ASSERT_TRUE(verified) << "Last backtrace:\n" << last_dump;
329 }
330 
TEST(libbacktrace,ptrace_trace)331 TEST(libbacktrace, ptrace_trace) {
332   pid_t pid;
333   if ((pid = fork()) == 0) {
334     ASSERT_NE(test_level_one(1, 2, 3, 4, nullptr, nullptr), 0);
335     _exit(1);
336   }
337   VerifyProcTest(pid, BACKTRACE_CURRENT_THREAD, false, ReadyLevelBacktrace, VerifyLevelDump);
338 
339   kill(pid, SIGKILL);
340   int status;
341   ASSERT_EQ(waitpid(pid, &status, 0), pid);
342 }
343 
TEST(libbacktrace,ptrace_trace_shared_map)344 TEST(libbacktrace, ptrace_trace_shared_map) {
345   pid_t pid;
346   if ((pid = fork()) == 0) {
347     ASSERT_NE(test_level_one(1, 2, 3, 4, nullptr, nullptr), 0);
348     _exit(1);
349   }
350 
351   VerifyProcTest(pid, BACKTRACE_CURRENT_THREAD, true, ReadyLevelBacktrace, VerifyLevelDump);
352 
353   kill(pid, SIGKILL);
354   int status;
355   ASSERT_EQ(waitpid(pid, &status, 0), pid);
356 }
357 
TEST(libbacktrace,ptrace_max_trace)358 TEST(libbacktrace, ptrace_max_trace) {
359   pid_t pid;
360   if ((pid = fork()) == 0) {
361     ASSERT_NE(test_recursive_call(MAX_BACKTRACE_FRAMES+10, nullptr, nullptr), 0);
362     _exit(1);
363   }
364   VerifyProcTest(pid, BACKTRACE_CURRENT_THREAD, false, ReadyMaxBacktrace, VerifyMaxDump);
365 
366   kill(pid, SIGKILL);
367   int status;
368   ASSERT_EQ(waitpid(pid, &status, 0), pid);
369 }
370 
VerifyProcessIgnoreFrames(Backtrace * bt_all)371 void VerifyProcessIgnoreFrames(Backtrace* bt_all) {
372   std::unique_ptr<Backtrace> ign1(Backtrace::Create(bt_all->Pid(), BACKTRACE_CURRENT_THREAD));
373   ASSERT_TRUE(ign1.get() != nullptr);
374   ASSERT_TRUE(ign1->Unwind(1));
375 
376   std::unique_ptr<Backtrace> ign2(Backtrace::Create(bt_all->Pid(), BACKTRACE_CURRENT_THREAD));
377   ASSERT_TRUE(ign2.get() != nullptr);
378   ASSERT_TRUE(ign2->Unwind(2));
379 
380   VerifyIgnoreFrames(bt_all, ign1.get(), ign2.get(), nullptr);
381 }
382 
TEST(libbacktrace,ptrace_ignore_frames)383 TEST(libbacktrace, ptrace_ignore_frames) {
384   pid_t pid;
385   if ((pid = fork()) == 0) {
386     ASSERT_NE(test_level_one(1, 2, 3, 4, nullptr, nullptr), 0);
387     _exit(1);
388   }
389   VerifyProcTest(pid, BACKTRACE_CURRENT_THREAD, false, ReadyLevelBacktrace, VerifyProcessIgnoreFrames);
390 
391   kill(pid, SIGKILL);
392   int status;
393   ASSERT_EQ(waitpid(pid, &status, 0), pid);
394 }
395 
396 // Create a process with multiple threads and dump all of the threads.
PtraceThreadLevelRun(void *)397 void* PtraceThreadLevelRun(void*) {
398   EXPECT_NE(test_level_one(1, 2, 3, 4, nullptr, nullptr), 0);
399   return nullptr;
400 }
401 
GetThreads(pid_t pid,std::vector<pid_t> * threads)402 void GetThreads(pid_t pid, std::vector<pid_t>* threads) {
403   // Get the list of tasks.
404   char task_path[128];
405   snprintf(task_path, sizeof(task_path), "/proc/%d/task", pid);
406 
407   DIR* tasks_dir = opendir(task_path);
408   ASSERT_TRUE(tasks_dir != nullptr);
409   struct dirent* entry;
410   while ((entry = readdir(tasks_dir)) != nullptr) {
411     char* end;
412     pid_t tid = strtoul(entry->d_name, &end, 10);
413     if (*end == '\0') {
414       threads->push_back(tid);
415     }
416   }
417   closedir(tasks_dir);
418 }
419 
TEST(libbacktrace,ptrace_threads)420 TEST(libbacktrace, ptrace_threads) {
421   pid_t pid;
422   if ((pid = fork()) == 0) {
423     for (size_t i = 0; i < NUM_PTRACE_THREADS; i++) {
424       pthread_attr_t attr;
425       pthread_attr_init(&attr);
426       pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
427 
428       pthread_t thread;
429       ASSERT_TRUE(pthread_create(&thread, &attr, PtraceThreadLevelRun, nullptr) == 0);
430     }
431     ASSERT_NE(test_level_one(1, 2, 3, 4, nullptr, nullptr), 0);
432     _exit(1);
433   }
434 
435   // Check to see that all of the threads are running before unwinding.
436   std::vector<pid_t> threads;
437   uint64_t start = NanoTime();
438   do {
439     usleep(US_PER_MSEC);
440     threads.clear();
441     GetThreads(pid, &threads);
442   } while ((threads.size() != NUM_PTRACE_THREADS + 1) &&
443       ((NanoTime() - start) <= 5 * NS_PER_SEC));
444   ASSERT_EQ(threads.size(), static_cast<size_t>(NUM_PTRACE_THREADS + 1));
445 
446   ASSERT_TRUE(ptrace(PTRACE_ATTACH, pid, 0, 0) == 0);
447   WaitForStop(pid);
448   for (std::vector<int>::const_iterator it = threads.begin(); it != threads.end(); ++it) {
449     // Skip the current forked process, we only care about the threads.
450     if (pid == *it) {
451       continue;
452     }
453     VerifyProcTest(pid, *it, false, ReadyLevelBacktrace, VerifyLevelDump);
454   }
455   ASSERT_TRUE(ptrace(PTRACE_DETACH, pid, 0, 0) == 0);
456 
457   kill(pid, SIGKILL);
458   int status;
459   ASSERT_EQ(waitpid(pid, &status, 0), pid);
460 }
461 
VerifyLevelThread(void *)462 void VerifyLevelThread(void*) {
463   std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), gettid()));
464   ASSERT_TRUE(backtrace.get() != nullptr);
465   ASSERT_TRUE(backtrace->Unwind(0));
466 
467   VerifyLevelDump(backtrace.get());
468 }
469 
TEST(libbacktrace,thread_current_level)470 TEST(libbacktrace, thread_current_level) {
471   ASSERT_NE(test_level_one(1, 2, 3, 4, VerifyLevelThread, nullptr), 0);
472 }
473 
VerifyMaxThread(void *)474 void VerifyMaxThread(void*) {
475   std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), gettid()));
476   ASSERT_TRUE(backtrace.get() != nullptr);
477   ASSERT_TRUE(backtrace->Unwind(0));
478 
479   VerifyMaxDump(backtrace.get());
480 }
481 
TEST(libbacktrace,thread_current_max)482 TEST(libbacktrace, thread_current_max) {
483   ASSERT_NE(test_recursive_call(MAX_BACKTRACE_FRAMES+10, VerifyMaxThread, nullptr), 0);
484 }
485 
ThreadLevelRun(void * data)486 void* ThreadLevelRun(void* data) {
487   thread_t* thread = reinterpret_cast<thread_t*>(data);
488 
489   thread->tid = gettid();
490   EXPECT_NE(test_level_one(1, 2, 3, 4, ThreadSetState, data), 0);
491   return nullptr;
492 }
493 
TEST(libbacktrace,thread_level_trace)494 TEST(libbacktrace, thread_level_trace) {
495   pthread_attr_t attr;
496   pthread_attr_init(&attr);
497   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
498 
499   thread_t thread_data = { 0, 0, 0, nullptr };
500   pthread_t thread;
501   ASSERT_TRUE(pthread_create(&thread, &attr, ThreadLevelRun, &thread_data) == 0);
502 
503   // Wait up to 2 seconds for the tid to be set.
504   ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2));
505 
506   // Make sure that the thread signal used is not visible when compiled for
507   // the target.
508 #if !defined(__GLIBC__)
509   ASSERT_LT(THREAD_SIGNAL, SIGRTMIN);
510 #endif
511 
512   // Save the current signal action and make sure it is restored afterwards.
513   struct sigaction cur_action;
514   ASSERT_TRUE(sigaction(THREAD_SIGNAL, nullptr, &cur_action) == 0);
515 
516   std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), thread_data.tid));
517   ASSERT_TRUE(backtrace.get() != nullptr);
518   ASSERT_TRUE(backtrace->Unwind(0));
519 
520   VerifyLevelDump(backtrace.get());
521 
522   // Tell the thread to exit its infinite loop.
523   android_atomic_acquire_store(0, &thread_data.state);
524 
525   // Verify that the old action was restored.
526   struct sigaction new_action;
527   ASSERT_TRUE(sigaction(THREAD_SIGNAL, nullptr, &new_action) == 0);
528   EXPECT_EQ(cur_action.sa_sigaction, new_action.sa_sigaction);
529   // The SA_RESTORER flag gets set behind our back, so a direct comparison
530   // doesn't work unless we mask the value off. Mips doesn't have this
531   // flag, so skip this on that platform.
532 #if defined(SA_RESTORER)
533   cur_action.sa_flags &= ~SA_RESTORER;
534   new_action.sa_flags &= ~SA_RESTORER;
535 #elif defined(__GLIBC__)
536   // Our host compiler doesn't appear to define this flag for some reason.
537   cur_action.sa_flags &= ~0x04000000;
538   new_action.sa_flags &= ~0x04000000;
539 #endif
540   EXPECT_EQ(cur_action.sa_flags, new_action.sa_flags);
541 }
542 
TEST(libbacktrace,thread_ignore_frames)543 TEST(libbacktrace, thread_ignore_frames) {
544   pthread_attr_t attr;
545   pthread_attr_init(&attr);
546   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
547 
548   thread_t thread_data = { 0, 0, 0, nullptr };
549   pthread_t thread;
550   ASSERT_TRUE(pthread_create(&thread, &attr, ThreadLevelRun, &thread_data) == 0);
551 
552   // Wait up to 2 seconds for the tid to be set.
553   ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2));
554 
555   std::unique_ptr<Backtrace> all(Backtrace::Create(getpid(), thread_data.tid));
556   ASSERT_TRUE(all.get() != nullptr);
557   ASSERT_TRUE(all->Unwind(0));
558 
559   std::unique_ptr<Backtrace> ign1(Backtrace::Create(getpid(), thread_data.tid));
560   ASSERT_TRUE(ign1.get() != nullptr);
561   ASSERT_TRUE(ign1->Unwind(1));
562 
563   std::unique_ptr<Backtrace> ign2(Backtrace::Create(getpid(), thread_data.tid));
564   ASSERT_TRUE(ign2.get() != nullptr);
565   ASSERT_TRUE(ign2->Unwind(2));
566 
567   VerifyIgnoreFrames(all.get(), ign1.get(), ign2.get(), nullptr);
568 
569   // Tell the thread to exit its infinite loop.
570   android_atomic_acquire_store(0, &thread_data.state);
571 }
572 
ThreadMaxRun(void * data)573 void* ThreadMaxRun(void* data) {
574   thread_t* thread = reinterpret_cast<thread_t*>(data);
575 
576   thread->tid = gettid();
577   EXPECT_NE(test_recursive_call(MAX_BACKTRACE_FRAMES+10, ThreadSetState, data), 0);
578   return nullptr;
579 }
580 
TEST(libbacktrace,thread_max_trace)581 TEST(libbacktrace, thread_max_trace) {
582   pthread_attr_t attr;
583   pthread_attr_init(&attr);
584   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
585 
586   thread_t thread_data = { 0, 0, 0, nullptr };
587   pthread_t thread;
588   ASSERT_TRUE(pthread_create(&thread, &attr, ThreadMaxRun, &thread_data) == 0);
589 
590   // Wait for the tid to be set.
591   ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2));
592 
593   std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), thread_data.tid));
594   ASSERT_TRUE(backtrace.get() != nullptr);
595   ASSERT_TRUE(backtrace->Unwind(0));
596 
597   VerifyMaxDump(backtrace.get());
598 
599   // Tell the thread to exit its infinite loop.
600   android_atomic_acquire_store(0, &thread_data.state);
601 }
602 
ThreadDump(void * data)603 void* ThreadDump(void* data) {
604   dump_thread_t* dump = reinterpret_cast<dump_thread_t*>(data);
605   while (true) {
606     if (android_atomic_acquire_load(dump->now)) {
607       break;
608     }
609   }
610 
611   // The status of the actual unwind will be checked elsewhere.
612   dump->backtrace = Backtrace::Create(getpid(), dump->thread.tid);
613   dump->backtrace->Unwind(0);
614 
615   android_atomic_acquire_store(1, &dump->done);
616 
617   return nullptr;
618 }
619 
TEST(libbacktrace,thread_multiple_dump)620 TEST(libbacktrace, thread_multiple_dump) {
621   // Dump NUM_THREADS simultaneously.
622   std::vector<thread_t> runners(NUM_THREADS);
623   std::vector<dump_thread_t> dumpers(NUM_THREADS);
624 
625   pthread_attr_t attr;
626   pthread_attr_init(&attr);
627   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
628   for (size_t i = 0; i < NUM_THREADS; i++) {
629     // Launch the runners, they will spin in hard loops doing nothing.
630     runners[i].tid = 0;
631     runners[i].state = 0;
632     ASSERT_TRUE(pthread_create(&runners[i].threadId, &attr, ThreadMaxRun, &runners[i]) == 0);
633   }
634 
635   // Wait for tids to be set.
636   for (std::vector<thread_t>::iterator it = runners.begin(); it != runners.end(); ++it) {
637     ASSERT_TRUE(WaitForNonZero(&it->state, 30));
638   }
639 
640   // Start all of the dumpers at once, they will spin until they are signalled
641   // to begin their dump run.
642   int32_t dump_now = 0;
643   for (size_t i = 0; i < NUM_THREADS; i++) {
644     dumpers[i].thread.tid = runners[i].tid;
645     dumpers[i].thread.state = 0;
646     dumpers[i].done = 0;
647     dumpers[i].now = &dump_now;
648 
649     ASSERT_TRUE(pthread_create(&dumpers[i].thread.threadId, &attr, ThreadDump, &dumpers[i]) == 0);
650   }
651 
652   // Start all of the dumpers going at once.
653   android_atomic_acquire_store(1, &dump_now);
654 
655   for (size_t i = 0; i < NUM_THREADS; i++) {
656     ASSERT_TRUE(WaitForNonZero(&dumpers[i].done, 30));
657 
658     // Tell the runner thread to exit its infinite loop.
659     android_atomic_acquire_store(0, &runners[i].state);
660 
661     ASSERT_TRUE(dumpers[i].backtrace != nullptr);
662     VerifyMaxDump(dumpers[i].backtrace);
663 
664     delete dumpers[i].backtrace;
665     dumpers[i].backtrace = nullptr;
666   }
667 }
668 
TEST(libbacktrace,thread_multiple_dump_same_thread)669 TEST(libbacktrace, thread_multiple_dump_same_thread) {
670   pthread_attr_t attr;
671   pthread_attr_init(&attr);
672   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
673   thread_t runner;
674   runner.tid = 0;
675   runner.state = 0;
676   ASSERT_TRUE(pthread_create(&runner.threadId, &attr, ThreadMaxRun, &runner) == 0);
677 
678   // Wait for tids to be set.
679   ASSERT_TRUE(WaitForNonZero(&runner.state, 30));
680 
681   // Start all of the dumpers at once, they will spin until they are signalled
682   // to begin their dump run.
683   int32_t dump_now = 0;
684   // Dump the same thread NUM_THREADS simultaneously.
685   std::vector<dump_thread_t> dumpers(NUM_THREADS);
686   for (size_t i = 0; i < NUM_THREADS; i++) {
687     dumpers[i].thread.tid = runner.tid;
688     dumpers[i].thread.state = 0;
689     dumpers[i].done = 0;
690     dumpers[i].now = &dump_now;
691 
692     ASSERT_TRUE(pthread_create(&dumpers[i].thread.threadId, &attr, ThreadDump, &dumpers[i]) == 0);
693   }
694 
695   // Start all of the dumpers going at once.
696   android_atomic_acquire_store(1, &dump_now);
697 
698   for (size_t i = 0; i < NUM_THREADS; i++) {
699     ASSERT_TRUE(WaitForNonZero(&dumpers[i].done, 30));
700 
701     ASSERT_TRUE(dumpers[i].backtrace != nullptr);
702     VerifyMaxDump(dumpers[i].backtrace);
703 
704     delete dumpers[i].backtrace;
705     dumpers[i].backtrace = nullptr;
706   }
707 
708   // Tell the runner thread to exit its infinite loop.
709   android_atomic_acquire_store(0, &runner.state);
710 }
711 
712 // This test is for UnwindMaps that should share the same map cursor when
713 // multiple maps are created for the current process at the same time.
TEST(libbacktrace,simultaneous_maps)714 TEST(libbacktrace, simultaneous_maps) {
715   BacktraceMap* map1 = BacktraceMap::Create(getpid());
716   BacktraceMap* map2 = BacktraceMap::Create(getpid());
717   BacktraceMap* map3 = BacktraceMap::Create(getpid());
718 
719   Backtrace* back1 = Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD, map1);
720   ASSERT_TRUE(back1 != nullptr);
721   EXPECT_TRUE(back1->Unwind(0));
722   delete back1;
723   delete map1;
724 
725   Backtrace* back2 = Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD, map2);
726   ASSERT_TRUE(back2 != nullptr);
727   EXPECT_TRUE(back2->Unwind(0));
728   delete back2;
729   delete map2;
730 
731   Backtrace* back3 = Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD, map3);
732   ASSERT_TRUE(back3 != nullptr);
733   EXPECT_TRUE(back3->Unwind(0));
734   delete back3;
735   delete map3;
736 }
737 
TEST(libbacktrace,fillin_erases)738 TEST(libbacktrace, fillin_erases) {
739   BacktraceMap* back_map = BacktraceMap::Create(getpid());
740 
741   backtrace_map_t map;
742 
743   map.start = 1;
744   map.end = 3;
745   map.flags = 1;
746   map.name = "Initialized";
747   back_map->FillIn(0, &map);
748   delete back_map;
749 
750   ASSERT_FALSE(BacktraceMap::IsValid(map));
751   ASSERT_EQ(static_cast<uintptr_t>(0), map.start);
752   ASSERT_EQ(static_cast<uintptr_t>(0), map.end);
753   ASSERT_EQ(0, map.flags);
754   ASSERT_EQ("", map.name);
755 }
756 
TEST(libbacktrace,format_test)757 TEST(libbacktrace, format_test) {
758   std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD));
759   ASSERT_TRUE(backtrace.get() != nullptr);
760 
761   backtrace_frame_data_t frame;
762   frame.num = 1;
763   frame.pc = 2;
764   frame.sp = 0;
765   frame.stack_size = 0;
766   frame.func_offset = 0;
767 
768   // Check no map set.
769   frame.num = 1;
770 #if defined(__LP64__)
771   EXPECT_EQ("#01 pc 0000000000000002  <unknown>",
772 #else
773   EXPECT_EQ("#01 pc 00000002  <unknown>",
774 #endif
775             backtrace->FormatFrameData(&frame));
776 
777   // Check map name empty, but exists.
778   frame.map.start = 1;
779   frame.map.end = 1;
780   frame.map.load_base = 0;
781 #if defined(__LP64__)
782   EXPECT_EQ("#01 pc 0000000000000001  <unknown>",
783 #else
784   EXPECT_EQ("#01 pc 00000001  <unknown>",
785 #endif
786             backtrace->FormatFrameData(&frame));
787 
788 
789   // Check relative pc is set and map name is set.
790   frame.pc = 0x12345679;
791   frame.map.name = "MapFake";
792   frame.map.start =  1;
793   frame.map.end =  1;
794 #if defined(__LP64__)
795   EXPECT_EQ("#01 pc 0000000012345678  MapFake",
796 #else
797   EXPECT_EQ("#01 pc 12345678  MapFake",
798 #endif
799             backtrace->FormatFrameData(&frame));
800 
801   // Check func_name is set, but no func offset.
802   frame.func_name = "ProcFake";
803 #if defined(__LP64__)
804   EXPECT_EQ("#01 pc 0000000012345678  MapFake (ProcFake)",
805 #else
806   EXPECT_EQ("#01 pc 12345678  MapFake (ProcFake)",
807 #endif
808             backtrace->FormatFrameData(&frame));
809 
810   // Check func_name is set, and func offset is non-zero.
811   frame.func_offset = 645;
812 #if defined(__LP64__)
813   EXPECT_EQ("#01 pc 0000000012345678  MapFake (ProcFake+645)",
814 #else
815   EXPECT_EQ("#01 pc 12345678  MapFake (ProcFake+645)",
816 #endif
817             backtrace->FormatFrameData(&frame));
818 
819   // Check func_name is set, func offset is non-zero, and load_base is non-zero.
820   frame.func_offset = 645;
821   frame.map.load_base = 100;
822 #if defined(__LP64__)
823   EXPECT_EQ("#01 pc 00000000123456dc  MapFake (ProcFake+645)",
824 #else
825   EXPECT_EQ("#01 pc 123456dc  MapFake (ProcFake+645)",
826 #endif
827             backtrace->FormatFrameData(&frame));
828 
829   // Check a non-zero map offset.
830   frame.map.offset = 0x1000;
831 #if defined(__LP64__)
832   EXPECT_EQ("#01 pc 00000000123456dc  MapFake (offset 0x1000) (ProcFake+645)",
833 #else
834   EXPECT_EQ("#01 pc 123456dc  MapFake (offset 0x1000) (ProcFake+645)",
835 #endif
836             backtrace->FormatFrameData(&frame));
837 }
838 
839 struct map_test_t {
840   uintptr_t start;
841   uintptr_t end;
842 };
843 
map_sort(map_test_t i,map_test_t j)844 bool map_sort(map_test_t i, map_test_t j) {
845   return i.start < j.start;
846 }
847 
VerifyMap(pid_t pid)848 void VerifyMap(pid_t pid) {
849   char buffer[4096];
850   snprintf(buffer, sizeof(buffer), "/proc/%d/maps", pid);
851 
852   FILE* map_file = fopen(buffer, "r");
853   ASSERT_TRUE(map_file != nullptr);
854   std::vector<map_test_t> test_maps;
855   while (fgets(buffer, sizeof(buffer), map_file)) {
856     map_test_t map;
857     ASSERT_EQ(2, sscanf(buffer, "%" SCNxPTR "-%" SCNxPTR " ", &map.start, &map.end));
858     test_maps.push_back(map);
859   }
860   fclose(map_file);
861   std::sort(test_maps.begin(), test_maps.end(), map_sort);
862 
863   std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(pid));
864 
865   // Basic test that verifies that the map is in the expected order.
866   std::vector<map_test_t>::const_iterator test_it = test_maps.begin();
867   for (BacktraceMap::const_iterator it = map->begin(); it != map->end(); ++it) {
868     ASSERT_TRUE(test_it != test_maps.end());
869     ASSERT_EQ(test_it->start, it->start);
870     ASSERT_EQ(test_it->end, it->end);
871     ++test_it;
872   }
873   ASSERT_TRUE(test_it == test_maps.end());
874 }
875 
TEST(libbacktrace,verify_map_remote)876 TEST(libbacktrace, verify_map_remote) {
877   pid_t pid;
878 
879   if ((pid = fork()) == 0) {
880     while (true) {
881     }
882     _exit(0);
883   }
884   ASSERT_LT(0, pid);
885 
886   ASSERT_TRUE(ptrace(PTRACE_ATTACH, pid, 0, 0) == 0);
887 
888   // Wait for the process to get to a stopping point.
889   WaitForStop(pid);
890 
891   // The maps should match exactly since the forked process has been paused.
892   VerifyMap(pid);
893 
894   ASSERT_TRUE(ptrace(PTRACE_DETACH, pid, 0, 0) == 0);
895 
896   kill(pid, SIGKILL);
897   ASSERT_EQ(waitpid(pid, nullptr, 0), pid);
898 }
899 
InitMemory(uint8_t * memory,size_t bytes)900 void InitMemory(uint8_t* memory, size_t bytes) {
901   for (size_t i = 0; i < bytes; i++) {
902     memory[i] = i;
903     if (memory[i] == '\0') {
904       // Don't use '\0' in our data so we can verify that an overread doesn't
905       // occur by using a '\0' as the character after the read data.
906       memory[i] = 23;
907     }
908   }
909 }
910 
ThreadReadTest(void * data)911 void* ThreadReadTest(void* data) {
912   thread_t* thread_data = reinterpret_cast<thread_t*>(data);
913 
914   thread_data->tid = gettid();
915 
916   // Create two map pages.
917   // Mark the second page as not-readable.
918   size_t pagesize = static_cast<size_t>(sysconf(_SC_PAGE_SIZE));
919   uint8_t* memory;
920   if (posix_memalign(reinterpret_cast<void**>(&memory), pagesize, 2 * pagesize) != 0) {
921     return reinterpret_cast<void*>(-1);
922   }
923 
924   if (mprotect(&memory[pagesize], pagesize, PROT_NONE) != 0) {
925     return reinterpret_cast<void*>(-1);
926   }
927 
928   // Set up a simple pattern in memory.
929   InitMemory(memory, pagesize);
930 
931   thread_data->data = memory;
932 
933   // Tell the caller it's okay to start reading memory.
934   android_atomic_acquire_store(1, &thread_data->state);
935 
936   // Loop waiting for the caller to finish reading the memory.
937   while (thread_data->state) {
938   }
939 
940   // Re-enable read-write on the page so that we don't crash if we try
941   // and access data on this page when freeing the memory.
942   if (mprotect(&memory[pagesize], pagesize, PROT_READ | PROT_WRITE) != 0) {
943     return reinterpret_cast<void*>(-1);
944   }
945   free(memory);
946 
947   android_atomic_acquire_store(1, &thread_data->state);
948 
949   return nullptr;
950 }
951 
RunReadTest(Backtrace * backtrace,uintptr_t read_addr)952 void RunReadTest(Backtrace* backtrace, uintptr_t read_addr) {
953   size_t pagesize = static_cast<size_t>(sysconf(_SC_PAGE_SIZE));
954 
955   // Create a page of data to use to do quick compares.
956   uint8_t* expected = new uint8_t[pagesize];
957   InitMemory(expected, pagesize);
958 
959   uint8_t* data = new uint8_t[2*pagesize];
960   // Verify that we can only read one page worth of data.
961   size_t bytes_read = backtrace->Read(read_addr, data, 2 * pagesize);
962   ASSERT_EQ(pagesize, bytes_read);
963   ASSERT_TRUE(memcmp(data, expected, pagesize) == 0);
964 
965   // Verify unaligned reads.
966   for (size_t i = 1; i < sizeof(word_t); i++) {
967     bytes_read = backtrace->Read(read_addr + i, data, 2 * sizeof(word_t));
968     ASSERT_EQ(2 * sizeof(word_t), bytes_read);
969     ASSERT_TRUE(memcmp(data, &expected[i], 2 * sizeof(word_t)) == 0)
970         << "Offset at " << i << " failed";
971   }
972 
973   // Verify small unaligned reads.
974   for (size_t i = 1; i < sizeof(word_t); i++) {
975     for (size_t j = 1; j < sizeof(word_t); j++) {
976       // Set one byte past what we expect to read, to guarantee we don't overread.
977       data[j] = '\0';
978       bytes_read = backtrace->Read(read_addr + i, data, j);
979       ASSERT_EQ(j, bytes_read);
980       ASSERT_TRUE(memcmp(data, &expected[i], j) == 0)
981           << "Offset at " << i << " length " << j << " miscompared";
982       ASSERT_EQ('\0', data[j])
983           << "Offset at " << i << " length " << j << " wrote too much data";
984     }
985   }
986   delete data;
987   delete expected;
988 }
989 
TEST(libbacktrace,thread_read)990 TEST(libbacktrace, thread_read) {
991   pthread_attr_t attr;
992   pthread_attr_init(&attr);
993   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
994   pthread_t thread;
995   thread_t thread_data = { 0, 0, 0, nullptr };
996   ASSERT_TRUE(pthread_create(&thread, &attr, ThreadReadTest, &thread_data) == 0);
997 
998   ASSERT_TRUE(WaitForNonZero(&thread_data.state, 10));
999 
1000   std::unique_ptr<Backtrace> backtrace(Backtrace::Create(getpid(), thread_data.tid));
1001   ASSERT_TRUE(backtrace.get() != nullptr);
1002 
1003   RunReadTest(backtrace.get(), reinterpret_cast<uintptr_t>(thread_data.data));
1004 
1005   android_atomic_acquire_store(0, &thread_data.state);
1006 
1007   ASSERT_TRUE(WaitForNonZero(&thread_data.state, 10));
1008 }
1009 
1010 volatile uintptr_t g_ready = 0;
1011 volatile uintptr_t g_addr = 0;
1012 
ForkedReadTest()1013 void ForkedReadTest() {
1014   // Create two map pages.
1015   size_t pagesize = static_cast<size_t>(sysconf(_SC_PAGE_SIZE));
1016   uint8_t* memory;
1017   if (posix_memalign(reinterpret_cast<void**>(&memory), pagesize, 2 * pagesize) != 0) {
1018     perror("Failed to allocate memory\n");
1019     exit(1);
1020   }
1021 
1022   // Mark the second page as not-readable.
1023   if (mprotect(&memory[pagesize], pagesize, PROT_NONE) != 0) {
1024     perror("Failed to mprotect memory\n");
1025     exit(1);
1026   }
1027 
1028   // Set up a simple pattern in memory.
1029   InitMemory(memory, pagesize);
1030 
1031   g_addr = reinterpret_cast<uintptr_t>(memory);
1032   g_ready = 1;
1033 
1034   while (1) {
1035     usleep(US_PER_MSEC);
1036   }
1037 }
1038 
TEST(libbacktrace,process_read)1039 TEST(libbacktrace, process_read) {
1040   g_ready = 0;
1041   pid_t pid;
1042   if ((pid = fork()) == 0) {
1043     ForkedReadTest();
1044     exit(0);
1045   }
1046   ASSERT_NE(-1, pid);
1047 
1048   bool test_executed = false;
1049   uint64_t start = NanoTime();
1050   while (1) {
1051     if (ptrace(PTRACE_ATTACH, pid, 0, 0) == 0) {
1052       WaitForStop(pid);
1053 
1054       std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, pid));
1055       ASSERT_TRUE(backtrace.get() != nullptr);
1056 
1057       uintptr_t read_addr;
1058       size_t bytes_read = backtrace->Read(reinterpret_cast<uintptr_t>(&g_ready),
1059                                           reinterpret_cast<uint8_t*>(&read_addr),
1060                                           sizeof(uintptr_t));
1061       ASSERT_EQ(sizeof(uintptr_t), bytes_read);
1062       if (read_addr) {
1063         // The forked process is ready to be read.
1064         bytes_read = backtrace->Read(reinterpret_cast<uintptr_t>(&g_addr),
1065                                      reinterpret_cast<uint8_t*>(&read_addr),
1066                                      sizeof(uintptr_t));
1067         ASSERT_EQ(sizeof(uintptr_t), bytes_read);
1068 
1069         RunReadTest(backtrace.get(), read_addr);
1070 
1071         test_executed = true;
1072         break;
1073       }
1074       ASSERT_TRUE(ptrace(PTRACE_DETACH, pid, 0, 0) == 0);
1075     }
1076     if ((NanoTime() - start) > 5 * NS_PER_SEC) {
1077       break;
1078     }
1079     usleep(US_PER_MSEC);
1080   }
1081   kill(pid, SIGKILL);
1082   ASSERT_EQ(waitpid(pid, nullptr, 0), pid);
1083 
1084   ASSERT_TRUE(test_executed);
1085 }
1086 
VerifyFunctionsFound(const std::vector<std::string> & found_functions)1087 void VerifyFunctionsFound(const std::vector<std::string>& found_functions) {
1088   // We expect to find these functions in libbacktrace_test. If we don't
1089   // find them, that's a bug in the memory read handling code in libunwind.
1090   std::list<std::string> expected_functions;
1091   expected_functions.push_back("test_recursive_call");
1092   expected_functions.push_back("test_level_one");
1093   expected_functions.push_back("test_level_two");
1094   expected_functions.push_back("test_level_three");
1095   expected_functions.push_back("test_level_four");
1096   for (const auto& found_function : found_functions) {
1097     for (const auto& expected_function : expected_functions) {
1098       if (found_function == expected_function) {
1099         expected_functions.remove(found_function);
1100         break;
1101       }
1102     }
1103   }
1104   ASSERT_TRUE(expected_functions.empty()) << "Not all functions found in shared library.";
1105 }
1106 
CopySharedLibrary()1107 const char* CopySharedLibrary() {
1108 #if defined(__LP64__)
1109   const char* lib_name = "lib64";
1110 #else
1111   const char* lib_name = "lib";
1112 #endif
1113 
1114 #if defined(__BIONIC__)
1115   const char* tmp_so_name = "/data/local/tmp/libbacktrace_test.so";
1116   std::string cp_cmd = android::base::StringPrintf("cp /system/%s/libbacktrace_test.so %s",
1117                                                    lib_name, tmp_so_name);
1118 #else
1119   const char* tmp_so_name = "/tmp/libbacktrace_test.so";
1120   if (getenv("ANDROID_HOST_OUT") == NULL) {
1121     fprintf(stderr, "ANDROID_HOST_OUT not set, make sure you run lunch.");
1122     return nullptr;
1123   }
1124   std::string cp_cmd = android::base::StringPrintf("cp %s/%s/libbacktrace_test.so %s",
1125                                                    getenv("ANDROID_HOST_OUT"), lib_name,
1126                                                    tmp_so_name);
1127 #endif
1128 
1129   // Copy the shared so to a tempory directory.
1130   system(cp_cmd.c_str());
1131 
1132   return tmp_so_name;
1133 }
1134 
TEST(libbacktrace,check_unreadable_elf_local)1135 TEST(libbacktrace, check_unreadable_elf_local) {
1136   const char* tmp_so_name = CopySharedLibrary();
1137   ASSERT_TRUE(tmp_so_name != nullptr);
1138 
1139   struct stat buf;
1140   ASSERT_TRUE(stat(tmp_so_name, &buf) != -1);
1141   uintptr_t map_size = buf.st_size;
1142 
1143   int fd = open(tmp_so_name, O_RDONLY);
1144   ASSERT_TRUE(fd != -1);
1145 
1146   void* map = mmap(NULL, map_size, PROT_READ, MAP_PRIVATE, fd, 0);
1147   ASSERT_TRUE(map != MAP_FAILED);
1148   close(fd);
1149   ASSERT_TRUE(unlink(tmp_so_name) != -1);
1150 
1151   std::vector<std::string> found_functions;
1152   std::unique_ptr<Backtrace> backtrace(Backtrace::Create(BACKTRACE_CURRENT_PROCESS,
1153                                                          BACKTRACE_CURRENT_THREAD));
1154   ASSERT_TRUE(backtrace.get() != nullptr);
1155 
1156   // Needed before GetFunctionName will work.
1157   backtrace->Unwind(0);
1158 
1159   // Loop through the entire map, and get every function we can find.
1160   map_size += reinterpret_cast<uintptr_t>(map);
1161   std::string last_func;
1162   for (uintptr_t read_addr = reinterpret_cast<uintptr_t>(map);
1163        read_addr < map_size; read_addr += 4) {
1164     uintptr_t offset;
1165     std::string func_name = backtrace->GetFunctionName(read_addr, &offset);
1166     if (!func_name.empty() && last_func != func_name) {
1167       found_functions.push_back(func_name);
1168     }
1169     last_func = func_name;
1170   }
1171 
1172   ASSERT_TRUE(munmap(map, map_size - reinterpret_cast<uintptr_t>(map)) == 0);
1173 
1174   VerifyFunctionsFound(found_functions);
1175 }
1176 
TEST(libbacktrace,check_unreadable_elf_remote)1177 TEST(libbacktrace, check_unreadable_elf_remote) {
1178   const char* tmp_so_name = CopySharedLibrary();
1179   ASSERT_TRUE(tmp_so_name != nullptr);
1180 
1181   g_ready = 0;
1182 
1183   struct stat buf;
1184   ASSERT_TRUE(stat(tmp_so_name, &buf) != -1);
1185   uintptr_t map_size = buf.st_size;
1186 
1187   pid_t pid;
1188   if ((pid = fork()) == 0) {
1189     int fd = open(tmp_so_name, O_RDONLY);
1190     if (fd == -1) {
1191       fprintf(stderr, "Failed to open file %s: %s\n", tmp_so_name, strerror(errno));
1192       unlink(tmp_so_name);
1193       exit(0);
1194     }
1195 
1196     void* map = mmap(NULL, map_size, PROT_READ, MAP_PRIVATE, fd, 0);
1197     if (map == MAP_FAILED) {
1198       fprintf(stderr, "Failed to map in memory: %s\n", strerror(errno));
1199       unlink(tmp_so_name);
1200       exit(0);
1201     }
1202     close(fd);
1203     if (unlink(tmp_so_name) == -1) {
1204       fprintf(stderr, "Failed to unlink: %s\n", strerror(errno));
1205       exit(0);
1206     }
1207 
1208     g_addr = reinterpret_cast<uintptr_t>(map);
1209     g_ready = 1;
1210     while (true) {
1211       usleep(US_PER_MSEC);
1212     }
1213     exit(0);
1214   }
1215   ASSERT_TRUE(pid > 0);
1216 
1217   std::vector<std::string> found_functions;
1218   uint64_t start = NanoTime();
1219   while (true) {
1220     ASSERT_TRUE(ptrace(PTRACE_ATTACH, pid, 0, 0) == 0);
1221 
1222     // Wait for the process to get to a stopping point.
1223     WaitForStop(pid);
1224 
1225     std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, BACKTRACE_CURRENT_THREAD));
1226     ASSERT_TRUE(backtrace.get() != nullptr);
1227 
1228     uintptr_t read_addr;
1229     ASSERT_EQ(sizeof(uintptr_t), backtrace->Read(reinterpret_cast<uintptr_t>(&g_ready), reinterpret_cast<uint8_t*>(&read_addr), sizeof(uintptr_t)));
1230     if (read_addr) {
1231       ASSERT_EQ(sizeof(uintptr_t), backtrace->Read(reinterpret_cast<uintptr_t>(&g_addr), reinterpret_cast<uint8_t*>(&read_addr), sizeof(uintptr_t)));
1232 
1233       // Needed before GetFunctionName will work.
1234       backtrace->Unwind(0);
1235 
1236       // Loop through the entire map, and get every function we can find.
1237       map_size += read_addr;
1238       std::string last_func;
1239       for (; read_addr < map_size; read_addr += 4) {
1240         uintptr_t offset;
1241         std::string func_name = backtrace->GetFunctionName(read_addr, &offset);
1242         if (!func_name.empty() && last_func != func_name) {
1243           found_functions.push_back(func_name);
1244         }
1245         last_func = func_name;
1246       }
1247       break;
1248     }
1249     ASSERT_TRUE(ptrace(PTRACE_DETACH, pid, 0, 0) == 0);
1250 
1251     if ((NanoTime() - start) > 5 * NS_PER_SEC) {
1252       break;
1253     }
1254     usleep(US_PER_MSEC);
1255   }
1256 
1257   kill(pid, SIGKILL);
1258   ASSERT_EQ(waitpid(pid, nullptr, 0), pid);
1259 
1260   VerifyFunctionsFound(found_functions);
1261 }
1262 
FindFuncFrameInBacktrace(Backtrace * backtrace,uintptr_t test_func,size_t * frame_num)1263 bool FindFuncFrameInBacktrace(Backtrace* backtrace, uintptr_t test_func, size_t* frame_num) {
1264   backtrace_map_t map;
1265   backtrace->FillInMap(test_func, &map);
1266   if (!BacktraceMap::IsValid(map)) {
1267     return false;
1268   }
1269 
1270   // Loop through the frames, and find the one that is in the map.
1271   *frame_num = 0;
1272   for (Backtrace::const_iterator it = backtrace->begin(); it != backtrace->end(); ++it) {
1273     if (BacktraceMap::IsValid(it->map) && map.start == it->map.start &&
1274         it->pc >= test_func) {
1275       *frame_num = it->num;
1276       return true;
1277     }
1278   }
1279   return false;
1280 }
1281 
VerifyUnreadableElfFrame(Backtrace * backtrace,uintptr_t test_func,size_t frame_num)1282 void VerifyUnreadableElfFrame(Backtrace* backtrace, uintptr_t test_func, size_t frame_num) {
1283   ASSERT_LT(backtrace->NumFrames(), static_cast<size_t>(MAX_BACKTRACE_FRAMES))
1284     << DumpFrames(backtrace);
1285 
1286   ASSERT_TRUE(frame_num != 0) << DumpFrames(backtrace);
1287   // Make sure that there is at least one more frame above the test func call.
1288   ASSERT_LT(frame_num, backtrace->NumFrames()) << DumpFrames(backtrace);
1289 
1290   uintptr_t diff = backtrace->GetFrame(frame_num)->pc - test_func;
1291   ASSERT_LT(diff, 200U) << DumpFrames(backtrace);
1292 }
1293 
VerifyUnreadableElfBacktrace(uintptr_t test_func)1294 void VerifyUnreadableElfBacktrace(uintptr_t test_func) {
1295   std::unique_ptr<Backtrace> backtrace(Backtrace::Create(BACKTRACE_CURRENT_PROCESS,
1296                                                          BACKTRACE_CURRENT_THREAD));
1297   ASSERT_TRUE(backtrace.get() != nullptr);
1298   ASSERT_TRUE(backtrace->Unwind(0));
1299 
1300   size_t frame_num;
1301   ASSERT_TRUE(FindFuncFrameInBacktrace(backtrace.get(), test_func, &frame_num));
1302 
1303   VerifyUnreadableElfFrame(backtrace.get(), test_func, frame_num);
1304 }
1305 
1306 typedef int (*test_func_t)(int, int, int, int, void (*)(uintptr_t), uintptr_t);
1307 
TEST(libbacktrace,unwind_through_unreadable_elf_local)1308 TEST(libbacktrace, unwind_through_unreadable_elf_local) {
1309   const char* tmp_so_name = CopySharedLibrary();
1310   ASSERT_TRUE(tmp_so_name != nullptr);
1311   void* lib_handle = dlopen(tmp_so_name, RTLD_NOW);
1312   ASSERT_TRUE(lib_handle != nullptr);
1313   ASSERT_TRUE(unlink(tmp_so_name) != -1);
1314 
1315   test_func_t test_func;
1316   test_func = reinterpret_cast<test_func_t>(dlsym(lib_handle, "test_level_one"));
1317   ASSERT_TRUE(test_func != nullptr);
1318 
1319   ASSERT_NE(test_func(1, 2, 3, 4, VerifyUnreadableElfBacktrace,
1320                       reinterpret_cast<uintptr_t>(test_func)), 0);
1321 
1322   ASSERT_TRUE(dlclose(lib_handle) == 0);
1323 }
1324 
TEST(libbacktrace,unwind_through_unreadable_elf_remote)1325 TEST(libbacktrace, unwind_through_unreadable_elf_remote) {
1326   const char* tmp_so_name = CopySharedLibrary();
1327   ASSERT_TRUE(tmp_so_name != nullptr);
1328   void* lib_handle = dlopen(tmp_so_name, RTLD_NOW);
1329   ASSERT_TRUE(lib_handle != nullptr);
1330   ASSERT_TRUE(unlink(tmp_so_name) != -1);
1331 
1332   test_func_t test_func;
1333   test_func = reinterpret_cast<test_func_t>(dlsym(lib_handle, "test_level_one"));
1334   ASSERT_TRUE(test_func != nullptr);
1335 
1336   pid_t pid;
1337   if ((pid = fork()) == 0) {
1338     test_func(1, 2, 3, 4, 0, 0);
1339     exit(0);
1340   }
1341   ASSERT_TRUE(pid > 0);
1342   ASSERT_TRUE(dlclose(lib_handle) == 0);
1343 
1344   uint64_t start = NanoTime();
1345   bool done = false;
1346   while (!done) {
1347     ASSERT_TRUE(ptrace(PTRACE_ATTACH, pid, 0, 0) == 0);
1348 
1349     // Wait for the process to get to a stopping point.
1350     WaitForStop(pid);
1351 
1352     std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, BACKTRACE_CURRENT_THREAD));
1353     ASSERT_TRUE(backtrace.get() != nullptr);
1354     ASSERT_TRUE(backtrace->Unwind(0));
1355 
1356     size_t frame_num;
1357     if (FindFuncFrameInBacktrace(backtrace.get(),
1358                                  reinterpret_cast<uintptr_t>(test_func), &frame_num)) {
1359 
1360       VerifyUnreadableElfFrame(backtrace.get(), reinterpret_cast<uintptr_t>(test_func), frame_num);
1361       done = true;
1362     }
1363 
1364     ASSERT_TRUE(ptrace(PTRACE_DETACH, pid, 0, 0) == 0);
1365 
1366     if ((NanoTime() - start) > 5 * NS_PER_SEC) {
1367       break;
1368     }
1369     usleep(US_PER_MSEC);
1370   }
1371 
1372   kill(pid, SIGKILL);
1373   ASSERT_EQ(waitpid(pid, nullptr, 0), pid);
1374 
1375   ASSERT_TRUE(done) << "Test function never found in unwind.";
1376 }
1377 
1378 #if defined(ENABLE_PSS_TESTS)
1379 #include "GetPss.h"
1380 
1381 #define MAX_LEAK_BYTES 32*1024UL
1382 
CheckForLeak(pid_t pid,pid_t tid)1383 void CheckForLeak(pid_t pid, pid_t tid) {
1384   // Do a few runs to get the PSS stable.
1385   for (size_t i = 0; i < 100; i++) {
1386     Backtrace* backtrace = Backtrace::Create(pid, tid);
1387     ASSERT_TRUE(backtrace != nullptr);
1388     ASSERT_TRUE(backtrace->Unwind(0));
1389     delete backtrace;
1390   }
1391   size_t stable_pss = GetPssBytes();
1392   ASSERT_TRUE(stable_pss != 0);
1393 
1394   // Loop enough that even a small leak should be detectable.
1395   for (size_t i = 0; i < 4096; i++) {
1396     Backtrace* backtrace = Backtrace::Create(pid, tid);
1397     ASSERT_TRUE(backtrace != nullptr);
1398     ASSERT_TRUE(backtrace->Unwind(0));
1399     delete backtrace;
1400   }
1401   size_t new_pss = GetPssBytes();
1402   ASSERT_TRUE(new_pss != 0);
1403   size_t abs_diff = (new_pss > stable_pss) ? new_pss - stable_pss : stable_pss - new_pss;
1404   // As long as the new pss is within a certain amount, consider everything okay.
1405   ASSERT_LE(abs_diff, MAX_LEAK_BYTES);
1406 }
1407 
TEST(libbacktrace,check_for_leak_local)1408 TEST(libbacktrace, check_for_leak_local) {
1409   CheckForLeak(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD);
1410 }
1411 
TEST(libbacktrace,check_for_leak_local_thread)1412 TEST(libbacktrace, check_for_leak_local_thread) {
1413   thread_t thread_data = { 0, 0, 0, nullptr };
1414   pthread_t thread;
1415   ASSERT_TRUE(pthread_create(&thread, nullptr, ThreadLevelRun, &thread_data) == 0);
1416 
1417   // Wait up to 2 seconds for the tid to be set.
1418   ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2));
1419 
1420   CheckForLeak(BACKTRACE_CURRENT_PROCESS, thread_data.tid);
1421 
1422   // Tell the thread to exit its infinite loop.
1423   android_atomic_acquire_store(0, &thread_data.state);
1424 
1425   ASSERT_TRUE(pthread_join(thread, nullptr) == 0);
1426 }
1427 
TEST(libbacktrace,check_for_leak_remote)1428 TEST(libbacktrace, check_for_leak_remote) {
1429   pid_t pid;
1430 
1431   if ((pid = fork()) == 0) {
1432     while (true) {
1433     }
1434     _exit(0);
1435   }
1436   ASSERT_LT(0, pid);
1437 
1438   ASSERT_TRUE(ptrace(PTRACE_ATTACH, pid, 0, 0) == 0);
1439 
1440   // Wait for the process to get to a stopping point.
1441   WaitForStop(pid);
1442 
1443   CheckForLeak(pid, BACKTRACE_CURRENT_THREAD);
1444 
1445   ASSERT_TRUE(ptrace(PTRACE_DETACH, pid, 0, 0) == 0);
1446 
1447   kill(pid, SIGKILL);
1448   ASSERT_EQ(waitpid(pid, nullptr, 0), pid);
1449 }
1450 #endif
1451 
1452