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 20
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 EXPECT_EQ(cur_action.sa_flags, new_action.sa_flags);
490 }
491
TEST(libbacktrace,thread_ignore_frames)492 TEST(libbacktrace, thread_ignore_frames) {
493 pthread_attr_t attr;
494 pthread_attr_init(&attr);
495 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
496
497 thread_t thread_data = { 0, 0, 0 };
498 pthread_t thread;
499 ASSERT_TRUE(pthread_create(&thread, &attr, ThreadLevelRun, &thread_data) == 0);
500
501 // Wait up to 2 seconds for the tid to be set.
502 ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2));
503
504 UniquePtr<Backtrace> all(Backtrace::Create(getpid(), thread_data.tid));
505 ASSERT_TRUE(all.get() != NULL);
506 ASSERT_TRUE(all->Unwind(0));
507
508 UniquePtr<Backtrace> ign1(Backtrace::Create(getpid(), thread_data.tid));
509 ASSERT_TRUE(ign1.get() != NULL);
510 ASSERT_TRUE(ign1->Unwind(1));
511
512 UniquePtr<Backtrace> ign2(Backtrace::Create(getpid(), thread_data.tid));
513 ASSERT_TRUE(ign2.get() != NULL);
514 ASSERT_TRUE(ign2->Unwind(2));
515
516 VerifyIgnoreFrames(all.get(), ign1.get(), ign2.get(), NULL);
517
518 // Tell the thread to exit its infinite loop.
519 android_atomic_acquire_store(0, &thread_data.state);
520 }
521
ThreadMaxRun(void * data)522 void* ThreadMaxRun(void* data) {
523 thread_t* thread = reinterpret_cast<thread_t*>(data);
524
525 thread->tid = gettid();
526 EXPECT_NE(test_recursive_call(MAX_BACKTRACE_FRAMES+10, ThreadSetState, data), 0);
527 return NULL;
528 }
529
TEST(libbacktrace,thread_max_trace)530 TEST(libbacktrace, thread_max_trace) {
531 pthread_attr_t attr;
532 pthread_attr_init(&attr);
533 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
534
535 thread_t thread_data = { 0, 0, 0 };
536 pthread_t thread;
537 ASSERT_TRUE(pthread_create(&thread, &attr, ThreadMaxRun, &thread_data) == 0);
538
539 // Wait for the tid to be set.
540 ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2));
541
542 UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), thread_data.tid));
543 ASSERT_TRUE(backtrace.get() != NULL);
544 ASSERT_TRUE(backtrace->Unwind(0));
545
546 VerifyMaxDump(backtrace.get());
547
548 // Tell the thread to exit its infinite loop.
549 android_atomic_acquire_store(0, &thread_data.state);
550 }
551
ThreadDump(void * data)552 void* ThreadDump(void* data) {
553 dump_thread_t* dump = reinterpret_cast<dump_thread_t*>(data);
554 while (true) {
555 if (android_atomic_acquire_load(dump->now)) {
556 break;
557 }
558 }
559
560 // The status of the actual unwind will be checked elsewhere.
561 dump->backtrace = Backtrace::Create(getpid(), dump->thread.tid);
562 dump->backtrace->Unwind(0);
563
564 android_atomic_acquire_store(1, &dump->done);
565
566 return NULL;
567 }
568
TEST(libbacktrace,thread_multiple_dump)569 TEST(libbacktrace, thread_multiple_dump) {
570 // Dump NUM_THREADS simultaneously.
571 std::vector<thread_t> runners(NUM_THREADS);
572 std::vector<dump_thread_t> dumpers(NUM_THREADS);
573
574 pthread_attr_t attr;
575 pthread_attr_init(&attr);
576 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
577 for (size_t i = 0; i < NUM_THREADS; i++) {
578 // Launch the runners, they will spin in hard loops doing nothing.
579 runners[i].tid = 0;
580 runners[i].state = 0;
581 ASSERT_TRUE(pthread_create(&runners[i].threadId, &attr, ThreadMaxRun, &runners[i]) == 0);
582 }
583
584 // Wait for tids to be set.
585 for (std::vector<thread_t>::iterator it = runners.begin(); it != runners.end(); ++it) {
586 ASSERT_TRUE(WaitForNonZero(&it->state, 10));
587 }
588
589 // Start all of the dumpers at once, they will spin until they are signalled
590 // to begin their dump run.
591 int32_t dump_now = 0;
592 for (size_t i = 0; i < NUM_THREADS; i++) {
593 dumpers[i].thread.tid = runners[i].tid;
594 dumpers[i].thread.state = 0;
595 dumpers[i].done = 0;
596 dumpers[i].now = &dump_now;
597
598 ASSERT_TRUE(pthread_create(&dumpers[i].thread.threadId, &attr, ThreadDump, &dumpers[i]) == 0);
599 }
600
601 // Start all of the dumpers going at once.
602 android_atomic_acquire_store(1, &dump_now);
603
604 for (size_t i = 0; i < NUM_THREADS; i++) {
605 ASSERT_TRUE(WaitForNonZero(&dumpers[i].done, 10));
606
607 // Tell the runner thread to exit its infinite loop.
608 android_atomic_acquire_store(0, &runners[i].state);
609
610 ASSERT_TRUE(dumpers[i].backtrace != NULL);
611 VerifyMaxDump(dumpers[i].backtrace);
612
613 delete dumpers[i].backtrace;
614 dumpers[i].backtrace = NULL;
615 }
616 }
617
TEST(libbacktrace,thread_multiple_dump_same_thread)618 TEST(libbacktrace, thread_multiple_dump_same_thread) {
619 pthread_attr_t attr;
620 pthread_attr_init(&attr);
621 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
622 thread_t runner;
623 runner.tid = 0;
624 runner.state = 0;
625 ASSERT_TRUE(pthread_create(&runner.threadId, &attr, ThreadMaxRun, &runner) == 0);
626
627 // Wait for tids to be set.
628 ASSERT_TRUE(WaitForNonZero(&runner.state, 10));
629
630 // Start all of the dumpers at once, they will spin until they are signalled
631 // to begin their dump run.
632 int32_t dump_now = 0;
633 // Dump the same thread NUM_THREADS simultaneously.
634 std::vector<dump_thread_t> dumpers(NUM_THREADS);
635 for (size_t i = 0; i < NUM_THREADS; i++) {
636 dumpers[i].thread.tid = runner.tid;
637 dumpers[i].thread.state = 0;
638 dumpers[i].done = 0;
639 dumpers[i].now = &dump_now;
640
641 ASSERT_TRUE(pthread_create(&dumpers[i].thread.threadId, &attr, ThreadDump, &dumpers[i]) == 0);
642 }
643
644 // Start all of the dumpers going at once.
645 android_atomic_acquire_store(1, &dump_now);
646
647 for (size_t i = 0; i < NUM_THREADS; i++) {
648 ASSERT_TRUE(WaitForNonZero(&dumpers[i].done, 100));
649
650 ASSERT_TRUE(dumpers[i].backtrace != NULL);
651 VerifyMaxDump(dumpers[i].backtrace);
652
653 delete dumpers[i].backtrace;
654 dumpers[i].backtrace = NULL;
655 }
656
657 // Tell the runner thread to exit its infinite loop.
658 android_atomic_acquire_store(0, &runner.state);
659 }
660
661 // This test is for UnwindMaps that should share the same map cursor when
662 // multiple maps are created for the current process at the same time.
TEST(libbacktrace,simultaneous_maps)663 TEST(libbacktrace, simultaneous_maps) {
664 BacktraceMap* map1 = BacktraceMap::Create(getpid());
665 BacktraceMap* map2 = BacktraceMap::Create(getpid());
666 BacktraceMap* map3 = BacktraceMap::Create(getpid());
667
668 Backtrace* back1 = Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD, map1);
669 EXPECT_TRUE(back1->Unwind(0));
670 delete back1;
671 delete map1;
672
673 Backtrace* back2 = Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD, map2);
674 EXPECT_TRUE(back2->Unwind(0));
675 delete back2;
676 delete map2;
677
678 Backtrace* back3 = Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD, map3);
679 EXPECT_TRUE(back3->Unwind(0));
680 delete back3;
681 delete map3;
682 }
683
TEST(libbacktrace,format_test)684 TEST(libbacktrace, format_test) {
685 UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD));
686 ASSERT_TRUE(backtrace.get() != NULL);
687
688 backtrace_frame_data_t frame;
689 frame.num = 1;
690 frame.pc = 2;
691 frame.sp = 0;
692 frame.stack_size = 0;
693 frame.map = NULL;
694 frame.func_offset = 0;
695
696 backtrace_map_t map;
697 map.start = 0;
698 map.end = 0;
699
700 // Check no map set.
701 frame.num = 1;
702 #if defined(__LP64__)
703 EXPECT_EQ("#01 pc 0000000000000002 <unknown>",
704 #else
705 EXPECT_EQ("#01 pc 00000002 <unknown>",
706 #endif
707 backtrace->FormatFrameData(&frame));
708
709 // Check map name empty, but exists.
710 frame.map = ↦
711 map.start = 1;
712 #if defined(__LP64__)
713 EXPECT_EQ("#01 pc 0000000000000001 <unknown>",
714 #else
715 EXPECT_EQ("#01 pc 00000001 <unknown>",
716 #endif
717 backtrace->FormatFrameData(&frame));
718
719
720 // Check relative pc is set and map name is set.
721 frame.pc = 0x12345679;
722 frame.map = ↦
723 map.name = "MapFake";
724 map.start = 1;
725 #if defined(__LP64__)
726 EXPECT_EQ("#01 pc 0000000012345678 MapFake",
727 #else
728 EXPECT_EQ("#01 pc 12345678 MapFake",
729 #endif
730 backtrace->FormatFrameData(&frame));
731
732 // Check func_name is set, but no func offset.
733 frame.func_name = "ProcFake";
734 #if defined(__LP64__)
735 EXPECT_EQ("#01 pc 0000000012345678 MapFake (ProcFake)",
736 #else
737 EXPECT_EQ("#01 pc 12345678 MapFake (ProcFake)",
738 #endif
739 backtrace->FormatFrameData(&frame));
740
741 // Check func_name is set, and func offset is non-zero.
742 frame.func_offset = 645;
743 #if defined(__LP64__)
744 EXPECT_EQ("#01 pc 0000000012345678 MapFake (ProcFake+645)",
745 #else
746 EXPECT_EQ("#01 pc 12345678 MapFake (ProcFake+645)",
747 #endif
748 backtrace->FormatFrameData(&frame));
749 }
750
751 struct map_test_t {
752 uintptr_t start;
753 uintptr_t end;
754 };
755
map_sort(map_test_t i,map_test_t j)756 bool map_sort(map_test_t i, map_test_t j) {
757 return i.start < j.start;
758 }
759
VerifyMap(pid_t pid)760 static void VerifyMap(pid_t pid) {
761 char buffer[4096];
762 snprintf(buffer, sizeof(buffer), "/proc/%d/maps", pid);
763
764 FILE* map_file = fopen(buffer, "r");
765 ASSERT_TRUE(map_file != NULL);
766 std::vector<map_test_t> test_maps;
767 while (fgets(buffer, sizeof(buffer), map_file)) {
768 map_test_t map;
769 ASSERT_EQ(2, sscanf(buffer, "%" SCNxPTR "-%" SCNxPTR " ", &map.start, &map.end));
770 test_maps.push_back(map);
771 }
772 fclose(map_file);
773 std::sort(test_maps.begin(), test_maps.end(), map_sort);
774
775 UniquePtr<BacktraceMap> map(BacktraceMap::Create(pid));
776
777 // Basic test that verifies that the map is in the expected order.
778 std::vector<map_test_t>::const_iterator test_it = test_maps.begin();
779 for (BacktraceMap::const_iterator it = map->begin(); it != map->end(); ++it) {
780 ASSERT_TRUE(test_it != test_maps.end());
781 ASSERT_EQ(test_it->start, it->start);
782 ASSERT_EQ(test_it->end, it->end);
783 ++test_it;
784 }
785 ASSERT_TRUE(test_it == test_maps.end());
786 }
787
TEST(libbacktrace,verify_map_remote)788 TEST(libbacktrace, verify_map_remote) {
789 pid_t pid;
790
791 if ((pid = fork()) == 0) {
792 while (true) {
793 }
794 _exit(0);
795 }
796 ASSERT_LT(0, pid);
797
798 ASSERT_TRUE(ptrace(PTRACE_ATTACH, pid, 0, 0) == 0);
799
800 // Wait for the process to get to a stopping point.
801 WaitForStop(pid);
802
803 // The maps should match exactly since the forked process has been paused.
804 VerifyMap(pid);
805
806 ASSERT_TRUE(ptrace(PTRACE_DETACH, pid, 0, 0) == 0);
807
808 kill(pid, SIGKILL);
809 ASSERT_EQ(waitpid(pid, NULL, 0), pid);
810 }
811
812 #if defined(ENABLE_PSS_TESTS)
813 #include "GetPss.h"
814
815 #define MAX_LEAK_BYTES 32*1024UL
816
CheckForLeak(pid_t pid,pid_t tid)817 static void CheckForLeak(pid_t pid, pid_t tid) {
818 // Do a few runs to get the PSS stable.
819 for (size_t i = 0; i < 100; i++) {
820 Backtrace* backtrace = Backtrace::Create(pid, tid);
821 ASSERT_TRUE(backtrace != NULL);
822 ASSERT_TRUE(backtrace->Unwind(0));
823 delete backtrace;
824 }
825 size_t stable_pss = GetPssBytes();
826
827 // Loop enough that even a small leak should be detectable.
828 for (size_t i = 0; i < 4096; i++) {
829 Backtrace* backtrace = Backtrace::Create(pid, tid);
830 ASSERT_TRUE(backtrace != NULL);
831 ASSERT_TRUE(backtrace->Unwind(0));
832 delete backtrace;
833 }
834 size_t new_pss = GetPssBytes();
835 size_t abs_diff = (new_pss > stable_pss) ? new_pss - stable_pss : stable_pss - new_pss;
836 // As long as the new pss is within a certain amount, consider everything okay.
837 ASSERT_LE(abs_diff, MAX_LEAK_BYTES);
838 }
839
TEST(libbacktrace,check_for_leak_local)840 TEST(libbacktrace, check_for_leak_local) {
841 CheckForLeak(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD);
842 }
843
TEST(libbacktrace,check_for_leak_local_thread)844 TEST(libbacktrace, check_for_leak_local_thread) {
845 thread_t thread_data = { 0, 0, 0 };
846 pthread_t thread;
847 ASSERT_TRUE(pthread_create(&thread, NULL, ThreadLevelRun, &thread_data) == 0);
848
849 // Wait up to 2 seconds for the tid to be set.
850 ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2));
851
852 CheckForLeak(BACKTRACE_CURRENT_PROCESS, thread_data.tid);
853
854 // Tell the thread to exit its infinite loop.
855 android_atomic_acquire_store(0, &thread_data.state);
856
857 ASSERT_TRUE(pthread_join(thread, NULL) == 0);
858 }
859
TEST(libbacktrace,check_for_leak_remote)860 TEST(libbacktrace, check_for_leak_remote) {
861 pid_t pid;
862
863 if ((pid = fork()) == 0) {
864 while (true) {
865 }
866 _exit(0);
867 }
868 ASSERT_LT(0, pid);
869
870 ASSERT_TRUE(ptrace(PTRACE_ATTACH, pid, 0, 0) == 0);
871
872 // Wait for the process to get to a stopping point.
873 WaitForStop(pid);
874
875 CheckForLeak(pid, BACKTRACE_CURRENT_THREAD);
876
877 ASSERT_TRUE(ptrace(PTRACE_DETACH, pid, 0, 0) == 0);
878
879 kill(pid, SIGKILL);
880 ASSERT_EQ(waitpid(pid, NULL, 0), pid);
881 }
882 #endif
883