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 <errno.h>
19 #include <stdint.h>
20 #include <string.h>
21 #include <sys/param.h>
22 #include <sys/ptrace.h>
23 #include <sys/types.h>
24 #include <ucontext.h>
25 #include <unistd.h>
26
27 #include <string>
28
29 #include <backtrace/Backtrace.h>
30 #include <backtrace/BacktraceMap.h>
31
32 #include <cutils/threads.h>
33
34 #include "BacktraceCurrent.h"
35 #include "BacktraceLog.h"
36 #include "ThreadEntry.h"
37 #include "thread_utils.h"
38
ReadWord(uintptr_t ptr,word_t * out_value)39 bool BacktraceCurrent::ReadWord(uintptr_t ptr, word_t* out_value) {
40 if (!VerifyReadWordArgs(ptr, out_value)) {
41 return false;
42 }
43
44 backtrace_map_t map;
45 FillInMap(ptr, &map);
46 if (BacktraceMap::IsValid(map) && map.flags & PROT_READ) {
47 *out_value = *reinterpret_cast<word_t*>(ptr);
48 return true;
49 } else {
50 BACK_LOGW("pointer %p not in a readable map", reinterpret_cast<void*>(ptr));
51 *out_value = static_cast<word_t>(-1);
52 return false;
53 }
54 }
55
Read(uintptr_t addr,uint8_t * buffer,size_t bytes)56 size_t BacktraceCurrent::Read(uintptr_t addr, uint8_t* buffer, size_t bytes) {
57 backtrace_map_t map;
58 FillInMap(addr, &map);
59 if (!BacktraceMap::IsValid(map) || !(map.flags & PROT_READ)) {
60 return 0;
61 }
62 bytes = MIN(map.end - addr, bytes);
63 memcpy(buffer, reinterpret_cast<uint8_t*>(addr), bytes);
64 return bytes;
65 }
66
Unwind(size_t num_ignore_frames,ucontext_t * ucontext)67 bool BacktraceCurrent::Unwind(size_t num_ignore_frames, ucontext_t* ucontext) {
68 if (GetMap() == nullptr) {
69 // Without a map object, we can't do anything.
70 return false;
71 }
72
73 if (ucontext) {
74 return UnwindFromContext(num_ignore_frames, ucontext);
75 }
76
77 if (Tid() != gettid()) {
78 return UnwindThread(num_ignore_frames);
79 }
80
81 return UnwindFromContext(num_ignore_frames, nullptr);
82 }
83
DiscardFrame(const backtrace_frame_data_t & frame)84 bool BacktraceCurrent::DiscardFrame(const backtrace_frame_data_t& frame) {
85 if (BacktraceMap::IsValid(frame.map)) {
86 const std::string library = basename(frame.map.name.c_str());
87 if (library == "libunwind.so" || library == "libbacktrace.so") {
88 return true;
89 }
90 }
91 return false;
92 }
93
94 static pthread_mutex_t g_sigaction_mutex = PTHREAD_MUTEX_INITIALIZER;
95
SignalLogOnly(int,siginfo_t *,void *)96 static void SignalLogOnly(int, siginfo_t*, void*) {
97 BACK_LOGE("pid %d, tid %d: Received a spurious signal %d\n", getpid(), gettid(), THREAD_SIGNAL);
98 }
99
SignalHandler(int,siginfo_t *,void * sigcontext)100 static void SignalHandler(int, siginfo_t*, void* sigcontext) {
101 ThreadEntry* entry = ThreadEntry::Get(getpid(), gettid(), false);
102 if (!entry) {
103 BACK_LOGE("pid %d, tid %d entry not found", getpid(), gettid());
104 return;
105 }
106
107 entry->CopyUcontextFromSigcontext(sigcontext);
108
109 // Indicate the ucontext is now valid.
110 entry->Wake();
111
112 // Pause the thread until the unwind is complete. This avoids having
113 // the thread run ahead causing problems.
114 // The number indicates that we are waiting for the second Wake() call
115 // overall which is made by the thread requesting an unwind.
116 if (entry->Wait(2)) {
117 // Do not remove the entry here because that can result in a deadlock
118 // if the code cannot properly send a signal to the thread under test.
119 entry->Wake();
120 } else {
121 // At this point, it is possible that entry has been freed, so just exit.
122 BACK_LOGE("Timed out waiting for unwind thread to indicate it completed.");
123 }
124 }
125
UnwindThread(size_t num_ignore_frames)126 bool BacktraceCurrent::UnwindThread(size_t num_ignore_frames) {
127 // Prevent multiple threads trying to set the trigger action on different
128 // threads at the same time.
129 pthread_mutex_lock(&g_sigaction_mutex);
130
131 ThreadEntry* entry = ThreadEntry::Get(Pid(), Tid());
132 entry->Lock();
133
134 struct sigaction act, oldact;
135 memset(&act, 0, sizeof(act));
136 act.sa_sigaction = SignalHandler;
137 act.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
138 sigemptyset(&act.sa_mask);
139 if (sigaction(THREAD_SIGNAL, &act, &oldact) != 0) {
140 BACK_LOGE("sigaction failed: %s", strerror(errno));
141 ThreadEntry::Remove(entry);
142 pthread_mutex_unlock(&g_sigaction_mutex);
143 return false;
144 }
145
146 if (tgkill(Pid(), Tid(), THREAD_SIGNAL) != 0) {
147 BACK_LOGE("tgkill %d failed: %s", Tid(), strerror(errno));
148 sigaction(THREAD_SIGNAL, &oldact, nullptr);
149 ThreadEntry::Remove(entry);
150 pthread_mutex_unlock(&g_sigaction_mutex);
151 return false;
152 }
153
154 // Wait for the thread to get the ucontext. The number indicates
155 // that we are waiting for the first Wake() call made by the thread.
156 bool wait_completed = entry->Wait(1);
157
158 if (!wait_completed && oldact.sa_sigaction == nullptr) {
159 // If the wait failed, it could be that the signal could not be delivered
160 // within the timeout. Add a signal handler that's simply going to log
161 // something so that we don't crash if the signal eventually gets
162 // delivered. Only do this if there isn't already an action set up.
163 memset(&act, 0, sizeof(act));
164 act.sa_sigaction = SignalLogOnly;
165 act.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
166 sigemptyset(&act.sa_mask);
167 sigaction(THREAD_SIGNAL, &act, nullptr);
168 } else {
169 sigaction(THREAD_SIGNAL, &oldact, nullptr);
170 }
171 // After the thread has received the signal, allow other unwinders to
172 // continue.
173 pthread_mutex_unlock(&g_sigaction_mutex);
174
175 bool unwind_done = false;
176 if (wait_completed) {
177 unwind_done = UnwindFromContext(num_ignore_frames, entry->GetUcontext());
178
179 // Tell the signal handler to exit and release the entry.
180 entry->Wake();
181
182 // Wait for the thread to indicate it is done with the ThreadEntry.
183 if (!entry->Wait(3)) {
184 // Send a warning, but do not mark as a failure to unwind.
185 BACK_LOGW("Timed out waiting for signal handler to indicate it finished.");
186 }
187 } else {
188 BACK_LOGE("Timed out waiting for signal handler to get ucontext data.");
189 }
190
191 ThreadEntry::Remove(entry);
192
193 return unwind_done;
194 }
195