runtime/signal_catcher.cc - LeafOS-Project/android_art - Gitiles

 /*
  * 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 <sstream>

 #include <android-base/stringprintf.h>

 #if defined(ART_TARGET_ANDROID)
 #include <tombstoned/tombstoned.h>
 #endif

 #include "arch/instruction_set.h"
 #include "base/file_utils.h"
 #include "base/time_utils.h"
 #include "base/unix_file/fd_file.h"
 #include "class_linker.h"
 #include "gc/heap.h"
 #include "jit/profile_saver.h"
 #include "os.h"
 #include "runtime.h"
 #include "scoped_thread_state_change-inl.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", &current_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 != nullptr && 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,
                              bool use_tombstoned_stack_trace_fd)
     : stack_trace_file_(stack_trace_file),
       use_tombstoned_stack_trace_fd_(use_tombstoned_stack_trace_fd),
       lock_("SignalCatcher lock"),
       cond_("SignalCatcher::cond_", lock_),
       thread_(nullptr) {
 #if !defined(ART_TARGET_ANDROID)
   // We're not running on Android, so we can't communicate with tombstoned
   // to ask for an open file.
   CHECK(!use_tombstoned_stack_trace_fd_);
 #endif

   SetHaltFlag(false);

   // Create a raw pthread; its start routine will attach to the runtime.
   CHECK_PTHREAD_CALL(pthread_create, (&pthread_, nullptr, &Run, this), "signal catcher thread");

   Thread* self = Thread::Current();
   MutexLock mu(self, lock_);
   while (thread_ == nullptr) {
     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_, nullptr), "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_;
 }

 bool SignalCatcher::OpenStackTraceFile(android::base::unique_fd* tombstone_fd,
                                        android::base::unique_fd* output_fd) {
   if (use_tombstoned_stack_trace_fd_) {
 #if defined(ART_TARGET_ANDROID)
     return tombstoned_connect(getpid(), tombstone_fd, output_fd, kDebuggerdJavaBacktrace);
 #else
     UNUSED(tombstone_fd);
     UNUSED(output_fd);
 #endif
   }

   // The runtime is not configured to dump traces to a file, will LOG(INFO)
   // instead.
   if (stack_trace_file_.empty()) {
     return false;
   }

   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 false;
   }

   output_fd->reset(fd);
   return true;
 }

 void SignalCatcher::Output(const std::string& s) {
   android::base::unique_fd tombstone_fd;
   android::base::unique_fd output_fd;
   if (!OpenStackTraceFile(&tombstone_fd, &output_fd)) {
     LOG(INFO) << s;
     return;
   }

   ScopedThreadStateChange tsc(Thread::Current(), kWaitingForSignalCatcherOutput);

   std::unique_ptr<File> file(new File(output_fd.release(), true /* check_usage */));
   bool success = file->WriteFully(s.data(), s.size());
   if (success) {
     success = file->FlushCloseOrErase() == 0;
   } else {
     file->Erase();
   }

   const std::string output_path_msg = (use_tombstoned_stack_trace_fd_) ?
       "[tombstoned]" : stack_trace_file_;

   if (success) {
     LOG(INFO) << "Wrote stack traces to '" << output_path_msg << "'";
   } else {
     PLOG(ERROR) << "Failed to write stack traces to '" << output_path_msg << "'";
   }

 #if defined(ART_TARGET_ANDROID)
   if (use_tombstoned_stack_trace_fd_ && !tombstoned_notify_completion(tombstone_fd)) {
     PLOG(WARNING) << "Unable to notify tombstoned of dump completion";
   }
 #endif
 }

 void SignalCatcher::HandleSigQuit() {
   Runtime* runtime = Runtime::Current();
   std::ostringstream os;
   os << "\n"
       << "----- pid " << getpid() << " at " << GetIsoDate() << " -----\n";

   DumpCmdLine(os);

   // Note: The strings "Build fingerprint:" and "ABI:" are chosen to match the format used by
   // debuggerd. This allows, for example, the stack tool to work.
   std::string fingerprint = runtime->GetFingerprint();
   os << "Build fingerprint: '" << (fingerprint.empty() ? "unknown" : fingerprint) << "'\n";
   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";
   Output(os.str());
 }

 void SignalCatcher::HandleSigUsr1() {
   LOG(INFO) << "SIGUSR1 forcing GC (no HPROF) and profile save";
   Runtime::Current()->GetHeap()->CollectGarbage(false);
   ProfileSaver::ForceProcessProfiles();
 }

 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_STREAM(INFO));
   }

   return signal_number;
 }

 void* SignalCatcher::Run(void* arg) {
   SignalCatcher* signal_catcher = reinterpret_cast<SignalCatcher*>(arg);
   CHECK(signal_catcher != nullptr);

   Runtime* runtime = Runtime::Current();
   CHECK(runtime->AttachCurrentThread("Signal Catcher", true, runtime->GetSystemThreadGroup(),
                                      !runtime->IsAotCompiler()));

   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 nullptr;
     }

     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
	/*
	* 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 <sstream>

	#include <android-base/stringprintf.h>

	#if defined(ART_TARGET_ANDROID)
	#include <tombstoned/tombstoned.h>
	#endif

	#include "arch/instruction_set.h"
	#include "base/file_utils.h"
	#include "base/time_utils.h"
	#include "base/unix_file/fd_file.h"
	#include "class_linker.h"
	#include "gc/heap.h"
	#include "jit/profile_saver.h"
	#include "os.h"
	#include "runtime.h"
	#include "scoped_thread_state_change-inl.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", &current_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 != nullptr && 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,
	bool use_tombstoned_stack_trace_fd)
	: stack_trace_file_(stack_trace_file),
	use_tombstoned_stack_trace_fd_(use_tombstoned_stack_trace_fd),
	lock_("SignalCatcher lock"),
	cond_("SignalCatcher::cond_", lock_),
	thread_(nullptr) {
	#if !defined(ART_TARGET_ANDROID)
	// We're not running on Android, so we can't communicate with tombstoned
	// to ask for an open file.
	CHECK(!use_tombstoned_stack_trace_fd_);
	#endif

	SetHaltFlag(false);

	// Create a raw pthread; its start routine will attach to the runtime.
	CHECK_PTHREAD_CALL(pthread_create, (&pthread_, nullptr, &Run, this), "signal catcher thread");

	Thread* self = Thread::Current();
	MutexLock mu(self, lock_);
	while (thread_ == nullptr) {
	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_, nullptr), "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_;
	}

	bool SignalCatcher::OpenStackTraceFile(android::base::unique_fd* tombstone_fd,
	android::base::unique_fd* output_fd) {
	if (use_tombstoned_stack_trace_fd_) {
	#if defined(ART_TARGET_ANDROID)
	return tombstoned_connect(getpid(), tombstone_fd, output_fd, kDebuggerdJavaBacktrace);
	#else
	UNUSED(tombstone_fd);
	UNUSED(output_fd);
	#endif
	}

	// The runtime is not configured to dump traces to a file, will LOG(INFO)
	// instead.
	if (stack_trace_file_.empty()) {
	return false;
	}

	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 false;
	}

	output_fd->reset(fd);
	return true;
	}

	void SignalCatcher::Output(const std::string& s) {
	android::base::unique_fd tombstone_fd;
	android::base::unique_fd output_fd;
	if (!OpenStackTraceFile(&tombstone_fd, &output_fd)) {
	LOG(INFO) << s;
	return;
	}

	ScopedThreadStateChange tsc(Thread::Current(), kWaitingForSignalCatcherOutput);

	std::unique_ptr<File> file(new File(output_fd.release(), true /* check_usage */));
	bool success = file->WriteFully(s.data(), s.size());
	if (success) {
	success = file->FlushCloseOrErase() == 0;
	} else {
	file->Erase();
	}

	const std::string output_path_msg = (use_tombstoned_stack_trace_fd_) ?
	"[tombstoned]" : stack_trace_file_;

	if (success) {
	LOG(INFO) << "Wrote stack traces to '" << output_path_msg << "'";
	} else {
	PLOG(ERROR) << "Failed to write stack traces to '" << output_path_msg << "'";
	}

	#if defined(ART_TARGET_ANDROID)
	if (use_tombstoned_stack_trace_fd_ && !tombstoned_notify_completion(tombstone_fd)) {
	PLOG(WARNING) << "Unable to notify tombstoned of dump completion";
	}
	#endif
	}

	void SignalCatcher::HandleSigQuit() {
	Runtime* runtime = Runtime::Current();
	std::ostringstream os;
	os << "\n"
	<< "----- pid " << getpid() << " at " << GetIsoDate() << " -----\n";

	DumpCmdLine(os);

	// Note: The strings "Build fingerprint:" and "ABI:" are chosen to match the format used by
	// debuggerd. This allows, for example, the stack tool to work.
	std::string fingerprint = runtime->GetFingerprint();
	os << "Build fingerprint: '" << (fingerprint.empty() ? "unknown" : fingerprint) << "'\n";
	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";
	Output(os.str());
	}

	void SignalCatcher::HandleSigUsr1() {
	LOG(INFO) << "SIGUSR1 forcing GC (no HPROF) and profile save";
	Runtime::Current()->GetHeap()->CollectGarbage(false);
	ProfileSaver::ForceProcessProfiles();
	}

	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_STREAM(INFO));
	}

	return signal_number;
	}

	void* SignalCatcher::Run(void* arg) {
	SignalCatcher* signal_catcher = reinterpret_cast<SignalCatcher*>(arg);
	CHECK(signal_catcher != nullptr);

	Runtime* runtime = Runtime::Current();
	CHECK(runtime->AttachCurrentThread("Signal Catcher", true, runtime->GetSystemThreadGroup(),
	!runtime->IsAotCompiler()));

	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 nullptr;
	}

	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