blob: f0b6ee4a58f0c3b3d2882a4a1fbf05cb7543d5b2 [file] [log] [blame]
Elliott Hughese27955c2011-08-26 15:21:24 -07001/*
2 * Copyright (C) 2008 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 "signal_catcher.h"
18
Elliott Hughes94ce37a2011-10-18 15:07:48 -070019#include <fcntl.h>
Elliott Hughese27955c2011-08-26 15:21:24 -070020#include <pthread.h>
21#include <signal.h>
22#include <stdlib.h>
Elliott Hughes94ce37a2011-10-18 15:07:48 -070023#include <sys/stat.h>
Elliott Hughese27955c2011-08-26 15:21:24 -070024#include <sys/time.h>
Elliott Hughes94ce37a2011-10-18 15:07:48 -070025#include <sys/types.h>
Elliott Hughese27955c2011-08-26 15:21:24 -070026#include <unistd.h>
27
Ian Rogersc7dd2952014-10-21 23:31:19 -070028#include <sstream>
29
Narayan Kamath84695ae2017-04-07 15:41:41 +010030#include "android-base/stringprintf.h"
Ian Rogersd582fa42014-11-05 23:46:43 -080031#include "arch/instruction_set.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010032#include "base/time_utils.h"
Elliott Hughes76160052012-12-12 16:31:20 -080033#include "base/unix_file/fd_file.h"
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -070034#include "class_linker.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070035#include "gc/heap.h"
Mathieu Chartier07ea07e2017-04-05 17:23:54 -070036#include "jit/profile_saver.h"
Elliott Hughes94ce37a2011-10-18 15:07:48 -070037#include "os.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070038#include "runtime.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -070039#include "scoped_thread_state_change-inl.h"
Elliott Hughes457005c2012-04-16 13:54:25 -070040#include "signal_set.h"
Elliott Hughese27955c2011-08-26 15:21:24 -070041#include "thread.h"
Elliott Hughes8d768a92011-09-14 16:35:25 -070042#include "thread_list.h"
Elliott Hughese27955c2011-08-26 15:21:24 -070043#include "utils.h"
44
Narayan Kamatheb710332017-05-10 11:48:46 +010045#if defined(ART_TARGET_ANDROID)
46#include "tombstoned/tombstoned.h"
47#endif
48
Elliott Hughese27955c2011-08-26 15:21:24 -070049namespace art {
50
Elliott Hughes0d39c122012-06-06 16:41:17 -070051static void DumpCmdLine(std::ostream& os) {
52#if defined(__linux__)
53 // Show the original command line, and the current command line too if it's changed.
54 // On Android, /proc/self/cmdline will have been rewritten to something like "system_server".
Jeff Brownb4fffc72014-09-10 18:41:18 -070055 // Note: The string "Cmd line:" is chosen to match the format used by debuggerd.
Elliott Hughes0d39c122012-06-06 16:41:17 -070056 std::string current_cmd_line;
57 if (ReadFileToString("/proc/self/cmdline", &current_cmd_line)) {
Jeff Brownb4fffc72014-09-10 18:41:18 -070058 current_cmd_line.resize(current_cmd_line.find_last_not_of('\0') + 1); // trim trailing '\0's
Elliott Hughes0d39c122012-06-06 16:41:17 -070059 std::replace(current_cmd_line.begin(), current_cmd_line.end(), '\0', ' ');
60
Jeff Brownb4fffc72014-09-10 18:41:18 -070061 os << "Cmd line: " << current_cmd_line << "\n";
Elliott Hughes0d39c122012-06-06 16:41:17 -070062 const char* stashed_cmd_line = GetCmdLine();
Mathieu Chartier2cebb242015-04-21 16:50:40 -070063 if (stashed_cmd_line != nullptr && current_cmd_line != stashed_cmd_line
Jeff Brownb4fffc72014-09-10 18:41:18 -070064 && strcmp(stashed_cmd_line, "<unset>") != 0) {
65 os << "Original command line: " << stashed_cmd_line << "\n";
Elliott Hughes0d39c122012-06-06 16:41:17 -070066 }
Elliott Hughesae80b492012-04-24 10:43:17 -070067 }
Elliott Hughes0d39c122012-06-06 16:41:17 -070068#else
Jeff Brownb4fffc72014-09-10 18:41:18 -070069 os << "Cmd line: " << GetCmdLine() << "\n";
Elliott Hughesabbe07d2012-06-05 17:42:23 -070070#endif
Elliott Hughes0d39c122012-06-06 16:41:17 -070071}
Elliott Hughesae80b492012-04-24 10:43:17 -070072
Narayan Kamatheb710332017-05-10 11:48:46 +010073SignalCatcher::SignalCatcher(const std::string& stack_trace_file,
74 bool use_tombstoned_stack_trace_fd)
75 : stack_trace_file_(stack_trace_file),
76 use_tombstoned_stack_trace_fd_(use_tombstoned_stack_trace_fd),
Elliott Hughes94ce37a2011-10-18 15:07:48 -070077 lock_("SignalCatcher lock"),
Ian Rogersc604d732012-10-14 16:09:54 -070078 cond_("SignalCatcher::cond_", lock_),
Mathieu Chartier2cebb242015-04-21 16:50:40 -070079 thread_(nullptr) {
Narayan Kamatheb710332017-05-10 11:48:46 +010080#if !defined(ART_TARGET_ANDROID)
81 // We're not running on Android, so we can't communicate with tombstoned
82 // to ask for an open file.
83 CHECK(!use_tombstoned_stack_trace_fd_);
84#endif
85
Elliott Hughes5fe594f2011-09-08 12:33:17 -070086 SetHaltFlag(false);
87
Elliott Hughese27955c2011-08-26 15:21:24 -070088 // Create a raw pthread; its start routine will attach to the runtime.
Mathieu Chartier2cebb242015-04-21 16:50:40 -070089 CHECK_PTHREAD_CALL(pthread_create, (&pthread_, nullptr, &Run, this), "signal catcher thread");
Elliott Hughes8d768a92011-09-14 16:35:25 -070090
Ian Rogers81d425b2012-09-27 16:03:43 -070091 Thread* self = Thread::Current();
92 MutexLock mu(self, lock_);
Mathieu Chartier2cebb242015-04-21 16:50:40 -070093 while (thread_ == nullptr) {
Ian Rogersc604d732012-10-14 16:09:54 -070094 cond_.Wait(self);
Elliott Hughese27955c2011-08-26 15:21:24 -070095 }
96}
97
98SignalCatcher::~SignalCatcher() {
99 // Since we know the thread is just sitting around waiting for signals
100 // to arrive, send it one.
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700101 SetHaltFlag(true);
Elliott Hughes8d768a92011-09-14 16:35:25 -0700102 CHECK_PTHREAD_CALL(pthread_kill, (pthread_, SIGQUIT), "signal catcher shutdown");
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700103 CHECK_PTHREAD_CALL(pthread_join, (pthread_, nullptr), "signal catcher shutdown");
Elliott Hughese27955c2011-08-26 15:21:24 -0700104}
105
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700106void SignalCatcher::SetHaltFlag(bool new_value) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700107 MutexLock mu(Thread::Current(), lock_);
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700108 halt_ = new_value;
109}
110
111bool SignalCatcher::ShouldHalt() {
Ian Rogers50b35e22012-10-04 10:09:15 -0700112 MutexLock mu(Thread::Current(), lock_);
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700113 return halt_;
114}
115
Narayan Kamatheb710332017-05-10 11:48:46 +0100116bool SignalCatcher::OpenStackTraceFile(android::base::unique_fd* tombstone_fd,
117 android::base::unique_fd* output_fd) {
118 if (use_tombstoned_stack_trace_fd_) {
119#if defined(ART_TARGET_ANDROID)
Narayan Kamathe0f02b72017-05-30 16:22:28 +0100120 return tombstoned_connect(getpid(), tombstone_fd, output_fd, kDebuggerdJavaBacktrace);
Narayan Kamatheb710332017-05-10 11:48:46 +0100121#else
122 UNUSED(tombstone_fd);
123 UNUSED(output_fd);
124#endif
Narayan Kamath84695ae2017-04-07 15:41:41 +0100125 }
126
Narayan Kamatheb710332017-05-10 11:48:46 +0100127 // The runtime is not configured to dump traces to a file, will LOG(INFO)
128 // instead.
129 if (stack_trace_file_.empty()) {
130 return false;
131 }
132
133 int fd = open(stack_trace_file_.c_str(), O_APPEND | O_CREAT | O_WRONLY, 0666);
134 if (fd == -1) {
135 PLOG(ERROR) << "Unable to open stack trace file '" << stack_trace_file_ << "'";
136 return false;
137 }
138
139 output_fd->reset(fd);
140 return true;
Narayan Kamath84695ae2017-04-07 15:41:41 +0100141}
142
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700143void SignalCatcher::Output(const std::string& s) {
Narayan Kamatheb710332017-05-10 11:48:46 +0100144 android::base::unique_fd tombstone_fd;
145 android::base::unique_fd output_fd;
146 if (!OpenStackTraceFile(&tombstone_fd, &output_fd)) {
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700147 LOG(INFO) << s;
148 return;
149 }
150
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700151 ScopedThreadStateChange tsc(Thread::Current(), kWaitingForSignalCatcherOutput);
Narayan Kamatheb710332017-05-10 11:48:46 +0100152
153 std::unique_ptr<File> file(new File(output_fd.release(), true /* check_usage */));
Andreas Gampe4303ba92014-11-06 01:00:46 -0800154 bool success = file->WriteFully(s.data(), s.size());
155 if (success) {
156 success = file->FlushCloseOrErase() == 0;
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700157 } else {
Andreas Gampe4303ba92014-11-06 01:00:46 -0800158 file->Erase();
159 }
Narayan Kamatheb710332017-05-10 11:48:46 +0100160
161 const std::string output_path_msg = (use_tombstoned_stack_trace_fd_) ?
162 "[tombstoned]" : stack_trace_file_;
163
Andreas Gampe4303ba92014-11-06 01:00:46 -0800164 if (success) {
Narayan Kamatheb710332017-05-10 11:48:46 +0100165 LOG(INFO) << "Wrote stack traces to '" << output_path_msg << "'";
Andreas Gampe4303ba92014-11-06 01:00:46 -0800166 } else {
Narayan Kamatheb710332017-05-10 11:48:46 +0100167 PLOG(ERROR) << "Failed to write stack traces to '" << output_path_msg << "'";
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700168 }
Narayan Kamatheb710332017-05-10 11:48:46 +0100169
170#if defined(ART_TARGET_ANDROID)
Narayan Kamath2cfd6122017-07-11 17:40:56 +0100171 if (use_tombstoned_stack_trace_fd_ && !tombstoned_notify_completion(tombstone_fd)) {
Narayan Kamatheb710332017-05-10 11:48:46 +0100172 LOG(WARNING) << "Unable to notify tombstoned of dump completion.";
173 }
174#endif
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700175}
176
Elliott Hughese27955c2011-08-26 15:21:24 -0700177void SignalCatcher::HandleSigQuit() {
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700178 Runtime* runtime = Runtime::Current();
Elliott Hughes3b6baaa2011-10-14 19:13:56 -0700179 std::ostringstream os;
Elliott Hughesd92bec42011-09-02 17:04:36 -0700180 os << "\n"
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700181 << "----- pid " << getpid() << " at " << GetIsoDate() << " -----\n";
Elliott Hughese27955c2011-08-26 15:21:24 -0700182
Elliott Hughes0d39c122012-06-06 16:41:17 -0700183 DumpCmdLine(os);
Elliott Hughesae80b492012-04-24 10:43:17 -0700184
Andreas Gampedd671252015-07-23 14:37:18 -0700185 // Note: The strings "Build fingerprint:" and "ABI:" are chosen to match the format used by
186 // debuggerd. This allows, for example, the stack tool to work.
187 std::string fingerprint = runtime->GetFingerprint();
188 os << "Build fingerprint: '" << (fingerprint.empty() ? "unknown" : fingerprint) << "'\n";
189 os << "ABI: '" << GetInstructionSetString(runtime->GetInstructionSet()) << "'\n";
Jeff Brownb4fffc72014-09-10 18:41:18 -0700190
Elliott Hughesae80b492012-04-24 10:43:17 -0700191 os << "Build type: " << (kIsDebugBuild ? "debug" : "optimized") << "\n";
Elliott Hughese27955c2011-08-26 15:21:24 -0700192
Elliott Hughesc967f782012-04-16 10:23:15 -0700193 runtime->DumpForSigQuit(os);
Elliott Hughese27955c2011-08-26 15:21:24 -0700194
Ian Rogerscf7f1912014-10-22 22:06:39 -0700195 if ((false)) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700196 std::string maps;
197 if (ReadFileToString("/proc/self/maps", &maps)) {
198 os << "/proc/self/maps:\n" << maps;
199 }
Elliott Hughesd92bec42011-09-02 17:04:36 -0700200 }
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700201 os << "----- end " << getpid() << " -----\n";
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700202 Output(os.str());
Elliott Hughese27955c2011-08-26 15:21:24 -0700203}
204
205void SignalCatcher::HandleSigUsr1() {
Mathieu Chartier07ea07e2017-04-05 17:23:54 -0700206 LOG(INFO) << "SIGUSR1 forcing GC (no HPROF) and profile save";
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800207 Runtime::Current()->GetHeap()->CollectGarbage(false);
Mathieu Chartier07ea07e2017-04-05 17:23:54 -0700208 ProfileSaver::ForceProcessProfiles();
Elliott Hughese27955c2011-08-26 15:21:24 -0700209}
210
Elliott Hughesf8349362012-06-18 15:00:06 -0700211int SignalCatcher::WaitForSignal(Thread* self, SignalSet& signals) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700212 ScopedThreadStateChange tsc(self, kWaitingInMainSignalCatcherLoop);
Elliott Hughesad7c2a32011-08-31 11:58:10 -0700213
214 // Signals for sigwait() must be blocked but not ignored. We
215 // block signals like SIGQUIT for all threads, so the condition
216 // is met. When the signal hits, we wake up, without any signal
217 // handlers being invoked.
Elliott Hughes457005c2012-04-16 13:54:25 -0700218 int signal_number = signals.Wait();
Elliott Hughesc2f80062011-11-07 11:57:51 -0800219 if (!ShouldHalt()) {
220 // Let the user know we got the signal, just in case the system's too screwed for us to
221 // actually do what they want us to do...
Elliott Hughesf8349362012-06-18 15:00:06 -0700222 LOG(INFO) << *self << ": reacting to signal " << signal_number;
Elliott Hughesc2f80062011-11-07 11:57:51 -0800223
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800224 // If anyone's holding locks (which might prevent us from getting back into state Runnable), say so...
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700225 Runtime::Current()->DumpLockHolders(LOG_STREAM(INFO));
Elliott Hughesc2f80062011-11-07 11:57:51 -0800226 }
227
Elliott Hughesad7c2a32011-08-31 11:58:10 -0700228 return signal_number;
229}
230
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700231void* SignalCatcher::Run(void* arg) {
232 SignalCatcher* signal_catcher = reinterpret_cast<SignalCatcher*>(arg);
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700233 CHECK(signal_catcher != nullptr);
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700234
Elliott Hughes8d768a92011-09-14 16:35:25 -0700235 Runtime* runtime = Runtime::Current();
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800236 CHECK(runtime->AttachCurrentThread("Signal Catcher", true, runtime->GetSystemThreadGroup(),
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800237 !runtime->IsAotCompiler()));
Elliott Hughesf8349362012-06-18 15:00:06 -0700238
239 Thread* self = Thread::Current();
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700240 DCHECK_NE(self->GetState(), kRunnable);
Elliott Hughes8d768a92011-09-14 16:35:25 -0700241 {
Ian Rogers81d425b2012-09-27 16:03:43 -0700242 MutexLock mu(self, signal_catcher->lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -0700243 signal_catcher->thread_ = self;
Ian Rogersc604d732012-10-14 16:09:54 -0700244 signal_catcher->cond_.Broadcast(self);
Elliott Hughes8d768a92011-09-14 16:35:25 -0700245 }
Elliott Hughese27955c2011-08-26 15:21:24 -0700246
Elliott Hughese27955c2011-08-26 15:21:24 -0700247 // Set up mask with signals we want to handle.
Elliott Hughes457005c2012-04-16 13:54:25 -0700248 SignalSet signals;
249 signals.Add(SIGQUIT);
250 signals.Add(SIGUSR1);
Elliott Hughese27955c2011-08-26 15:21:24 -0700251
252 while (true) {
Elliott Hughesf8349362012-06-18 15:00:06 -0700253 int signal_number = signal_catcher->WaitForSignal(self, signals);
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700254 if (signal_catcher->ShouldHalt()) {
Elliott Hughes8d768a92011-09-14 16:35:25 -0700255 runtime->DetachCurrentThread();
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700256 return nullptr;
Elliott Hughese27955c2011-08-26 15:21:24 -0700257 }
258
Elliott Hughese27955c2011-08-26 15:21:24 -0700259 switch (signal_number) {
260 case SIGQUIT:
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700261 signal_catcher->HandleSigQuit();
Elliott Hughese27955c2011-08-26 15:21:24 -0700262 break;
263 case SIGUSR1:
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700264 signal_catcher->HandleSigUsr1();
Elliott Hughese27955c2011-08-26 15:21:24 -0700265 break;
266 default:
267 LOG(ERROR) << "Unexpected signal %d" << signal_number;
268 break;
269 }
270 }
271}
272
273} // namespace art