The Tor Browser: comparison toolkit/crashreporter/google-breakpad/src/client/solaris/handler/exception

--1:000000000000
+:461fdf1f90ee
+// Copyright (c) 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Author: Alfred Peng
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <cassert>
+#include <cstdlib>
+#include <ctime>
+#include "client/solaris/handler/exception_handler.h"
+#include "common/solaris/guid_creator.h"
+#include "common/solaris/message_output.h"
+#include "google_breakpad/common/minidump_format.h"
+namespace google_breakpad {
+// Signals that we are interested.
+static const int kSigTable[] = {
+SIGSEGV,
+SIGABRT,
+SIGFPE,
+SIGILL,
+SIGBUS
+};
+std::vector<ExceptionHandler*> *ExceptionHandler::handler_stack_ = NULL;
+int ExceptionHandler::handler_stack_index_ = 0;
+pthread_mutex_t ExceptionHandler::handler_stack_mutex_ =
+PTHREAD_MUTEX_INITIALIZER;
+ExceptionHandler::ExceptionHandler(const string &dump_path,
+FilterCallback filter,
+MinidumpCallback callback,
+void *callback_context,
+bool install_handler)
+: filter_(filter),
+callback_(callback),
+callback_context_(callback_context),
+dump_path_(),
+installed_handler_(install_handler) {
+set_dump_path(dump_path);
+if (install_handler) {
+SetupHandler();
+}
+if (install_handler) {
+pthread_mutex_lock(&handler_stack_mutex_);
+if (handler_stack_ == NULL)
+handler_stack_ = new std::vector<ExceptionHandler *>;
+handler_stack_->push_back(this);
+pthread_mutex_unlock(&handler_stack_mutex_);
+}
+}
+ExceptionHandler::~ExceptionHandler() {
+TeardownAllHandlers();
+pthread_mutex_lock(&handler_stack_mutex_);
+if (handler_stack_->back() == this) {
+handler_stack_->pop_back();
+} else {
+print_message1(2, "warning: removing Breakpad handler out of order\n");
+for (std::vector<ExceptionHandler *>::iterator iterator =
+handler_stack_->begin();
+iterator != handler_stack_->end();
+++iterator) {
+if (*iterator == this) {
+handler_stack_->erase(iterator);
+}
+}
+}
+if (handler_stack_->empty()) {
+// When destroying the last ExceptionHandler that installed a handler,
+// clean up the handler stack.
+delete handler_stack_;
+handler_stack_ = NULL;
+}
+pthread_mutex_unlock(&handler_stack_mutex_);
+}
+bool ExceptionHandler::WriteMinidump() {
+return InternalWriteMinidump(0, 0, NULL);
+}
+// static
+bool ExceptionHandler::WriteMinidump(const string &dump_path,
+MinidumpCallback callback,
+void *callback_context) {
+ExceptionHandler handler(dump_path, NULL, callback,
+callback_context, false);
+return handler.InternalWriteMinidump(0, 0, NULL);
+}
+void ExceptionHandler::SetupHandler() {
+// Signal on a different stack to avoid using the stack
+// of the crashing lwp.
+struct sigaltstack sig_stack;
+sig_stack.ss_sp = malloc(MINSIGSTKSZ);
+if (sig_stack.ss_sp == NULL)
+return;
+sig_stack.ss_size = MINSIGSTKSZ;
+sig_stack.ss_flags = 0;
+if (sigaltstack(&sig_stack, NULL) < 0)
+return;
+for (size_t i = 0; i < sizeof(kSigTable) / sizeof(kSigTable[0]); ++i)
+SetupHandler(kSigTable[i]);
+}
+void ExceptionHandler::SetupHandler(int signo) {
+struct sigaction act, old_act;
+act.sa_handler = HandleException;
+act.sa_flags = SA_ONSTACK;
+if (sigaction(signo, &act, &old_act) < 0)
+return;
+old_handlers_[signo] = old_act.sa_handler;
+}
+void ExceptionHandler::TeardownHandler(int signo) {
+if (old_handlers_.find(signo) != old_handlers_.end()) {
+struct sigaction act;
+act.sa_handler = old_handlers_[signo];
+act.sa_flags = 0;
+sigaction(signo, &act, 0);
+}
+}
+void ExceptionHandler::TeardownAllHandlers() {
+for (size_t i = 0; i < sizeof(kSigTable) / sizeof(kSigTable[0]); ++i) {
+TeardownHandler(kSigTable[i]);
+}
+}
+// static
+void ExceptionHandler::HandleException(int signo) {
+//void ExceptionHandler::HandleException(int signo, siginfo_t *sip, ucontext_t *sig_ctx) {
+// The context information about the signal is put on the stack of
+// the signal handler frame as value parameter. For some reasons, the
+// prototype of the handler doesn't declare this information as parameter, we
+// will do it by hand. The stack layout for a signal handler frame is here:
+// http://src.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/lib/libproc/common/Pstack.c#81
+//
+// However, if we are being called by another signal handler passing the
+// signal up the chain, then we may not have this random extra parameter,
+// so we may have to walk the stack to find it.  We do the actual work
+// on another thread, where it's a little safer, but we want the ebp
+// from this frame to find it.
+uintptr_t current_ebp = (uintptr_t)_getfp();
+pthread_mutex_lock(&handler_stack_mutex_);
+ExceptionHandler *current_handler =
+handler_stack_->at(handler_stack_->size() - ++handler_stack_index_);
+pthread_mutex_unlock(&handler_stack_mutex_);
+// Restore original handler.
+current_handler->TeardownHandler(signo);
+ucontext_t *sig_ctx = NULL;
+if (current_handler->InternalWriteMinidump(signo, current_ebp, &sig_ctx)) {
+//  if (current_handler->InternalWriteMinidump(signo, &sig_ctx)) {
+// Fully handled this exception, safe to exit.
+exit(EXIT_FAILURE);
+} else {
+// Exception not fully handled, will call the next handler in stack to
+// process it.
+typedef void (*SignalHandler)(int signo);
+SignalHandler old_handler =
+reinterpret_cast<SignalHandler>(current_handler->old_handlers_[signo]);
+if (old_handler != NULL)
+old_handler(signo);
+}
+pthread_mutex_lock(&handler_stack_mutex_);
+current_handler->SetupHandler(signo);
+--handler_stack_index_;
+// All the handlers in stack have been invoked to handle the exception,
+// normally the process should be terminated and should not reach here.
+// In case we got here, ask the OS to handle it to avoid endless loop,
+// normally the OS will generate a core and termiate the process. This
+// may be desired to debug the program.
+if (handler_stack_index_ == 0)
+signal(signo, SIG_DFL);
+pthread_mutex_unlock(&handler_stack_mutex_);
+}
+bool ExceptionHandler::InternalWriteMinidump(int signo,
+uintptr_t sighandler_ebp,
+ucontext_t **sig_ctx) {
+if (filter_ && !filter_(callback_context_))
+return false;
+bool success = false;
+GUID guid;
+char guid_str[kGUIDStringLength + 1];
+if (CreateGUID(&guid) && GUIDToString(&guid, guid_str, sizeof(guid_str))) {
+char minidump_path[PATH_MAX];
+snprintf(minidump_path, sizeof(minidump_path), "%s/%s.dmp",
+dump_path_c_, guid_str);
+// Block all the signals we want to process when writing minidump.
+// We don't want it to be interrupted.
+sigset_t sig_blocked, sig_old;
+bool blocked = true;
+sigfillset(&sig_blocked);
+for (size_t i = 0; i < sizeof(kSigTable) / sizeof(kSigTable[0]); ++i)
+sigdelset(&sig_blocked, kSigTable[i]);
+if (sigprocmask(SIG_BLOCK, &sig_blocked, &sig_old) != 0) {
+blocked = false;
+print_message1(2, "HandleException: failed to block signals.\n");
+}
+success = minidump_generator_.WriteMinidumpToFile(
+minidump_path, signo, sighandler_ebp, sig_ctx);
+// Unblock the signals.
+if (blocked)
+sigprocmask(SIG_SETMASK, &sig_old, &sig_old);
+if (callback_)
+success = callback_(dump_path_c_, guid_str, callback_context_, success);
+}
+return success;
+}
+}  // namespace google_breakpad

The Tor Browser / file comparison

comparison: toolkit/crashreporter/google-breakpad/src/client/solaris/handler/exception_handler.cc

toolkit/crashreporter/google-breakpad/src/client/solaris/handler/exception_handler.cc