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

--1:000000000000
+:2e7c7ba800f9
+// Copyright (c) 2006, 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.
+#include <mach/exc.h>
+#include <mach/mig.h>
+#include <pthread.h>
+#include <signal.h>
+#include <TargetConditionals.h>
+#include <map>
+#include "client/mac/handler/exception_handler.h"
+#include "client/mac/handler/minidump_generator.h"
+#include "common/mac/macho_utilities.h"
+#include "common/mac/scoped_task_suspend-inl.h"
+#include "google_breakpad/common/minidump_exception_mac.h"
+#ifndef __EXCEPTIONS
+// This file uses C++ try/catch (but shouldn't). Duplicate the macros from
+// <c++/4.2.1/exception_defines.h> allowing this file to work properly with
+// exceptions disabled even when other C++ libraries are used. #undef the try
+// and catch macros first in case libstdc++ is in use and has already provided
+// its own definitions.
+#undef try
+#define try       if (true)
+#undef catch
+#define catch(X)  if (false)
+#endif  // __EXCEPTIONS
+#ifndef USE_PROTECTED_ALLOCATIONS
+#if TARGET_OS_IPHONE
+#define USE_PROTECTED_ALLOCATIONS 1
+#else
+#define USE_PROTECTED_ALLOCATIONS 0
+#endif
+#endif
+// If USE_PROTECTED_ALLOCATIONS is activated then the
+// gBreakpadAllocator needs to be setup in other code
+// ahead of time.  Please see ProtectedMemoryAllocator.h
+// for more details.
+#if USE_PROTECTED_ALLOCATIONS
+#include "protected_memory_allocator.h"
+extern ProtectedMemoryAllocator *gBreakpadAllocator;
+#endif
+namespace google_breakpad {
+static union {
+#if USE_PROTECTED_ALLOCATIONS
+char protected_buffer[PAGE_SIZE] __attribute__((aligned(PAGE_SIZE)));
+#endif
+google_breakpad::ExceptionHandler *handler;
+} gProtectedData;
+using std::map;
+// These structures and techniques are illustrated in
+// Mac OS X Internals, Amit Singh, ch 9.7
+struct ExceptionMessage {
+mach_msg_header_t           header;
+mach_msg_body_t             body;
+mach_msg_port_descriptor_t  thread;
+mach_msg_port_descriptor_t  task;
+NDR_record_t                ndr;
+exception_type_t            exception;
+mach_msg_type_number_t      code_count;
+integer_t                   code[EXCEPTION_CODE_MAX];
+char                        padding[512];
+};
+struct ExceptionParameters {
+ExceptionParameters() : count(0) {}
+mach_msg_type_number_t count;
+exception_mask_t masks[EXC_TYPES_COUNT];
+mach_port_t ports[EXC_TYPES_COUNT];
+exception_behavior_t behaviors[EXC_TYPES_COUNT];
+thread_state_flavor_t flavors[EXC_TYPES_COUNT];
+};
+struct ExceptionReplyMessage {
+mach_msg_header_t  header;
+NDR_record_t       ndr;
+kern_return_t      return_code;
+};
+// Only catch these three exceptions.  The other ones are nebulously defined
+// and may result in treating a non-fatal exception as fatal.
+exception_mask_t s_exception_mask = EXC_MASK_BAD_ACCESS |
+EXC_MASK_BAD_INSTRUCTION | EXC_MASK_ARITHMETIC | EXC_MASK_BREAKPOINT;
+#if !TARGET_OS_IPHONE
+extern "C" {
+// Forward declarations for functions that need "C" style compilation
+boolean_t exc_server(mach_msg_header_t* request,
+mach_msg_header_t* reply);
+// This symbol must be visible to dlsym() - see
+// http://code.google.com/p/google-breakpad/issues/detail?id=345 for details.
+kern_return_t catch_exception_raise(mach_port_t target_port,
+mach_port_t failed_thread,
+mach_port_t task,
+exception_type_t exception,
+exception_data_t code,
+mach_msg_type_number_t code_count)
+__attribute__((visibility("default")));
+}
+#endif
+kern_return_t ForwardException(mach_port_t task,
+mach_port_t failed_thread,
+exception_type_t exception,
+exception_data_t code,
+mach_msg_type_number_t code_count);
+#if TARGET_OS_IPHONE
+// Implementation is based on the implementation generated by mig.
+boolean_t breakpad_exc_server(mach_msg_header_t* InHeadP,
+mach_msg_header_t* OutHeadP) {
+OutHeadP->msgh_bits =
+MACH_MSGH_BITS(MACH_MSGH_BITS_REMOTE(InHeadP->msgh_bits), 0);
+OutHeadP->msgh_remote_port = InHeadP->msgh_remote_port;
+/* Minimal size: routine() will update it if different */
+OutHeadP->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);
+OutHeadP->msgh_local_port = MACH_PORT_NULL;
+OutHeadP->msgh_id = InHeadP->msgh_id + 100;
+if (InHeadP->msgh_id != 2401) {
+((mig_reply_error_t*)OutHeadP)->NDR = NDR_record;
+((mig_reply_error_t*)OutHeadP)->RetCode = MIG_BAD_ID;
+return FALSE;
+}
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+typedef struct {
+mach_msg_header_t Head;
+/* start of the kernel processed data */
+mach_msg_body_t msgh_body;
+mach_msg_port_descriptor_t thread;
+mach_msg_port_descriptor_t task;
+/* end of the kernel processed data */
+NDR_record_t NDR;
+exception_type_t exception;
+mach_msg_type_number_t codeCnt;
+integer_t code[2];
+mach_msg_trailer_t trailer;
+} Request;
+typedef struct {
+mach_msg_header_t Head;
+NDR_record_t NDR;
+kern_return_t RetCode;
+} Reply;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+Request* In0P = (Request*)InHeadP;
+Reply* OutP = (Reply*)OutHeadP;
+if (In0P->task.name != mach_task_self()) {
+return FALSE;
+}
+OutP->RetCode = ForwardException(In0P->task.name,
+In0P->thread.name,
+In0P->exception,
+In0P->code,
+In0P->codeCnt);
+OutP->NDR = NDR_record;
+return TRUE;
+}
+#else
+boolean_t breakpad_exc_server(mach_msg_header_t* request,
+mach_msg_header_t* reply) {
+return exc_server(request, reply);
+}
+// Callback from exc_server()
+kern_return_t catch_exception_raise(mach_port_t port, mach_port_t failed_thread,
+mach_port_t task,
+exception_type_t exception,
+exception_data_t code,
+mach_msg_type_number_t code_count) {
+if (task != mach_task_self()) {
+return KERN_FAILURE;
+}
+return ForwardException(task, failed_thread, exception, code, code_count);
+}
+#endif
+ExceptionHandler::ExceptionHandler(const string &dump_path,
+FilterCallback filter,
+MinidumpCallback callback,
+void* callback_context,
+bool install_handler,
+const char* port_name)
+: dump_path_(),
+filter_(filter),
+callback_(callback),
+callback_context_(callback_context),
+directCallback_(NULL),
+handler_thread_(NULL),
+handler_port_(MACH_PORT_NULL),
+previous_(NULL),
+installed_exception_handler_(false),
+is_in_teardown_(false),
+last_minidump_write_result_(false),
+use_minidump_write_mutex_(false) {
+// This will update to the ID and C-string pointers
+set_dump_path(dump_path);
+MinidumpGenerator::GatherSystemInformation();
+#if !TARGET_OS_IPHONE
+if (port_name)
+crash_generation_client_.reset(new CrashGenerationClient(port_name));
+#endif
+Setup(install_handler);
+}
+// special constructor if we want to bypass minidump writing and
+// simply get a callback with the exception information
+ExceptionHandler::ExceptionHandler(DirectCallback callback,
+void* callback_context,
+bool install_handler)
+: dump_path_(),
+filter_(NULL),
+callback_(NULL),
+callback_context_(callback_context),
+directCallback_(callback),
+handler_thread_(NULL),
+handler_port_(MACH_PORT_NULL),
+previous_(NULL),
+installed_exception_handler_(false),
+is_in_teardown_(false),
+last_minidump_write_result_(false),
+use_minidump_write_mutex_(false) {
+MinidumpGenerator::GatherSystemInformation();
+Setup(install_handler);
+}
+ExceptionHandler::~ExceptionHandler() {
+Teardown();
+}
+bool ExceptionHandler::WriteMinidump(bool write_exception_stream) {
+// If we're currently writing, just return
+if (use_minidump_write_mutex_)
+return false;
+use_minidump_write_mutex_ = true;
+last_minidump_write_result_ = false;
+// Lock the mutex.  Since we just created it, this will return immediately.
+if (pthread_mutex_lock(&minidump_write_mutex_) == 0) {
+// Send an empty message to the handle port so that a minidump will
+// be written
+bool result = SendMessageToHandlerThread(write_exception_stream ?
+kWriteDumpWithExceptionMessage :
+kWriteDumpMessage);
+if (!result) {
+pthread_mutex_unlock(&minidump_write_mutex_);
+return false;
+}
+// Wait for the minidump writer to complete its writing.  It will unlock
+// the mutex when completed
+pthread_mutex_lock(&minidump_write_mutex_);
+}
+use_minidump_write_mutex_ = false;
+UpdateNextID();
+return last_minidump_write_result_;
+}
+// static
+bool ExceptionHandler::WriteMinidump(const string &dump_path,
+bool write_exception_stream,
+MinidumpCallback callback,
+void* callback_context) {
+ExceptionHandler handler(dump_path, NULL, callback, callback_context, false,
+NULL);
+return handler.WriteMinidump(write_exception_stream);
+}
+// static
+bool ExceptionHandler::WriteMinidumpForChild(mach_port_t child,
+mach_port_t child_blamed_thread,
+const string &dump_path,
+MinidumpCallback callback,
+void* callback_context) {
+ScopedTaskSuspend suspend(child);
+MinidumpGenerator generator(child, MACH_PORT_NULL);
+string dump_id;
+string dump_filename = generator.UniqueNameInDirectory(dump_path, &dump_id);
+generator.SetExceptionInformation(EXC_BREAKPOINT,
+#if defined(__i386__) || defined(__x86_64__)
+EXC_I386_BPT,
+#elif defined(__ppc__) || defined(__ppc64__)
+EXC_PPC_BREAKPOINT,
+#elif defined(__arm__)
+EXC_ARM_BREAKPOINT,
+#else
+#error architecture not supported
+#endif
+0,
+child_blamed_thread);
+bool result = generator.Write(dump_filename.c_str());
+if (callback) {
+return callback(dump_path.c_str(), dump_id.c_str(),
+callback_context, result);
+}
+return result;
+}
+bool ExceptionHandler::WriteMinidumpWithException(int exception_type,
+int exception_code,
+int exception_subcode,
+ucontext_t* task_context,
+mach_port_t thread_name,
+bool exit_after_write,
+bool report_current_thread) {
+bool result = false;
+if (directCallback_) {
+if (directCallback_(callback_context_,
+exception_type,
+exception_code,
+exception_subcode,
+thread_name) ) {
+if (exit_after_write)
+_exit(exception_type);
+}
+#if !TARGET_OS_IPHONE
+} else if (IsOutOfProcess()) {
+if (exception_type && exception_code) {
+// If this is a real exception, give the filter (if any) a chance to
+// decide if this should be sent.
+if (filter_ && !filter_(callback_context_))
+return false;
+result = crash_generation_client_->RequestDumpForException(
+exception_type,
+exception_code,
+exception_subcode,
+thread_name);
+if (result && exit_after_write) {
+_exit(exception_type);
+}
+}
+#endif
+} else {
+string minidump_id;
+// Putting the MinidumpGenerator in its own context will ensure that the
+// destructor is executed, closing the newly created minidump file.
+if (!dump_path_.empty()) {
+MinidumpGenerator md(mach_task_self(),
+report_current_thread ? MACH_PORT_NULL :
+mach_thread_self());
+md.SetTaskContext(task_context);
+if (exception_type && exception_code) {
+// If this is a real exception, give the filter (if any) a chance to
+// decide if this should be sent.
+if (filter_ && !filter_(callback_context_))
+return false;
+md.SetExceptionInformation(exception_type, exception_code,
+exception_subcode, thread_name);
+}
+result = md.Write(next_minidump_path_c_);
+}
+// Call user specified callback (if any)
+if (callback_) {
+// If the user callback returned true and we're handling an exception
+// (rather than just writing out the file), then we should exit without
+// forwarding the exception to the next handler.
+if (callback_(dump_path_c_, next_minidump_id_c_, callback_context_,
+result)) {
+if (exit_after_write)
+_exit(exception_type);
+}
+}
+}
+return result;
+}
+kern_return_t ForwardException(mach_port_t task, mach_port_t failed_thread,
+exception_type_t exception,
+exception_data_t code,
+mach_msg_type_number_t code_count) {
+// At this time, we should have called Uninstall() on the exception handler
+// so that the current exception ports are the ones that we should be
+// forwarding to.
+ExceptionParameters current;
+current.count = EXC_TYPES_COUNT;
+mach_port_t current_task = mach_task_self();
+task_get_exception_ports(current_task,
+s_exception_mask,
+current.masks,
+&current.count,
+current.ports,
+current.behaviors,
+current.flavors);
+// Find the first exception handler that matches the exception
+unsigned int found;
+for (found = 0; found < current.count; ++found) {
+if (current.masks[found] & (1 << exception)) {
+break;
+}
+}
+// Nothing to forward
+if (found == current.count) {
+fprintf(stderr, "** No previous ports for forwarding!! \n");
+exit(KERN_FAILURE);
+}
+mach_port_t target_port = current.ports[found];
+exception_behavior_t target_behavior = current.behaviors[found];
+kern_return_t result;
+switch (target_behavior) {
+case EXCEPTION_DEFAULT:
+result = exception_raise(target_port, failed_thread, task, exception,
+code, code_count);
+break;
+default:
+fprintf(stderr, "** Unknown exception behavior: %d\n", target_behavior);
+result = KERN_FAILURE;
+break;
+}
+return result;
+}
+// static
+void* ExceptionHandler::WaitForMessage(void* exception_handler_class) {
+ExceptionHandler* self =
+reinterpret_cast<ExceptionHandler*>(exception_handler_class);
+ExceptionMessage receive;
+// Wait for the exception info
+while (1) {
+receive.header.msgh_local_port = self->handler_port_;
+receive.header.msgh_size = static_cast<mach_msg_size_t>(sizeof(receive));
+kern_return_t result = mach_msg(&(receive.header),
+MACH_RCV_MSG | MACH_RCV_LARGE, 0,
+receive.header.msgh_size,
+self->handler_port_,
+MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+if (result == KERN_SUCCESS) {
+// Uninstall our handler so that we don't get in a loop if the process of
+// writing out a minidump causes an exception.  However, if the exception
+// was caused by a fork'd process, don't uninstall things
+// If the actual exception code is zero, then we're calling this handler
+// in a way that indicates that we want to either exit this thread or
+// generate a minidump
+//
+// While reporting, all threads (except this one) must be suspended
+// to avoid misleading stacks.  If appropriate they will be resumed
+// afterwards.
+if (!receive.exception) {
+// Don't touch self, since this message could have been sent
+// from its destructor.
+if (receive.header.msgh_id == kShutdownMessage)
+return NULL;
+self->SuspendThreads();
+#if USE_PROTECTED_ALLOCATIONS
+if (gBreakpadAllocator)
+gBreakpadAllocator->Unprotect();
+#endif
+mach_port_t thread = MACH_PORT_NULL;
+int exception_type = 0;
+int exception_code = 0;
+if (receive.header.msgh_id == kWriteDumpWithExceptionMessage) {
+thread = receive.thread.name;
+exception_type = EXC_BREAKPOINT;
+#if defined(__i386__) || defined(__x86_64__)
+exception_code = EXC_I386_BPT;
+#elif defined(__ppc__) || defined(__ppc64__)
+exception_code = EXC_PPC_BREAKPOINT;
+#elif defined(__arm__)
+exception_code = EXC_ARM_BREAKPOINT;
+#else
+#error architecture not supported
+#endif
+}
+// Write out the dump and save the result for later retrieval
+self->last_minidump_write_result_ =
+self->WriteMinidumpWithException(exception_type, exception_code,
+0, NULL, thread,
+false, false);
+#if USE_PROTECTED_ALLOCATIONS
+if (gBreakpadAllocator)
+gBreakpadAllocator->Protect();
+#endif
+self->ResumeThreads();
+if (self->use_minidump_write_mutex_)
+pthread_mutex_unlock(&self->minidump_write_mutex_);
+} else {
+// When forking a child process with the exception handler installed,
+// if the child crashes, it will send the exception back to the parent
+// process.  The check for task == self_task() ensures that only
+// exceptions that occur in the parent process are caught and
+// processed.  If the exception was not caused by this task, we
+// still need to call into the exception server and have it return
+// KERN_FAILURE (see catch_exception_raise) in order for the kernel
+// to move onto the host exception handler for the child task
+if (receive.task.name == mach_task_self()) {
+self->SuspendThreads();
+#if USE_PROTECTED_ALLOCATIONS
+if (gBreakpadAllocator)
+gBreakpadAllocator->Unprotect();
+#endif
+int subcode = 0;
+if (receive.exception == EXC_BAD_ACCESS && receive.code_count > 1)
+subcode = receive.code[1];
+// Generate the minidump with the exception data.
+self->WriteMinidumpWithException(receive.exception, receive.code[0],
+subcode, NULL, receive.thread.name,
+true, false);
+#if USE_PROTECTED_ALLOCATIONS
+// This may have become protected again within
+// WriteMinidumpWithException, but it needs to be unprotected for
+// UninstallHandler.
+if (gBreakpadAllocator)
+gBreakpadAllocator->Unprotect();
+#endif
+self->UninstallHandler(true);
+#if USE_PROTECTED_ALLOCATIONS
+if (gBreakpadAllocator)
+gBreakpadAllocator->Protect();
+#endif
+}
+// Pass along the exception to the server, which will setup the
+// message and call catch_exception_raise() and put the return
+// code into the reply.
+ExceptionReplyMessage reply;
+if (!breakpad_exc_server(&receive.header, &reply.header))
+exit(1);
+// Send a reply and exit
+mach_msg(&(reply.header), MACH_SEND_MSG,
+reply.header.msgh_size, 0, MACH_PORT_NULL,
+MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+}
+}
+}
+return NULL;
+}
+// static
+void ExceptionHandler::SignalHandler(int sig, siginfo_t* info, void* uc) {
+#if USE_PROTECTED_ALLOCATIONS
+if (gBreakpadAllocator)
+gBreakpadAllocator->Unprotect();
+#endif
+gProtectedData.handler->WriteMinidumpWithException(
+EXC_SOFTWARE,
+MD_EXCEPTION_CODE_MAC_ABORT,
+0,
+static_cast<ucontext_t*>(uc),
+mach_thread_self(),
+true,
+true);
+#if USE_PROTECTED_ALLOCATIONS
+if (gBreakpadAllocator)
+gBreakpadAllocator->Protect();
+#endif
+}
+bool ExceptionHandler::InstallHandler() {
+// If a handler is already installed, something is really wrong.
+if (gProtectedData.handler != NULL) {
+return false;
+}
+if (!IsOutOfProcess()) {
+struct sigaction sa;
+memset(&sa, 0, sizeof(sa));
+sigemptyset(&sa.sa_mask);
+sigaddset(&sa.sa_mask, SIGABRT);
+sa.sa_sigaction = ExceptionHandler::SignalHandler;
+sa.sa_flags = SA_SIGINFO;
+scoped_ptr<struct sigaction> old(new struct sigaction);
+if (sigaction(SIGABRT, &sa, old.get()) == -1) {
+return false;
+}
+old_handler_.swap(old);
+gProtectedData.handler = this;
+#if USE_PROTECTED_ALLOCATIONS
+assert(((size_t)(gProtectedData.protected_buffer) & PAGE_MASK) == 0);
+mprotect(gProtectedData.protected_buffer, PAGE_SIZE, PROT_READ);
+#endif
+}
+try {
+#if USE_PROTECTED_ALLOCATIONS
+previous_ = new (gBreakpadAllocator->Allocate(sizeof(ExceptionParameters)) )
+ExceptionParameters();
+#else
+previous_ = new ExceptionParameters();
+#endif
+}
+catch (std::bad_alloc) {
+return false;
+}
+// Save the current exception ports so that we can forward to them
+previous_->count = EXC_TYPES_COUNT;
+mach_port_t current_task = mach_task_self();
+kern_return_t result = task_get_exception_ports(current_task,
+s_exception_mask,
+previous_->masks,
+&previous_->count,
+previous_->ports,
+previous_->behaviors,
+previous_->flavors);
+// Setup the exception ports on this task
+if (result == KERN_SUCCESS)
+result = task_set_exception_ports(current_task, s_exception_mask,
+handler_port_, EXCEPTION_DEFAULT,
+THREAD_STATE_NONE);
+installed_exception_handler_ = (result == KERN_SUCCESS);
+return installed_exception_handler_;
+}
+bool ExceptionHandler::UninstallHandler(bool in_exception) {
+kern_return_t result = KERN_SUCCESS;
+if (old_handler_.get()) {
+sigaction(SIGABRT, old_handler_.get(), NULL);
+#if USE_PROTECTED_ALLOCATIONS
+mprotect(gProtectedData.protected_buffer, PAGE_SIZE,
+PROT_READ | PROT_WRITE);
+#endif
+old_handler_.reset();
+gProtectedData.handler = NULL;
+}
+if (installed_exception_handler_) {
+mach_port_t current_task = mach_task_self();
+// Restore the previous ports
+for (unsigned int i = 0; i < previous_->count; ++i) {
+result = task_set_exception_ports(current_task, previous_->masks[i],
+previous_->ports[i],
+previous_->behaviors[i],
+previous_->flavors[i]);
+if (result != KERN_SUCCESS)
+return false;
+}
+// this delete should NOT happen if an exception just occurred!
+if (!in_exception) {
+#if USE_PROTECTED_ALLOCATIONS
+previous_->~ExceptionParameters();
+#else
+delete previous_;
+#endif
+}
+previous_ = NULL;
+installed_exception_handler_ = false;
+}
+return result == KERN_SUCCESS;
+}
+bool ExceptionHandler::Setup(bool install_handler) {
+if (pthread_mutex_init(&minidump_write_mutex_, NULL))
+return false;
+// Create a receive right
+mach_port_t current_task = mach_task_self();
+kern_return_t result = mach_port_allocate(current_task,
+MACH_PORT_RIGHT_RECEIVE,
+&handler_port_);
+// Add send right
+if (result == KERN_SUCCESS)
+result = mach_port_insert_right(current_task, handler_port_, handler_port_,
+MACH_MSG_TYPE_MAKE_SEND);
+if (install_handler && result == KERN_SUCCESS)
+if (!InstallHandler())
+return false;
+if (result == KERN_SUCCESS) {
+// Install the handler in its own thread, detached as we won't be joining.
+pthread_attr_t attr;
+pthread_attr_init(&attr);
+pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+int thread_create_result = pthread_create(&handler_thread_, &attr,
+&WaitForMessage, this);
+pthread_attr_destroy(&attr);
+result = thread_create_result ? KERN_FAILURE : KERN_SUCCESS;
+}
+return result == KERN_SUCCESS;
+}
+bool ExceptionHandler::Teardown() {
+kern_return_t result = KERN_SUCCESS;
+is_in_teardown_ = true;
+if (!UninstallHandler(false))
+return false;
+// Send an empty message so that the handler_thread exits
+if (SendMessageToHandlerThread(kShutdownMessage)) {
+mach_port_t current_task = mach_task_self();
+result = mach_port_deallocate(current_task, handler_port_);
+if (result != KERN_SUCCESS)
+return false;
+} else {
+return false;
+}
+handler_thread_ = NULL;
+handler_port_ = MACH_PORT_NULL;
+pthread_mutex_destroy(&minidump_write_mutex_);
+return result == KERN_SUCCESS;
+}
+bool ExceptionHandler::SendMessageToHandlerThread(
+HandlerThreadMessage message_id) {
+ExceptionMessage msg;
+memset(&msg, 0, sizeof(msg));
+msg.header.msgh_id = message_id;
+if (message_id == kWriteDumpMessage ||
+message_id == kWriteDumpWithExceptionMessage) {
+// Include this thread's port.
+msg.thread.name = mach_thread_self();
+msg.thread.disposition = MACH_MSG_TYPE_PORT_SEND;
+msg.thread.type = MACH_MSG_PORT_DESCRIPTOR;
+}
+msg.header.msgh_size = sizeof(msg) - sizeof(msg.padding);
+msg.header.msgh_remote_port = handler_port_;
+msg.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND,
+MACH_MSG_TYPE_MAKE_SEND_ONCE);
+kern_return_t result = mach_msg(&(msg.header),
+MACH_SEND_MSG | MACH_SEND_TIMEOUT,
+msg.header.msgh_size, 0, 0,
+MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+return result == KERN_SUCCESS;
+}
+void ExceptionHandler::UpdateNextID() {
+next_minidump_path_ =
+(MinidumpGenerator::UniqueNameInDirectory(dump_path_, &next_minidump_id_));
+next_minidump_path_c_ = next_minidump_path_.c_str();
+next_minidump_id_c_ = next_minidump_id_.c_str();
+}
+bool ExceptionHandler::SuspendThreads() {
+thread_act_port_array_t   threads_for_task;
+mach_msg_type_number_t    thread_count;
+if (task_threads(mach_task_self(), &threads_for_task, &thread_count))
+return false;
+// suspend all of the threads except for this one
+for (unsigned int i = 0; i < thread_count; ++i) {
+if (threads_for_task[i] != mach_thread_self()) {
+if (thread_suspend(threads_for_task[i]))
+return false;
+}
+}
+return true;
+}
+bool ExceptionHandler::ResumeThreads() {
+thread_act_port_array_t   threads_for_task;
+mach_msg_type_number_t    thread_count;
+if (task_threads(mach_task_self(), &threads_for_task, &thread_count))
+return false;
+// resume all of the threads except for this one
+for (unsigned int i = 0; i < thread_count; ++i) {
+if (threads_for_task[i] != mach_thread_self()) {
+if (thread_resume(threads_for_task[i]))
+return false;
+}
+}
+return true;
+}
+}  // namespace google_breakpad

The Tor Browser / file comparison

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

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