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