• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include <dirent.h>
18 #include <errno.h>
19 #include <inttypes.h>
20 #include <pthread.h>
21 #include <signal.h>
22 #include <stdint.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <sys/ptrace.h>
27 #include <sys/types.h>
28 #include <sys/wait.h>
29 #include <time.h>
30 #include <unistd.h>
31 
32 #include <backtrace/Backtrace.h>
33 #include <backtrace/BacktraceMap.h>
34 #include <UniquePtr.h>
35 
36 // For the THREAD_SIGNAL definition.
37 #include "BacktraceThread.h"
38 
39 #include <cutils/atomic.h>
40 #include <gtest/gtest.h>
41 
42 #include <algorithm>
43 #include <vector>
44 
45 #include "thread_utils.h"
46 
47 // Number of microseconds per milliseconds.
48 #define US_PER_MSEC             1000
49 
50 // Number of nanoseconds in a second.
51 #define NS_PER_SEC              1000000000ULL
52 
53 // Number of simultaneous dumping operations to perform.
54 #define NUM_THREADS  40
55 
56 // Number of simultaneous threads running in our forked process.
57 #define NUM_PTRACE_THREADS 5
58 
59 struct thread_t {
60   pid_t tid;
61   int32_t state;
62   pthread_t threadId;
63 };
64 
65 struct dump_thread_t {
66   thread_t thread;
67   Backtrace* backtrace;
68   int32_t* now;
69   int32_t done;
70 };
71 
72 extern "C" {
73 // Prototypes for functions in the test library.
74 int test_level_one(int, int, int, int, void (*)(void*), void*);
75 
76 int test_recursive_call(int, void (*)(void*), void*);
77 }
78 
NanoTime()79 uint64_t NanoTime() {
80   struct timespec t = { 0, 0 };
81   clock_gettime(CLOCK_MONOTONIC, &t);
82   return static_cast<uint64_t>(t.tv_sec * NS_PER_SEC + t.tv_nsec);
83 }
84 
DumpFrames(Backtrace * backtrace)85 void DumpFrames(Backtrace* backtrace) {
86   if (backtrace->NumFrames() == 0) {
87     printf("    No frames to dump\n");
88     return;
89   }
90 
91   for (size_t i = 0; i < backtrace->NumFrames(); i++) {
92     printf("    %s\n", backtrace->FormatFrameData(i).c_str());
93   }
94 }
95 
WaitForStop(pid_t pid)96 void WaitForStop(pid_t pid) {
97   uint64_t start = NanoTime();
98 
99   siginfo_t si;
100   while (ptrace(PTRACE_GETSIGINFO, pid, 0, &si) < 0 && (errno == EINTR || errno == ESRCH)) {
101     if ((NanoTime() - start) > NS_PER_SEC) {
102       printf("The process did not get to a stopping point in 1 second.\n");
103       break;
104     }
105     usleep(US_PER_MSEC);
106   }
107 }
108 
ReadyLevelBacktrace(Backtrace * backtrace)109 bool ReadyLevelBacktrace(Backtrace* backtrace) {
110   // See if test_level_four is in the backtrace.
111   bool found = false;
112   for (Backtrace::const_iterator it = backtrace->begin(); it != backtrace->end(); ++it) {
113     if (it->func_name == "test_level_four") {
114       found = true;
115       break;
116     }
117   }
118 
119   return found;
120 }
121 
VerifyLevelDump(Backtrace * backtrace)122 void VerifyLevelDump(Backtrace* backtrace) {
123   ASSERT_GT(backtrace->NumFrames(), static_cast<size_t>(0));
124   ASSERT_LT(backtrace->NumFrames(), static_cast<size_t>(MAX_BACKTRACE_FRAMES));
125 
126   // Look through the frames starting at the highest to find the
127   // frame we want.
128   size_t frame_num = 0;
129   for (size_t i = backtrace->NumFrames()-1; i > 2; i--) {
130     if (backtrace->GetFrame(i)->func_name == "test_level_one") {
131       frame_num = i;
132       break;
133     }
134   }
135   ASSERT_LT(static_cast<size_t>(0), frame_num);
136   ASSERT_LE(static_cast<size_t>(3), frame_num);
137 
138   ASSERT_EQ(backtrace->GetFrame(frame_num)->func_name, "test_level_one");
139   ASSERT_EQ(backtrace->GetFrame(frame_num-1)->func_name, "test_level_two");
140   ASSERT_EQ(backtrace->GetFrame(frame_num-2)->func_name, "test_level_three");
141   ASSERT_EQ(backtrace->GetFrame(frame_num-3)->func_name, "test_level_four");
142 }
143 
VerifyLevelBacktrace(void *)144 void VerifyLevelBacktrace(void*) {
145   UniquePtr<Backtrace> backtrace(
146       Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
147   ASSERT_TRUE(backtrace.get() != NULL);
148   ASSERT_TRUE(backtrace->Unwind(0));
149 
150   VerifyLevelDump(backtrace.get());
151 }
152 
ReadyMaxBacktrace(Backtrace * backtrace)153 bool ReadyMaxBacktrace(Backtrace* backtrace) {
154   return (backtrace->NumFrames() == MAX_BACKTRACE_FRAMES);
155 }
156 
VerifyMaxDump(Backtrace * backtrace)157 void VerifyMaxDump(Backtrace* backtrace) {
158   ASSERT_EQ(backtrace->NumFrames(), static_cast<size_t>(MAX_BACKTRACE_FRAMES));
159   // Verify that the last frame is our recursive call.
160   ASSERT_EQ(backtrace->GetFrame(MAX_BACKTRACE_FRAMES-1)->func_name,
161             "test_recursive_call");
162 }
163 
VerifyMaxBacktrace(void *)164 void VerifyMaxBacktrace(void*) {
165   UniquePtr<Backtrace> backtrace(
166       Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
167   ASSERT_TRUE(backtrace.get() != NULL);
168   ASSERT_TRUE(backtrace->Unwind(0));
169 
170   VerifyMaxDump(backtrace.get());
171 }
172 
ThreadSetState(void * data)173 void ThreadSetState(void* data) {
174   thread_t* thread = reinterpret_cast<thread_t*>(data);
175   android_atomic_acquire_store(1, &thread->state);
176   volatile int i = 0;
177   while (thread->state) {
178     i++;
179   }
180 }
181 
VerifyThreadTest(pid_t tid,void (* VerifyFunc)(Backtrace *))182 void VerifyThreadTest(pid_t tid, void (*VerifyFunc)(Backtrace*)) {
183   UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), tid));
184   ASSERT_TRUE(backtrace.get() != NULL);
185   ASSERT_TRUE(backtrace->Unwind(0));
186 
187   VerifyFunc(backtrace.get());
188 }
189 
WaitForNonZero(int32_t * value,uint64_t seconds)190 bool WaitForNonZero(int32_t* value, uint64_t seconds) {
191   uint64_t start = NanoTime();
192   do {
193     if (android_atomic_acquire_load(value)) {
194       return true;
195     }
196   } while ((NanoTime() - start) < seconds * NS_PER_SEC);
197   return false;
198 }
199 
TEST(libbacktrace,local_trace)200 TEST(libbacktrace, local_trace) {
201   ASSERT_NE(test_level_one(1, 2, 3, 4, VerifyLevelBacktrace, NULL), 0);
202 }
203 
VerifyIgnoreFrames(Backtrace * bt_all,Backtrace * bt_ign1,Backtrace * bt_ign2,const char * cur_proc)204 void VerifyIgnoreFrames(
205     Backtrace* bt_all, Backtrace* bt_ign1,
206     Backtrace* bt_ign2, const char* cur_proc) {
207   EXPECT_EQ(bt_all->NumFrames(), bt_ign1->NumFrames() + 1);
208   EXPECT_EQ(bt_all->NumFrames(), bt_ign2->NumFrames() + 2);
209 
210   // Check all of the frames are the same > the current frame.
211   bool check = (cur_proc == NULL);
212   for (size_t i = 0; i < bt_ign2->NumFrames(); i++) {
213     if (check) {
214       EXPECT_EQ(bt_ign2->GetFrame(i)->pc, bt_ign1->GetFrame(i+1)->pc);
215       EXPECT_EQ(bt_ign2->GetFrame(i)->sp, bt_ign1->GetFrame(i+1)->sp);
216       EXPECT_EQ(bt_ign2->GetFrame(i)->stack_size, bt_ign1->GetFrame(i+1)->stack_size);
217 
218       EXPECT_EQ(bt_ign2->GetFrame(i)->pc, bt_all->GetFrame(i+2)->pc);
219       EXPECT_EQ(bt_ign2->GetFrame(i)->sp, bt_all->GetFrame(i+2)->sp);
220       EXPECT_EQ(bt_ign2->GetFrame(i)->stack_size, bt_all->GetFrame(i+2)->stack_size);
221     }
222     if (!check && bt_ign2->GetFrame(i)->func_name == cur_proc) {
223       check = true;
224     }
225   }
226 }
227 
VerifyLevelIgnoreFrames(void *)228 void VerifyLevelIgnoreFrames(void*) {
229   UniquePtr<Backtrace> all(
230       Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
231   ASSERT_TRUE(all.get() != NULL);
232   ASSERT_TRUE(all->Unwind(0));
233 
234   UniquePtr<Backtrace> ign1(
235       Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
236   ASSERT_TRUE(ign1.get() != NULL);
237   ASSERT_TRUE(ign1->Unwind(1));
238 
239   UniquePtr<Backtrace> ign2(
240       Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
241   ASSERT_TRUE(ign2.get() != NULL);
242   ASSERT_TRUE(ign2->Unwind(2));
243 
244   VerifyIgnoreFrames(all.get(), ign1.get(), ign2.get(), "VerifyLevelIgnoreFrames");
245 }
246 
TEST(libbacktrace,local_trace_ignore_frames)247 TEST(libbacktrace, local_trace_ignore_frames) {
248   ASSERT_NE(test_level_one(1, 2, 3, 4, VerifyLevelIgnoreFrames, NULL), 0);
249 }
250 
TEST(libbacktrace,local_max_trace)251 TEST(libbacktrace, local_max_trace) {
252   ASSERT_NE(test_recursive_call(MAX_BACKTRACE_FRAMES+10, VerifyMaxBacktrace, NULL), 0);
253 }
254 
VerifyProcTest(pid_t pid,pid_t tid,bool share_map,bool (* ReadyFunc)(Backtrace *),void (* VerifyFunc)(Backtrace *))255 void VerifyProcTest(pid_t pid, pid_t tid, bool share_map,
256                     bool (*ReadyFunc)(Backtrace*),
257                     void (*VerifyFunc)(Backtrace*)) {
258   pid_t ptrace_tid;
259   if (tid < 0) {
260     ptrace_tid = pid;
261   } else {
262     ptrace_tid = tid;
263   }
264   uint64_t start = NanoTime();
265   bool verified = false;
266   do {
267     usleep(US_PER_MSEC);
268     if (ptrace(PTRACE_ATTACH, ptrace_tid, 0, 0) == 0) {
269       // Wait for the process to get to a stopping point.
270       WaitForStop(ptrace_tid);
271 
272       UniquePtr<BacktraceMap> map;
273       if (share_map) {
274         map.reset(BacktraceMap::Create(pid));
275       }
276       UniquePtr<Backtrace> backtrace(Backtrace::Create(pid, tid, map.get()));
277       ASSERT_TRUE(backtrace->Unwind(0));
278       ASSERT_TRUE(backtrace.get() != NULL);
279       if (ReadyFunc(backtrace.get())) {
280         VerifyFunc(backtrace.get());
281         verified = true;
282       }
283 
284       ASSERT_TRUE(ptrace(PTRACE_DETACH, ptrace_tid, 0, 0) == 0);
285     }
286     // If 5 seconds have passed, then we are done.
287   } while (!verified && (NanoTime() - start) <= 5 * NS_PER_SEC);
288   ASSERT_TRUE(verified);
289 }
290 
TEST(libbacktrace,ptrace_trace)291 TEST(libbacktrace, ptrace_trace) {
292   pid_t pid;
293   if ((pid = fork()) == 0) {
294     ASSERT_NE(test_level_one(1, 2, 3, 4, NULL, NULL), 0);
295     _exit(1);
296   }
297   VerifyProcTest(pid, BACKTRACE_CURRENT_THREAD, false, ReadyLevelBacktrace, VerifyLevelDump);
298 
299   kill(pid, SIGKILL);
300   int status;
301   ASSERT_EQ(waitpid(pid, &status, 0), pid);
302 }
303 
TEST(libbacktrace,ptrace_trace_shared_map)304 TEST(libbacktrace, ptrace_trace_shared_map) {
305   pid_t pid;
306   if ((pid = fork()) == 0) {
307     ASSERT_NE(test_level_one(1, 2, 3, 4, NULL, NULL), 0);
308     _exit(1);
309   }
310 
311   VerifyProcTest(pid, BACKTRACE_CURRENT_THREAD, true, ReadyLevelBacktrace, VerifyLevelDump);
312 
313   kill(pid, SIGKILL);
314   int status;
315   ASSERT_EQ(waitpid(pid, &status, 0), pid);
316 }
317 
TEST(libbacktrace,ptrace_max_trace)318 TEST(libbacktrace, ptrace_max_trace) {
319   pid_t pid;
320   if ((pid = fork()) == 0) {
321     ASSERT_NE(test_recursive_call(MAX_BACKTRACE_FRAMES+10, NULL, NULL), 0);
322     _exit(1);
323   }
324   VerifyProcTest(pid, BACKTRACE_CURRENT_THREAD, false, ReadyMaxBacktrace, VerifyMaxDump);
325 
326   kill(pid, SIGKILL);
327   int status;
328   ASSERT_EQ(waitpid(pid, &status, 0), pid);
329 }
330 
VerifyProcessIgnoreFrames(Backtrace * bt_all)331 void VerifyProcessIgnoreFrames(Backtrace* bt_all) {
332   UniquePtr<Backtrace> ign1(Backtrace::Create(bt_all->Pid(), BACKTRACE_CURRENT_THREAD));
333   ASSERT_TRUE(ign1.get() != NULL);
334   ASSERT_TRUE(ign1->Unwind(1));
335 
336   UniquePtr<Backtrace> ign2(Backtrace::Create(bt_all->Pid(), BACKTRACE_CURRENT_THREAD));
337   ASSERT_TRUE(ign2.get() != NULL);
338   ASSERT_TRUE(ign2->Unwind(2));
339 
340   VerifyIgnoreFrames(bt_all, ign1.get(), ign2.get(), NULL);
341 }
342 
TEST(libbacktrace,ptrace_ignore_frames)343 TEST(libbacktrace, ptrace_ignore_frames) {
344   pid_t pid;
345   if ((pid = fork()) == 0) {
346     ASSERT_NE(test_level_one(1, 2, 3, 4, NULL, NULL), 0);
347     _exit(1);
348   }
349   VerifyProcTest(pid, BACKTRACE_CURRENT_THREAD, false, ReadyLevelBacktrace, VerifyProcessIgnoreFrames);
350 
351   kill(pid, SIGKILL);
352   int status;
353   ASSERT_EQ(waitpid(pid, &status, 0), pid);
354 }
355 
356 // Create a process with multiple threads and dump all of the threads.
PtraceThreadLevelRun(void *)357 void* PtraceThreadLevelRun(void*) {
358   EXPECT_NE(test_level_one(1, 2, 3, 4, NULL, NULL), 0);
359   return NULL;
360 }
361 
GetThreads(pid_t pid,std::vector<pid_t> * threads)362 void GetThreads(pid_t pid, std::vector<pid_t>* threads) {
363   // Get the list of tasks.
364   char task_path[128];
365   snprintf(task_path, sizeof(task_path), "/proc/%d/task", pid);
366 
367   DIR* tasks_dir = opendir(task_path);
368   ASSERT_TRUE(tasks_dir != NULL);
369   struct dirent* entry;
370   while ((entry = readdir(tasks_dir)) != NULL) {
371     char* end;
372     pid_t tid = strtoul(entry->d_name, &end, 10);
373     if (*end == '\0') {
374       threads->push_back(tid);
375     }
376   }
377   closedir(tasks_dir);
378 }
379 
TEST(libbacktrace,ptrace_threads)380 TEST(libbacktrace, ptrace_threads) {
381   pid_t pid;
382   if ((pid = fork()) == 0) {
383     for (size_t i = 0; i < NUM_PTRACE_THREADS; i++) {
384       pthread_attr_t attr;
385       pthread_attr_init(&attr);
386       pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
387 
388       pthread_t thread;
389       ASSERT_TRUE(pthread_create(&thread, &attr, PtraceThreadLevelRun, NULL) == 0);
390     }
391     ASSERT_NE(test_level_one(1, 2, 3, 4, NULL, NULL), 0);
392     _exit(1);
393   }
394 
395   // Check to see that all of the threads are running before unwinding.
396   std::vector<pid_t> threads;
397   uint64_t start = NanoTime();
398   do {
399     usleep(US_PER_MSEC);
400     threads.clear();
401     GetThreads(pid, &threads);
402   } while ((threads.size() != NUM_PTRACE_THREADS + 1) &&
403       ((NanoTime() - start) <= 5 * NS_PER_SEC));
404   ASSERT_EQ(threads.size(), static_cast<size_t>(NUM_PTRACE_THREADS + 1));
405 
406   ASSERT_TRUE(ptrace(PTRACE_ATTACH, pid, 0, 0) == 0);
407   WaitForStop(pid);
408   for (std::vector<int>::const_iterator it = threads.begin(); it != threads.end(); ++it) {
409     // Skip the current forked process, we only care about the threads.
410     if (pid == *it) {
411       continue;
412     }
413     VerifyProcTest(pid, *it, false, ReadyLevelBacktrace, VerifyLevelDump);
414   }
415   ASSERT_TRUE(ptrace(PTRACE_DETACH, pid, 0, 0) == 0);
416 
417   kill(pid, SIGKILL);
418   int status;
419   ASSERT_EQ(waitpid(pid, &status, 0), pid);
420 }
421 
VerifyLevelThread(void *)422 void VerifyLevelThread(void*) {
423   UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), gettid()));
424   ASSERT_TRUE(backtrace.get() != NULL);
425   ASSERT_TRUE(backtrace->Unwind(0));
426 
427   VerifyLevelDump(backtrace.get());
428 }
429 
TEST(libbacktrace,thread_current_level)430 TEST(libbacktrace, thread_current_level) {
431   ASSERT_NE(test_level_one(1, 2, 3, 4, VerifyLevelThread, NULL), 0);
432 }
433 
VerifyMaxThread(void *)434 void VerifyMaxThread(void*) {
435   UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), gettid()));
436   ASSERT_TRUE(backtrace.get() != NULL);
437   ASSERT_TRUE(backtrace->Unwind(0));
438 
439   VerifyMaxDump(backtrace.get());
440 }
441 
TEST(libbacktrace,thread_current_max)442 TEST(libbacktrace, thread_current_max) {
443   ASSERT_NE(test_recursive_call(MAX_BACKTRACE_FRAMES+10, VerifyMaxThread, NULL), 0);
444 }
445 
ThreadLevelRun(void * data)446 void* ThreadLevelRun(void* data) {
447   thread_t* thread = reinterpret_cast<thread_t*>(data);
448 
449   thread->tid = gettid();
450   EXPECT_NE(test_level_one(1, 2, 3, 4, ThreadSetState, data), 0);
451   return NULL;
452 }
453 
TEST(libbacktrace,thread_level_trace)454 TEST(libbacktrace, thread_level_trace) {
455   pthread_attr_t attr;
456   pthread_attr_init(&attr);
457   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
458 
459   thread_t thread_data = { 0, 0, 0 };
460   pthread_t thread;
461   ASSERT_TRUE(pthread_create(&thread, &attr, ThreadLevelRun, &thread_data) == 0);
462 
463   // Wait up to 2 seconds for the tid to be set.
464   ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2));
465 
466   // Make sure that the thread signal used is not visible when compiled for
467   // the target.
468 #if !defined(__GLIBC__)
469   ASSERT_LT(THREAD_SIGNAL, SIGRTMIN);
470 #endif
471 
472   // Save the current signal action and make sure it is restored afterwards.
473   struct sigaction cur_action;
474   ASSERT_TRUE(sigaction(THREAD_SIGNAL, NULL, &cur_action) == 0);
475 
476   UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), thread_data.tid));
477   ASSERT_TRUE(backtrace.get() != NULL);
478   ASSERT_TRUE(backtrace->Unwind(0));
479 
480   VerifyLevelDump(backtrace.get());
481 
482   // Tell the thread to exit its infinite loop.
483   android_atomic_acquire_store(0, &thread_data.state);
484 
485   // Verify that the old action was restored.
486   struct sigaction new_action;
487   ASSERT_TRUE(sigaction(THREAD_SIGNAL, NULL, &new_action) == 0);
488   EXPECT_EQ(cur_action.sa_sigaction, new_action.sa_sigaction);
489   // The SA_RESTORER flag gets set behind our back, so a direct comparison
490   // doesn't work unless we mask the value off. Mips doesn't have this
491   // flag, so skip this on that platform.
492 #ifdef SA_RESTORER
493   cur_action.sa_flags &= ~SA_RESTORER;
494   new_action.sa_flags &= ~SA_RESTORER;
495 #endif
496   EXPECT_EQ(cur_action.sa_flags, new_action.sa_flags);
497 }
498 
TEST(libbacktrace,thread_ignore_frames)499 TEST(libbacktrace, thread_ignore_frames) {
500   pthread_attr_t attr;
501   pthread_attr_init(&attr);
502   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
503 
504   thread_t thread_data = { 0, 0, 0 };
505   pthread_t thread;
506   ASSERT_TRUE(pthread_create(&thread, &attr, ThreadLevelRun, &thread_data) == 0);
507 
508   // Wait up to 2 seconds for the tid to be set.
509   ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2));
510 
511   UniquePtr<Backtrace> all(Backtrace::Create(getpid(), thread_data.tid));
512   ASSERT_TRUE(all.get() != NULL);
513   ASSERT_TRUE(all->Unwind(0));
514 
515   UniquePtr<Backtrace> ign1(Backtrace::Create(getpid(), thread_data.tid));
516   ASSERT_TRUE(ign1.get() != NULL);
517   ASSERT_TRUE(ign1->Unwind(1));
518 
519   UniquePtr<Backtrace> ign2(Backtrace::Create(getpid(), thread_data.tid));
520   ASSERT_TRUE(ign2.get() != NULL);
521   ASSERT_TRUE(ign2->Unwind(2));
522 
523   VerifyIgnoreFrames(all.get(), ign1.get(), ign2.get(), NULL);
524 
525   // Tell the thread to exit its infinite loop.
526   android_atomic_acquire_store(0, &thread_data.state);
527 }
528 
ThreadMaxRun(void * data)529 void* ThreadMaxRun(void* data) {
530   thread_t* thread = reinterpret_cast<thread_t*>(data);
531 
532   thread->tid = gettid();
533   EXPECT_NE(test_recursive_call(MAX_BACKTRACE_FRAMES+10, ThreadSetState, data), 0);
534   return NULL;
535 }
536 
TEST(libbacktrace,thread_max_trace)537 TEST(libbacktrace, thread_max_trace) {
538   pthread_attr_t attr;
539   pthread_attr_init(&attr);
540   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
541 
542   thread_t thread_data = { 0, 0, 0 };
543   pthread_t thread;
544   ASSERT_TRUE(pthread_create(&thread, &attr, ThreadMaxRun, &thread_data) == 0);
545 
546   // Wait for the tid to be set.
547   ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2));
548 
549   UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), thread_data.tid));
550   ASSERT_TRUE(backtrace.get() != NULL);
551   ASSERT_TRUE(backtrace->Unwind(0));
552 
553   VerifyMaxDump(backtrace.get());
554 
555   // Tell the thread to exit its infinite loop.
556   android_atomic_acquire_store(0, &thread_data.state);
557 }
558 
ThreadDump(void * data)559 void* ThreadDump(void* data) {
560   dump_thread_t* dump = reinterpret_cast<dump_thread_t*>(data);
561   while (true) {
562     if (android_atomic_acquire_load(dump->now)) {
563       break;
564     }
565   }
566 
567   // The status of the actual unwind will be checked elsewhere.
568   dump->backtrace = Backtrace::Create(getpid(), dump->thread.tid);
569   dump->backtrace->Unwind(0);
570 
571   android_atomic_acquire_store(1, &dump->done);
572 
573   return NULL;
574 }
575 
TEST(libbacktrace,thread_multiple_dump)576 TEST(libbacktrace, thread_multiple_dump) {
577   // Dump NUM_THREADS simultaneously.
578   std::vector<thread_t> runners(NUM_THREADS);
579   std::vector<dump_thread_t> dumpers(NUM_THREADS);
580 
581   pthread_attr_t attr;
582   pthread_attr_init(&attr);
583   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
584   for (size_t i = 0; i < NUM_THREADS; i++) {
585     // Launch the runners, they will spin in hard loops doing nothing.
586     runners[i].tid = 0;
587     runners[i].state = 0;
588     ASSERT_TRUE(pthread_create(&runners[i].threadId, &attr, ThreadMaxRun, &runners[i]) == 0);
589   }
590 
591   // Wait for tids to be set.
592   for (std::vector<thread_t>::iterator it = runners.begin(); it != runners.end(); ++it) {
593     ASSERT_TRUE(WaitForNonZero(&it->state, 30));
594   }
595 
596   // Start all of the dumpers at once, they will spin until they are signalled
597   // to begin their dump run.
598   int32_t dump_now = 0;
599   for (size_t i = 0; i < NUM_THREADS; i++) {
600     dumpers[i].thread.tid = runners[i].tid;
601     dumpers[i].thread.state = 0;
602     dumpers[i].done = 0;
603     dumpers[i].now = &dump_now;
604 
605     ASSERT_TRUE(pthread_create(&dumpers[i].thread.threadId, &attr, ThreadDump, &dumpers[i]) == 0);
606   }
607 
608   // Start all of the dumpers going at once.
609   android_atomic_acquire_store(1, &dump_now);
610 
611   for (size_t i = 0; i < NUM_THREADS; i++) {
612     ASSERT_TRUE(WaitForNonZero(&dumpers[i].done, 30));
613 
614     // Tell the runner thread to exit its infinite loop.
615     android_atomic_acquire_store(0, &runners[i].state);
616 
617     ASSERT_TRUE(dumpers[i].backtrace != NULL);
618     VerifyMaxDump(dumpers[i].backtrace);
619 
620     delete dumpers[i].backtrace;
621     dumpers[i].backtrace = NULL;
622   }
623 }
624 
TEST(libbacktrace,thread_multiple_dump_same_thread)625 TEST(libbacktrace, thread_multiple_dump_same_thread) {
626   pthread_attr_t attr;
627   pthread_attr_init(&attr);
628   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
629   thread_t runner;
630   runner.tid = 0;
631   runner.state = 0;
632   ASSERT_TRUE(pthread_create(&runner.threadId, &attr, ThreadMaxRun, &runner) == 0);
633 
634   // Wait for tids to be set.
635   ASSERT_TRUE(WaitForNonZero(&runner.state, 30));
636 
637   // Start all of the dumpers at once, they will spin until they are signalled
638   // to begin their dump run.
639   int32_t dump_now = 0;
640   // Dump the same thread NUM_THREADS simultaneously.
641   std::vector<dump_thread_t> dumpers(NUM_THREADS);
642   for (size_t i = 0; i < NUM_THREADS; i++) {
643     dumpers[i].thread.tid = runner.tid;
644     dumpers[i].thread.state = 0;
645     dumpers[i].done = 0;
646     dumpers[i].now = &dump_now;
647 
648     ASSERT_TRUE(pthread_create(&dumpers[i].thread.threadId, &attr, ThreadDump, &dumpers[i]) == 0);
649   }
650 
651   // Start all of the dumpers going at once.
652   android_atomic_acquire_store(1, &dump_now);
653 
654   for (size_t i = 0; i < NUM_THREADS; i++) {
655     ASSERT_TRUE(WaitForNonZero(&dumpers[i].done, 30));
656 
657     ASSERT_TRUE(dumpers[i].backtrace != NULL);
658     VerifyMaxDump(dumpers[i].backtrace);
659 
660     delete dumpers[i].backtrace;
661     dumpers[i].backtrace = NULL;
662   }
663 
664   // Tell the runner thread to exit its infinite loop.
665   android_atomic_acquire_store(0, &runner.state);
666 }
667 
668 // This test is for UnwindMaps that should share the same map cursor when
669 // multiple maps are created for the current process at the same time.
TEST(libbacktrace,simultaneous_maps)670 TEST(libbacktrace, simultaneous_maps) {
671   BacktraceMap* map1 = BacktraceMap::Create(getpid());
672   BacktraceMap* map2 = BacktraceMap::Create(getpid());
673   BacktraceMap* map3 = BacktraceMap::Create(getpid());
674 
675   Backtrace* back1 = Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD, map1);
676   EXPECT_TRUE(back1->Unwind(0));
677   delete back1;
678   delete map1;
679 
680   Backtrace* back2 = Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD, map2);
681   EXPECT_TRUE(back2->Unwind(0));
682   delete back2;
683   delete map2;
684 
685   Backtrace* back3 = Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD, map3);
686   EXPECT_TRUE(back3->Unwind(0));
687   delete back3;
688   delete map3;
689 }
690 
TEST(libbacktrace,format_test)691 TEST(libbacktrace, format_test) {
692   UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD));
693   ASSERT_TRUE(backtrace.get() != NULL);
694 
695   backtrace_frame_data_t frame;
696   frame.num = 1;
697   frame.pc = 2;
698   frame.sp = 0;
699   frame.stack_size = 0;
700   frame.map = NULL;
701   frame.func_offset = 0;
702 
703   backtrace_map_t map;
704   map.start = 0;
705   map.end = 0;
706 
707   // Check no map set.
708   frame.num = 1;
709 #if defined(__LP64__)
710   EXPECT_EQ("#01 pc 0000000000000002  <unknown>",
711 #else
712   EXPECT_EQ("#01 pc 00000002  <unknown>",
713 #endif
714             backtrace->FormatFrameData(&frame));
715 
716   // Check map name empty, but exists.
717   frame.map = &map;
718   map.start = 1;
719 #if defined(__LP64__)
720   EXPECT_EQ("#01 pc 0000000000000001  <unknown>",
721 #else
722   EXPECT_EQ("#01 pc 00000001  <unknown>",
723 #endif
724             backtrace->FormatFrameData(&frame));
725 
726 
727   // Check relative pc is set and map name is set.
728   frame.pc = 0x12345679;
729   frame.map = &map;
730   map.name = "MapFake";
731   map.start =  1;
732 #if defined(__LP64__)
733   EXPECT_EQ("#01 pc 0000000012345678  MapFake",
734 #else
735   EXPECT_EQ("#01 pc 12345678  MapFake",
736 #endif
737             backtrace->FormatFrameData(&frame));
738 
739   // Check func_name is set, but no func offset.
740   frame.func_name = "ProcFake";
741 #if defined(__LP64__)
742   EXPECT_EQ("#01 pc 0000000012345678  MapFake (ProcFake)",
743 #else
744   EXPECT_EQ("#01 pc 12345678  MapFake (ProcFake)",
745 #endif
746             backtrace->FormatFrameData(&frame));
747 
748   // Check func_name is set, and func offset is non-zero.
749   frame.func_offset = 645;
750 #if defined(__LP64__)
751   EXPECT_EQ("#01 pc 0000000012345678  MapFake (ProcFake+645)",
752 #else
753   EXPECT_EQ("#01 pc 12345678  MapFake (ProcFake+645)",
754 #endif
755             backtrace->FormatFrameData(&frame));
756 }
757 
758 struct map_test_t {
759   uintptr_t start;
760   uintptr_t end;
761 };
762 
map_sort(map_test_t i,map_test_t j)763 bool map_sort(map_test_t i, map_test_t j) {
764   return i.start < j.start;
765 }
766 
VerifyMap(pid_t pid)767 static void VerifyMap(pid_t pid) {
768   char buffer[4096];
769   snprintf(buffer, sizeof(buffer), "/proc/%d/maps", pid);
770 
771   FILE* map_file = fopen(buffer, "r");
772   ASSERT_TRUE(map_file != NULL);
773   std::vector<map_test_t> test_maps;
774   while (fgets(buffer, sizeof(buffer), map_file)) {
775     map_test_t map;
776     ASSERT_EQ(2, sscanf(buffer, "%" SCNxPTR "-%" SCNxPTR " ", &map.start, &map.end));
777     test_maps.push_back(map);
778   }
779   fclose(map_file);
780   std::sort(test_maps.begin(), test_maps.end(), map_sort);
781 
782   UniquePtr<BacktraceMap> map(BacktraceMap::Create(pid));
783 
784   // Basic test that verifies that the map is in the expected order.
785   std::vector<map_test_t>::const_iterator test_it = test_maps.begin();
786   for (BacktraceMap::const_iterator it = map->begin(); it != map->end(); ++it) {
787     ASSERT_TRUE(test_it != test_maps.end());
788     ASSERT_EQ(test_it->start, it->start);
789     ASSERT_EQ(test_it->end, it->end);
790     ++test_it;
791   }
792   ASSERT_TRUE(test_it == test_maps.end());
793 }
794 
TEST(libbacktrace,verify_map_remote)795 TEST(libbacktrace, verify_map_remote) {
796   pid_t pid;
797 
798   if ((pid = fork()) == 0) {
799     while (true) {
800     }
801     _exit(0);
802   }
803   ASSERT_LT(0, pid);
804 
805   ASSERT_TRUE(ptrace(PTRACE_ATTACH, pid, 0, 0) == 0);
806 
807   // Wait for the process to get to a stopping point.
808   WaitForStop(pid);
809 
810   // The maps should match exactly since the forked process has been paused.
811   VerifyMap(pid);
812 
813   ASSERT_TRUE(ptrace(PTRACE_DETACH, pid, 0, 0) == 0);
814 
815   kill(pid, SIGKILL);
816   ASSERT_EQ(waitpid(pid, NULL, 0), pid);
817 }
818 
819 #if defined(ENABLE_PSS_TESTS)
820 #include "GetPss.h"
821 
822 #define MAX_LEAK_BYTES 32*1024UL
823 
CheckForLeak(pid_t pid,pid_t tid)824 static void CheckForLeak(pid_t pid, pid_t tid) {
825   // Do a few runs to get the PSS stable.
826   for (size_t i = 0; i < 100; i++) {
827     Backtrace* backtrace = Backtrace::Create(pid, tid);
828     ASSERT_TRUE(backtrace != NULL);
829     ASSERT_TRUE(backtrace->Unwind(0));
830     delete backtrace;
831   }
832   size_t stable_pss = GetPssBytes();
833 
834   // Loop enough that even a small leak should be detectable.
835   for (size_t i = 0; i < 4096; i++) {
836     Backtrace* backtrace = Backtrace::Create(pid, tid);
837     ASSERT_TRUE(backtrace != NULL);
838     ASSERT_TRUE(backtrace->Unwind(0));
839     delete backtrace;
840   }
841   size_t new_pss = GetPssBytes();
842   size_t abs_diff = (new_pss > stable_pss) ? new_pss - stable_pss : stable_pss - new_pss;
843   // As long as the new pss is within a certain amount, consider everything okay.
844   ASSERT_LE(abs_diff, MAX_LEAK_BYTES);
845 }
846 
TEST(libbacktrace,check_for_leak_local)847 TEST(libbacktrace, check_for_leak_local) {
848   CheckForLeak(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD);
849 }
850 
TEST(libbacktrace,check_for_leak_local_thread)851 TEST(libbacktrace, check_for_leak_local_thread) {
852   thread_t thread_data = { 0, 0, 0 };
853   pthread_t thread;
854   ASSERT_TRUE(pthread_create(&thread, NULL, ThreadLevelRun, &thread_data) == 0);
855 
856   // Wait up to 2 seconds for the tid to be set.
857   ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2));
858 
859   CheckForLeak(BACKTRACE_CURRENT_PROCESS, thread_data.tid);
860 
861   // Tell the thread to exit its infinite loop.
862   android_atomic_acquire_store(0, &thread_data.state);
863 
864   ASSERT_TRUE(pthread_join(thread, NULL) == 0);
865 }
866 
TEST(libbacktrace,check_for_leak_remote)867 TEST(libbacktrace, check_for_leak_remote) {
868   pid_t pid;
869 
870   if ((pid = fork()) == 0) {
871     while (true) {
872     }
873     _exit(0);
874   }
875   ASSERT_LT(0, pid);
876 
877   ASSERT_TRUE(ptrace(PTRACE_ATTACH, pid, 0, 0) == 0);
878 
879   // Wait for the process to get to a stopping point.
880   WaitForStop(pid);
881 
882   CheckForLeak(pid, BACKTRACE_CURRENT_THREAD);
883 
884   ASSERT_TRUE(ptrace(PTRACE_DETACH, pid, 0, 0) == 0);
885 
886   kill(pid, SIGKILL);
887   ASSERT_EQ(waitpid(pid, NULL, 0), pid);
888 }
889 #endif
890