| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "signal_catcher.h" |
| |
| #include <fcntl.h> |
| #include <pthread.h> |
| #include <signal.h> |
| #include <stdlib.h> |
| #include <sys/stat.h> |
| #include <sys/time.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| |
| #include "base/unix_file/fd_file.h" |
| #include "class_linker.h" |
| #include "gc/heap.h" |
| #include "instruction_set.h" |
| #include "os.h" |
| #include "runtime.h" |
| #include "scoped_thread_state_change.h" |
| #include "signal_set.h" |
| #include "thread.h" |
| #include "thread_list.h" |
| #include "utils.h" |
| |
| namespace art { |
| |
| static void DumpCmdLine(std::ostream& os) { |
| #if defined(__linux__) |
| // Show the original command line, and the current command line too if it's changed. |
| // On Android, /proc/self/cmdline will have been rewritten to something like "system_server". |
| // Note: The string "Cmd line:" is chosen to match the format used by debuggerd. |
| std::string current_cmd_line; |
| if (ReadFileToString("/proc/self/cmdline", ¤t_cmd_line)) { |
| current_cmd_line.resize(current_cmd_line.find_last_not_of('\0') + 1); // trim trailing '\0's |
| std::replace(current_cmd_line.begin(), current_cmd_line.end(), '\0', ' '); |
| |
| os << "Cmd line: " << current_cmd_line << "\n"; |
| const char* stashed_cmd_line = GetCmdLine(); |
| if (stashed_cmd_line != NULL && current_cmd_line != stashed_cmd_line |
| && strcmp(stashed_cmd_line, "<unset>") != 0) { |
| os << "Original command line: " << stashed_cmd_line << "\n"; |
| } |
| } |
| #else |
| os << "Cmd line: " << GetCmdLine() << "\n"; |
| #endif |
| } |
| |
| SignalCatcher::SignalCatcher(const std::string& stack_trace_file) |
| : stack_trace_file_(stack_trace_file), |
| lock_("SignalCatcher lock"), |
| cond_("SignalCatcher::cond_", lock_), |
| thread_(NULL) { |
| SetHaltFlag(false); |
| |
| // Create a raw pthread; its start routine will attach to the runtime. |
| CHECK_PTHREAD_CALL(pthread_create, (&pthread_, NULL, &Run, this), "signal catcher thread"); |
| |
| Thread* self = Thread::Current(); |
| MutexLock mu(self, lock_); |
| while (thread_ == NULL) { |
| cond_.Wait(self); |
| } |
| } |
| |
| SignalCatcher::~SignalCatcher() { |
| // Since we know the thread is just sitting around waiting for signals |
| // to arrive, send it one. |
| SetHaltFlag(true); |
| CHECK_PTHREAD_CALL(pthread_kill, (pthread_, SIGQUIT), "signal catcher shutdown"); |
| CHECK_PTHREAD_CALL(pthread_join, (pthread_, NULL), "signal catcher shutdown"); |
| } |
| |
| void SignalCatcher::SetHaltFlag(bool new_value) { |
| MutexLock mu(Thread::Current(), lock_); |
| halt_ = new_value; |
| } |
| |
| bool SignalCatcher::ShouldHalt() { |
| MutexLock mu(Thread::Current(), lock_); |
| return halt_; |
| } |
| |
| void SignalCatcher::Output(const std::string& s) { |
| if (stack_trace_file_.empty()) { |
| LOG(INFO) << s; |
| return; |
| } |
| |
| ScopedThreadStateChange tsc(Thread::Current(), kWaitingForSignalCatcherOutput); |
| int fd = open(stack_trace_file_.c_str(), O_APPEND | O_CREAT | O_WRONLY, 0666); |
| if (fd == -1) { |
| PLOG(ERROR) << "Unable to open stack trace file '" << stack_trace_file_ << "'"; |
| return; |
| } |
| std::unique_ptr<File> file(new File(fd, stack_trace_file_, true)); |
| bool success = file->WriteFully(s.data(), s.size()); |
| if (success) { |
| success = file->FlushCloseOrErase() == 0; |
| } else { |
| file->Erase(); |
| } |
| if (success) { |
| LOG(INFO) << "Wrote stack traces to '" << stack_trace_file_ << "'"; |
| } else { |
| PLOG(ERROR) << "Failed to write stack traces to '" << stack_trace_file_ << "'"; |
| } |
| } |
| |
| void SignalCatcher::HandleSigQuit() { |
| Runtime* runtime = Runtime::Current(); |
| ThreadList* thread_list = runtime->GetThreadList(); |
| |
| // Grab exclusively the mutator lock, set state to Runnable without checking for a pending |
| // suspend request as we're going to suspend soon anyway. We set the state to Runnable to avoid |
| // giving away the mutator lock. |
| thread_list->SuspendAll(); |
| Thread* self = Thread::Current(); |
| Locks::mutator_lock_->AssertExclusiveHeld(self); |
| const char* old_cause = self->StartAssertNoThreadSuspension("Handling SIGQUIT"); |
| ThreadState old_state = self->SetStateUnsafe(kRunnable); |
| |
| std::ostringstream os; |
| os << "\n" |
| << "----- pid " << getpid() << " at " << GetIsoDate() << " -----\n"; |
| |
| DumpCmdLine(os); |
| |
| // Note: The string "ABI:" is chosen to match the format used by debuggerd. |
| os << "ABI: " << GetInstructionSetString(runtime->GetInstructionSet()) << "\n"; |
| |
| os << "Build type: " << (kIsDebugBuild ? "debug" : "optimized") << "\n"; |
| |
| runtime->DumpForSigQuit(os); |
| |
| if (false) { |
| std::string maps; |
| if (ReadFileToString("/proc/self/maps", &maps)) { |
| os << "/proc/self/maps:\n" << maps; |
| } |
| } |
| os << "----- end " << getpid() << " -----\n"; |
| CHECK_EQ(self->SetStateUnsafe(old_state), kRunnable); |
| self->EndAssertNoThreadSuspension(old_cause); |
| thread_list->ResumeAll(); |
| // Run the checkpoints after resuming the threads to prevent deadlocks if the checkpoint function |
| // acquires the mutator lock. |
| if (self->ReadFlag(kCheckpointRequest)) { |
| self->RunCheckpointFunction(); |
| } |
| Output(os.str()); |
| } |
| |
| void SignalCatcher::HandleSigUsr1() { |
| LOG(INFO) << "SIGUSR1 forcing GC (no HPROF)"; |
| Runtime::Current()->GetHeap()->CollectGarbage(false); |
| } |
| |
| int SignalCatcher::WaitForSignal(Thread* self, SignalSet& signals) { |
| ScopedThreadStateChange tsc(self, kWaitingInMainSignalCatcherLoop); |
| |
| // Signals for sigwait() must be blocked but not ignored. We |
| // block signals like SIGQUIT for all threads, so the condition |
| // is met. When the signal hits, we wake up, without any signal |
| // handlers being invoked. |
| int signal_number = signals.Wait(); |
| if (!ShouldHalt()) { |
| // Let the user know we got the signal, just in case the system's too screwed for us to |
| // actually do what they want us to do... |
| LOG(INFO) << *self << ": reacting to signal " << signal_number; |
| |
| // If anyone's holding locks (which might prevent us from getting back into state Runnable), say so... |
| Runtime::Current()->DumpLockHolders(LOG(INFO)); |
| } |
| |
| return signal_number; |
| } |
| |
| void* SignalCatcher::Run(void* arg) { |
| SignalCatcher* signal_catcher = reinterpret_cast<SignalCatcher*>(arg); |
| CHECK(signal_catcher != NULL); |
| |
| Runtime* runtime = Runtime::Current(); |
| CHECK(runtime->AttachCurrentThread("Signal Catcher", true, runtime->GetSystemThreadGroup(), |
| !runtime->IsCompiler())); |
| |
| Thread* self = Thread::Current(); |
| DCHECK_NE(self->GetState(), kRunnable); |
| { |
| MutexLock mu(self, signal_catcher->lock_); |
| signal_catcher->thread_ = self; |
| signal_catcher->cond_.Broadcast(self); |
| } |
| |
| // Set up mask with signals we want to handle. |
| SignalSet signals; |
| signals.Add(SIGQUIT); |
| signals.Add(SIGUSR1); |
| |
| while (true) { |
| int signal_number = signal_catcher->WaitForSignal(self, signals); |
| if (signal_catcher->ShouldHalt()) { |
| runtime->DetachCurrentThread(); |
| return NULL; |
| } |
| |
| switch (signal_number) { |
| case SIGQUIT: |
| signal_catcher->HandleSigQuit(); |
| break; |
| case SIGUSR1: |
| signal_catcher->HandleSigUsr1(); |
| break; |
| default: |
| LOG(ERROR) << "Unexpected signal %d" << signal_number; |
| break; |
| } |
| } |
| } |
| |
| } // namespace art |