mirror of
https://github.com/chromium/crashpad.git
synced 2024-12-31 01:43:03 +08:00
9086d25ce8
CrashReportExceptionHandler::CatchMachException() must always set a
valid new_state. Failing to do so appears to trigger corpse generation
on OS X 10.11. This is addressed by calling ExcServerCopyState().
Previously, this was not done for exceptions forwarded to the user
ReportCrash, under the apparent mistaken assumption that ReportCrash
would do it. However, ReportCrash is given copies of out-parameters like
new_state to explicitly prevent it from influencing Crashpad’s returned
state.
ExcServerSuccessfulReturnValue() must not return MACH_RCV_PORT_DIED for
an EXC_CRASH handler on OS X 10.11. This appears to trigger corpse
generation. This is addressed by always returning KERN_SUCCESS from
EXC_CRASH handlers on OS X 10.11.
This also adds generic EXC_CORPSE_NOTIFY support throughout Crashpad.
The crashpad_handler does not listen for this exception type, but it is
now possible to work with this exception type using tools like
exception_port_tool and catch_exception_tool.
BUG=crashpad:48
TEST=Crashes handled by crashpad_handler do not result in the generation
of reports in the root /Library/Logs/DiagnosticReports.
R=kerrnel@chromium.org, rsesek@chromium.org
Review URL: https://codereview.chromium.org/1305893010 .
802 lines
31 KiB
C++
802 lines
31 KiB
C++
// Copyright 2014 The Crashpad Authors. All rights reserved.
|
||
//
|
||
// 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 "util/mach/exc_server_variants.h"
|
||
|
||
#include <AvailabilityMacros.h>
|
||
#include <string.h>
|
||
|
||
#include <algorithm>
|
||
#include <vector>
|
||
|
||
#include "base/logging.h"
|
||
#include "util/mac/mac_util.h"
|
||
#include "util/mach/composite_mach_message_server.h"
|
||
#include "util/mach/exc.h"
|
||
#include "util/mach/exception_behaviors.h"
|
||
#include "util/mach/excServer.h"
|
||
#include "util/mach/mach_exc.h"
|
||
#include "util/mach/mach_excServer.h"
|
||
#include "util/mach/mach_message.h"
|
||
|
||
extern "C" {
|
||
|
||
// These six functions are not used, and are in fact obsoleted by the other
|
||
// functionality implemented in this file. The standard MIG-generated exc_server
|
||
// (in excServer.c) and mach_exc_server (in mach_excServer.c) server dispatch
|
||
// routines usable with the standard mach_msg_server() function call out to
|
||
// these functions. exc_server() and mach_exc_server() are unused and are
|
||
// replaced by the more flexible ExcServer and MachExcServer, but the linker
|
||
// still needs to see these six function definitions.
|
||
|
||
kern_return_t catch_exception_raise(exception_handler_t exception_port,
|
||
thread_t thread,
|
||
task_t task,
|
||
exception_type_t exception,
|
||
exception_data_t code,
|
||
mach_msg_type_number_t code_count) {
|
||
NOTREACHED();
|
||
return KERN_FAILURE;
|
||
}
|
||
|
||
kern_return_t catch_exception_raise_state(
|
||
exception_handler_t exception_port,
|
||
exception_type_t exception,
|
||
exception_data_t code,
|
||
mach_msg_type_number_t code_count,
|
||
thread_state_flavor_t* flavor,
|
||
thread_state_t old_state,
|
||
mach_msg_type_number_t old_state_count,
|
||
thread_state_t new_state,
|
||
mach_msg_type_number_t* new_state_count) {
|
||
NOTREACHED();
|
||
return KERN_FAILURE;
|
||
}
|
||
|
||
kern_return_t catch_exception_raise_state_identity(
|
||
exception_handler_t exception_port,
|
||
thread_t thread,
|
||
task_t task,
|
||
exception_type_t exception,
|
||
exception_data_t code,
|
||
mach_msg_type_number_t code_count,
|
||
thread_state_flavor_t* flavor,
|
||
thread_state_t old_state,
|
||
mach_msg_type_number_t old_state_count,
|
||
thread_state_t new_state,
|
||
mach_msg_type_number_t* new_state_count) {
|
||
NOTREACHED();
|
||
return KERN_FAILURE;
|
||
}
|
||
|
||
kern_return_t catch_mach_exception_raise(exception_handler_t exception_port,
|
||
thread_t thread,
|
||
task_t task,
|
||
exception_type_t exception,
|
||
mach_exception_data_t code,
|
||
mach_msg_type_number_t code_count) {
|
||
NOTREACHED();
|
||
return KERN_FAILURE;
|
||
}
|
||
|
||
kern_return_t catch_mach_exception_raise_state(
|
||
exception_handler_t exception_port,
|
||
exception_type_t exception,
|
||
mach_exception_data_t code,
|
||
mach_msg_type_number_t code_count,
|
||
thread_state_flavor_t* flavor,
|
||
thread_state_t old_state,
|
||
mach_msg_type_number_t old_state_count,
|
||
thread_state_t new_state,
|
||
mach_msg_type_number_t* new_state_count) {
|
||
NOTREACHED();
|
||
return KERN_FAILURE;
|
||
}
|
||
|
||
kern_return_t catch_mach_exception_raise_state_identity(
|
||
exception_handler_t exception_port,
|
||
thread_t thread,
|
||
task_t task,
|
||
exception_type_t exception,
|
||
mach_exception_data_t code,
|
||
mach_msg_type_number_t code_count,
|
||
thread_state_flavor_t* flavor,
|
||
thread_state_t old_state,
|
||
mach_msg_type_number_t old_state_count,
|
||
thread_state_t new_state,
|
||
mach_msg_type_number_t* new_state_count) {
|
||
NOTREACHED();
|
||
return KERN_FAILURE;
|
||
}
|
||
|
||
} // extern "C"
|
||
|
||
namespace crashpad {
|
||
|
||
namespace {
|
||
|
||
// Traits for ExcServer<> and SimplifiedExcServer<> adapting them for use with
|
||
// the exc subsystem.
|
||
struct ExcTraits {
|
||
using ExceptionCode = exception_data_type_t;
|
||
|
||
using RequestUnion = __RequestUnion__exc_subsystem;
|
||
using ReplyUnion = __ReplyUnion__exc_subsystem;
|
||
|
||
using ExceptionRaiseRequest = __Request__exception_raise_t;
|
||
using ExceptionRaiseStateRequest = __Request__exception_raise_state_t;
|
||
using ExceptionRaiseStateIdentityRequest =
|
||
__Request__exception_raise_state_identity_t;
|
||
|
||
using ExceptionRaiseReply = __Reply__exception_raise_t;
|
||
using ExceptionRaiseStateReply = __Reply__exception_raise_state_t;
|
||
using ExceptionRaiseStateIdentityReply =
|
||
__Reply__exception_raise_state_identity_t;
|
||
|
||
// The MIG-generated __MIG_check__Request__*() functions are not declared as
|
||
// accepting const data, but they could have been because they in fact do not
|
||
// modify the data.
|
||
|
||
static kern_return_t MIGCheckRequestExceptionRaise(
|
||
const ExceptionRaiseRequest* in_request) {
|
||
return __MIG_check__Request__exception_raise_t(
|
||
const_cast<ExceptionRaiseRequest*>(in_request));
|
||
}
|
||
|
||
static kern_return_t MIGCheckRequestExceptionRaiseState(
|
||
const ExceptionRaiseStateRequest* in_request,
|
||
const ExceptionRaiseStateRequest** in_request_1) {
|
||
return __MIG_check__Request__exception_raise_state_t(
|
||
const_cast<ExceptionRaiseStateRequest*>(in_request),
|
||
const_cast<ExceptionRaiseStateRequest**>(in_request_1));
|
||
}
|
||
|
||
static kern_return_t MIGCheckRequestExceptionRaiseStateIdentity(
|
||
const ExceptionRaiseStateIdentityRequest* in_request,
|
||
const ExceptionRaiseStateIdentityRequest** in_request_1) {
|
||
return __MIG_check__Request__exception_raise_state_identity_t(
|
||
const_cast<ExceptionRaiseStateIdentityRequest*>(in_request),
|
||
const_cast<ExceptionRaiseStateIdentityRequest**>(in_request_1));
|
||
}
|
||
|
||
// There are no predefined constants for these.
|
||
static const mach_msg_id_t kMachMessageIDExceptionRaise = 2401;
|
||
static const mach_msg_id_t kMachMessageIDExceptionRaiseState = 2402;
|
||
static const mach_msg_id_t kMachMessageIDExceptionRaiseStateIdentity = 2403;
|
||
|
||
static const exception_behavior_t kExceptionBehavior = 0;
|
||
};
|
||
|
||
// Traits for ExcServer<> and SimplifiedExcServer<> adapting them for use with
|
||
// the mach_exc subsystem.
|
||
struct MachExcTraits {
|
||
using ExceptionCode = mach_exception_data_type_t;
|
||
|
||
using RequestUnion = __RequestUnion__mach_exc_subsystem;
|
||
using ReplyUnion = __ReplyUnion__mach_exc_subsystem;
|
||
|
||
using ExceptionRaiseRequest = __Request__mach_exception_raise_t;
|
||
using ExceptionRaiseStateRequest = __Request__mach_exception_raise_state_t;
|
||
using ExceptionRaiseStateIdentityRequest =
|
||
__Request__mach_exception_raise_state_identity_t;
|
||
|
||
using ExceptionRaiseReply = __Reply__mach_exception_raise_t;
|
||
using ExceptionRaiseStateReply = __Reply__mach_exception_raise_state_t;
|
||
using ExceptionRaiseStateIdentityReply =
|
||
__Reply__mach_exception_raise_state_identity_t;
|
||
|
||
// The MIG-generated __MIG_check__Request__*() functions are not declared as
|
||
// accepting const data, but they could have been because they in fact do not
|
||
// modify the data.
|
||
|
||
static kern_return_t MIGCheckRequestExceptionRaise(
|
||
const ExceptionRaiseRequest* in_request) {
|
||
return __MIG_check__Request__mach_exception_raise_t(
|
||
const_cast<ExceptionRaiseRequest*>(in_request));
|
||
}
|
||
|
||
static kern_return_t MIGCheckRequestExceptionRaiseState(
|
||
const ExceptionRaiseStateRequest* in_request,
|
||
const ExceptionRaiseStateRequest** in_request_1) {
|
||
return __MIG_check__Request__mach_exception_raise_state_t(
|
||
const_cast<ExceptionRaiseStateRequest*>(in_request),
|
||
const_cast<ExceptionRaiseStateRequest**>(in_request_1));
|
||
}
|
||
|
||
static kern_return_t MIGCheckRequestExceptionRaiseStateIdentity(
|
||
const ExceptionRaiseStateIdentityRequest* in_request,
|
||
const ExceptionRaiseStateIdentityRequest** in_request_1) {
|
||
return __MIG_check__Request__mach_exception_raise_state_identity_t(
|
||
const_cast<ExceptionRaiseStateIdentityRequest*>(in_request),
|
||
const_cast<ExceptionRaiseStateIdentityRequest**>(in_request_1));
|
||
}
|
||
|
||
// There are no predefined constants for these.
|
||
static const mach_msg_id_t kMachMessageIDExceptionRaise = 2405;
|
||
static const mach_msg_id_t kMachMessageIDExceptionRaiseState = 2406;
|
||
static const mach_msg_id_t kMachMessageIDExceptionRaiseStateIdentity = 2407;
|
||
|
||
static const exception_behavior_t kExceptionBehavior = MACH_EXCEPTION_CODES;
|
||
};
|
||
|
||
//! \brief A server interface for the `exc` or `mach_exc` Mach subsystems.
|
||
template <typename Traits>
|
||
class ExcServer : public MachMessageServer::Interface {
|
||
public:
|
||
//! \brief An interface that the different request messages that are a part of
|
||
//! the `exc` or `mach_exc` Mach subsystems can be dispatched to.
|
||
class Interface {
|
||
public:
|
||
//! \brief Handles exceptions raised by `exception_raise()` or
|
||
//! `mach_exception_raise()`.
|
||
//!
|
||
//! This behaves equivalently to a `catch_exception_raise()` function used
|
||
//! with `exc_server()`, or a `catch_mach_exception_raise()` function used
|
||
//! with `mach_exc_server()`.
|
||
//!
|
||
//! \param[in] trailer The trailer received with the request message.
|
||
//! \param[out] destroy_request `true` if the request message is to be
|
||
//! destroyed even when this method returns success. See
|
||
//! MachMessageServer::Interface.
|
||
virtual kern_return_t CatchExceptionRaise(
|
||
exception_handler_t exception_port,
|
||
thread_t thread,
|
||
task_t task,
|
||
exception_type_t exception,
|
||
const typename Traits::ExceptionCode* code,
|
||
mach_msg_type_number_t code_count,
|
||
const mach_msg_trailer_t* trailer,
|
||
bool* destroy_request) = 0;
|
||
|
||
//! \brief Handles exceptions raised by `exception_raise_state()` or
|
||
//! `mach_exception_raise_state()`.
|
||
//!
|
||
//! This behaves equivalently to a `catch_exception_raise_state()` function
|
||
//! used with `exc_server()`, or a `catch_mach_exception_raise_state()`
|
||
//! function used with `mach_exc_server()`.
|
||
//!
|
||
//! There is no \a destroy_request parameter because, unlike
|
||
//! CatchExceptionRaise() and CatchExceptionRaiseStateIdentity(), the
|
||
//! request message is not complex (it does not carry the \a thread or \a
|
||
//! task port rights) and thus there is nothing to destroy.
|
||
//!
|
||
//! \param[in] trailer The trailer received with the request message.
|
||
virtual kern_return_t CatchExceptionRaiseState(
|
||
exception_handler_t exception_port,
|
||
exception_type_t exception,
|
||
const typename Traits::ExceptionCode* code,
|
||
mach_msg_type_number_t code_count,
|
||
thread_state_flavor_t* flavor,
|
||
ConstThreadState old_state,
|
||
mach_msg_type_number_t old_state_count,
|
||
thread_state_t new_state,
|
||
mach_msg_type_number_t* new_state_count,
|
||
const mach_msg_trailer_t* trailer) = 0;
|
||
|
||
//! \brief Handles exceptions raised by `exception_raise_state_identity()`
|
||
//! or `mach_exception_raise_state_identity()`.
|
||
//!
|
||
//! This behaves equivalently to a `catch_exception_raise_state_identity()`
|
||
//! function used with `exc_server()`, or a
|
||
//! `catch_mach_exception_raise_state_identity()` function used with
|
||
//! `mach_exc_server()`.
|
||
//!
|
||
//! \param[in] trailer The trailer received with the request message.
|
||
//! \param[out] destroy_request `true` if the request message is to be
|
||
//! destroyed even when this method returns success. See
|
||
//! MachMessageServer::Interface.
|
||
virtual kern_return_t CatchExceptionRaiseStateIdentity(
|
||
exception_handler_t exception_port,
|
||
thread_t thread,
|
||
task_t task,
|
||
exception_type_t exception,
|
||
const typename Traits::ExceptionCode* code,
|
||
mach_msg_type_number_t code_count,
|
||
thread_state_flavor_t* flavor,
|
||
ConstThreadState old_state,
|
||
mach_msg_type_number_t old_state_count,
|
||
thread_state_t new_state,
|
||
mach_msg_type_number_t* new_state_count,
|
||
const mach_msg_trailer_t* trailer,
|
||
bool* destroy_request) = 0;
|
||
|
||
protected:
|
||
~Interface() {}
|
||
};
|
||
|
||
//! \brief Constructs an object of this class.
|
||
//!
|
||
//! \param[in] interface The interface to dispatch requests to. Weak.
|
||
explicit ExcServer(Interface* interface)
|
||
: MachMessageServer::Interface(), interface_(interface) {}
|
||
|
||
// MachMessageServer::Interface:
|
||
|
||
bool MachMessageServerFunction(const mach_msg_header_t* in_header,
|
||
mach_msg_header_t* out_header,
|
||
bool* destroy_complex_request) override;
|
||
|
||
std::set<mach_msg_id_t> MachMessageServerRequestIDs() override {
|
||
const mach_msg_id_t request_ids[] = {
|
||
Traits::kMachMessageIDExceptionRaise,
|
||
Traits::kMachMessageIDExceptionRaiseState,
|
||
Traits::kMachMessageIDExceptionRaiseStateIdentity,
|
||
};
|
||
return std::set<mach_msg_id_t>(&request_ids[0],
|
||
&request_ids[arraysize(request_ids)]);
|
||
}
|
||
|
||
mach_msg_size_t MachMessageServerRequestSize() override {
|
||
return sizeof(typename Traits::RequestUnion);
|
||
}
|
||
|
||
mach_msg_size_t MachMessageServerReplySize() override {
|
||
return sizeof(typename Traits::ReplyUnion);
|
||
}
|
||
|
||
private:
|
||
Interface* interface_; // weak
|
||
|
||
DISALLOW_COPY_AND_ASSIGN(ExcServer);
|
||
};
|
||
|
||
template <typename Traits>
|
||
bool ExcServer<Traits>::MachMessageServerFunction(
|
||
const mach_msg_header_t* in_header,
|
||
mach_msg_header_t* out_header,
|
||
bool* destroy_complex_request) {
|
||
PrepareMIGReplyFromRequest(in_header, out_header);
|
||
|
||
const mach_msg_trailer_t* in_trailer =
|
||
MachMessageTrailerFromHeader(in_header);
|
||
|
||
switch (in_header->msgh_id) {
|
||
case Traits::kMachMessageIDExceptionRaise: {
|
||
// exception_raise(), catch_exception_raise(), mach_exception_raise(),
|
||
// catch_mach_exception_raise().
|
||
using Request = typename Traits::ExceptionRaiseRequest;
|
||
const Request* in_request = reinterpret_cast<const Request*>(in_header);
|
||
kern_return_t kr = Traits::MIGCheckRequestExceptionRaise(in_request);
|
||
if (kr != MACH_MSG_SUCCESS) {
|
||
SetMIGReplyError(out_header, kr);
|
||
return true;
|
||
}
|
||
|
||
using Reply = typename Traits::ExceptionRaiseReply;
|
||
Reply* out_reply = reinterpret_cast<Reply*>(out_header);
|
||
out_reply->RetCode =
|
||
interface_->CatchExceptionRaise(in_header->msgh_local_port,
|
||
in_request->thread.name,
|
||
in_request->task.name,
|
||
in_request->exception,
|
||
in_request->code,
|
||
in_request->codeCnt,
|
||
in_trailer,
|
||
destroy_complex_request);
|
||
if (out_reply->RetCode != KERN_SUCCESS) {
|
||
return true;
|
||
}
|
||
|
||
out_header->msgh_size = sizeof(*out_reply);
|
||
return true;
|
||
}
|
||
|
||
case Traits::kMachMessageIDExceptionRaiseState: {
|
||
// exception_raise_state(), catch_exception_raise_state(),
|
||
// mach_exception_raise_state(), catch_mach_exception_raise_state().
|
||
using Request = typename Traits::ExceptionRaiseStateRequest;
|
||
const Request* in_request = reinterpret_cast<const Request*>(in_header);
|
||
|
||
// in_request_1 is used for the portion of the request after the codes,
|
||
// which in theory can be variable-length. The check function will set it.
|
||
const Request* in_request_1;
|
||
kern_return_t kr =
|
||
Traits::MIGCheckRequestExceptionRaiseState(in_request, &in_request_1);
|
||
if (kr != MACH_MSG_SUCCESS) {
|
||
SetMIGReplyError(out_header, kr);
|
||
return true;
|
||
}
|
||
|
||
using Reply = typename Traits::ExceptionRaiseStateReply;
|
||
Reply* out_reply = reinterpret_cast<Reply*>(out_header);
|
||
out_reply->flavor = in_request_1->flavor;
|
||
out_reply->new_stateCnt = arraysize(out_reply->new_state);
|
||
out_reply->RetCode =
|
||
interface_->CatchExceptionRaiseState(in_header->msgh_local_port,
|
||
in_request->exception,
|
||
in_request->code,
|
||
in_request->codeCnt,
|
||
&out_reply->flavor,
|
||
in_request_1->old_state,
|
||
in_request_1->old_stateCnt,
|
||
out_reply->new_state,
|
||
&out_reply->new_stateCnt,
|
||
in_trailer);
|
||
if (out_reply->RetCode != KERN_SUCCESS) {
|
||
return true;
|
||
}
|
||
|
||
out_header->msgh_size =
|
||
sizeof(*out_reply) - sizeof(out_reply->new_state) +
|
||
sizeof(out_reply->new_state[0]) * out_reply->new_stateCnt;
|
||
return true;
|
||
}
|
||
|
||
case Traits::kMachMessageIDExceptionRaiseStateIdentity: {
|
||
// exception_raise_state_identity(),
|
||
// catch_exception_raise_state_identity(),
|
||
// mach_exception_raise_state_identity(),
|
||
// catch_mach_exception_raise_state_identity().
|
||
using Request = typename Traits::ExceptionRaiseStateIdentityRequest;
|
||
const Request* in_request = reinterpret_cast<const Request*>(in_header);
|
||
|
||
// in_request_1 is used for the portion of the request after the codes,
|
||
// which in theory can be variable-length. The check function will set it.
|
||
const Request* in_request_1;
|
||
kern_return_t kr = Traits::MIGCheckRequestExceptionRaiseStateIdentity(
|
||
in_request, &in_request_1);
|
||
if (kr != MACH_MSG_SUCCESS) {
|
||
SetMIGReplyError(out_header, kr);
|
||
return true;
|
||
}
|
||
|
||
using Reply = typename Traits::ExceptionRaiseStateIdentityReply;
|
||
Reply* out_reply = reinterpret_cast<Reply*>(out_header);
|
||
out_reply->flavor = in_request_1->flavor;
|
||
out_reply->new_stateCnt = arraysize(out_reply->new_state);
|
||
out_reply->RetCode = interface_->CatchExceptionRaiseStateIdentity(
|
||
in_header->msgh_local_port,
|
||
in_request->thread.name,
|
||
in_request->task.name,
|
||
in_request->exception,
|
||
in_request->code,
|
||
in_request->codeCnt,
|
||
&out_reply->flavor,
|
||
in_request_1->old_state,
|
||
in_request_1->old_stateCnt,
|
||
out_reply->new_state,
|
||
&out_reply->new_stateCnt,
|
||
in_trailer,
|
||
destroy_complex_request);
|
||
if (out_reply->RetCode != KERN_SUCCESS) {
|
||
return true;
|
||
}
|
||
|
||
out_header->msgh_size =
|
||
sizeof(*out_reply) - sizeof(out_reply->new_state) +
|
||
sizeof(out_reply->new_state[0]) * out_reply->new_stateCnt;
|
||
return true;
|
||
}
|
||
|
||
default: {
|
||
SetMIGReplyError(out_header, MIG_BAD_ID);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
|
||
//! \brief A server interface for the `exc` or `mach_exc` Mach subsystems,
|
||
//! simplified to have only a single interface method needing
|
||
//! implementation.
|
||
template <typename Traits>
|
||
class SimplifiedExcServer final : public ExcServer<Traits>,
|
||
public ExcServer<Traits>::Interface {
|
||
public:
|
||
//! \brief An interface that the different request messages that are a part of
|
||
//! the `exc` or `mach_exc` Mach subsystems can be dispatched to.
|
||
class Interface {
|
||
public:
|
||
//! \brief Handles exceptions raised by `exception_raise()`,
|
||
//! `exception_raise_state()`, and `exception_raise_state_identity()`;
|
||
//! or `mach_exception_raise()`, `mach_exception_raise_state()`, and
|
||
//! `mach_exception_raise_state_identity()`.
|
||
//!
|
||
//! For convenience in implementation, these different “behaviors” of
|
||
//! exception messages are all mapped to a single interface method. The
|
||
//! exception’s original “behavior” is specified in the \a behavior
|
||
//! parameter. Only parameters that were supplied in the request message
|
||
//! are populated, other parameters are set to reasonable default values.
|
||
//!
|
||
//! The meanings of most parameters are identical to that of
|
||
//! ExcServer<>::Interface::CatchExceptionRaiseStateIdentity().
|
||
//!
|
||
//! \param[in] behavior `EXCEPTION_DEFAULT`, `EXCEPTION_STATE`, or
|
||
//! `EXCEPTION_STATE_IDENTITY`, identifying which exception request
|
||
//! message was processed and thus which other parameters are valid.
|
||
//! When used with the `mach_exc` subsystem, `MACH_EXCEPTION_CODES` will
|
||
//! be ORed in to this parameter.
|
||
virtual kern_return_t CatchException(
|
||
exception_behavior_t behavior,
|
||
exception_handler_t exception_port,
|
||
thread_t thread,
|
||
task_t task,
|
||
exception_type_t exception,
|
||
const typename Traits::ExceptionCode* code,
|
||
mach_msg_type_number_t code_count,
|
||
thread_state_flavor_t* flavor,
|
||
ConstThreadState old_state,
|
||
mach_msg_type_number_t old_state_count,
|
||
thread_state_t new_state,
|
||
mach_msg_type_number_t* new_state_count,
|
||
const mach_msg_trailer_t* trailer,
|
||
bool* destroy_complex_request) = 0;
|
||
|
||
protected:
|
||
~Interface() {}
|
||
};
|
||
|
||
//! \brief Constructs an object of this class.
|
||
//!
|
||
//! \param[in] interface The interface to dispatch requests to. Weak.
|
||
explicit SimplifiedExcServer(Interface* interface)
|
||
: ExcServer<Traits>(this),
|
||
ExcServer<Traits>::Interface(),
|
||
interface_(interface) {}
|
||
|
||
// ExcServer::Interface:
|
||
|
||
kern_return_t CatchExceptionRaise(exception_handler_t exception_port,
|
||
thread_t thread,
|
||
task_t task,
|
||
exception_type_t exception,
|
||
const typename Traits::ExceptionCode* code,
|
||
mach_msg_type_number_t code_count,
|
||
const mach_msg_trailer_t* trailer,
|
||
bool* destroy_request) override {
|
||
thread_state_flavor_t flavor = THREAD_STATE_NONE;
|
||
mach_msg_type_number_t new_state_count = 0;
|
||
return interface_->CatchException(
|
||
Traits::kExceptionBehavior | EXCEPTION_DEFAULT,
|
||
exception_port,
|
||
thread,
|
||
task,
|
||
exception,
|
||
code_count ? code : nullptr,
|
||
code_count,
|
||
&flavor,
|
||
nullptr,
|
||
0,
|
||
nullptr,
|
||
&new_state_count,
|
||
trailer,
|
||
destroy_request);
|
||
}
|
||
|
||
kern_return_t CatchExceptionRaiseState(
|
||
exception_handler_t exception_port,
|
||
exception_type_t exception,
|
||
const typename Traits::ExceptionCode* code,
|
||
mach_msg_type_number_t code_count,
|
||
thread_state_flavor_t* flavor,
|
||
ConstThreadState old_state,
|
||
mach_msg_type_number_t old_state_count,
|
||
thread_state_t new_state,
|
||
mach_msg_type_number_t* new_state_count,
|
||
const mach_msg_trailer_t* trailer) override {
|
||
bool destroy_complex_request = false;
|
||
return interface_->CatchException(
|
||
Traits::kExceptionBehavior | EXCEPTION_STATE,
|
||
exception_port,
|
||
THREAD_NULL,
|
||
TASK_NULL,
|
||
exception,
|
||
code_count ? code : nullptr,
|
||
code_count,
|
||
flavor,
|
||
old_state_count ? old_state : nullptr,
|
||
old_state_count,
|
||
new_state_count ? new_state : nullptr,
|
||
new_state_count,
|
||
trailer,
|
||
&destroy_complex_request);
|
||
}
|
||
|
||
kern_return_t CatchExceptionRaiseStateIdentity(
|
||
exception_handler_t exception_port,
|
||
thread_t thread,
|
||
task_t task,
|
||
exception_type_t exception,
|
||
const typename Traits::ExceptionCode* code,
|
||
mach_msg_type_number_t code_count,
|
||
thread_state_flavor_t* flavor,
|
||
ConstThreadState old_state,
|
||
mach_msg_type_number_t old_state_count,
|
||
thread_state_t new_state,
|
||
mach_msg_type_number_t* new_state_count,
|
||
const mach_msg_trailer_t* trailer,
|
||
bool* destroy_request) override {
|
||
return interface_->CatchException(
|
||
Traits::kExceptionBehavior | EXCEPTION_STATE_IDENTITY,
|
||
exception_port,
|
||
thread,
|
||
task,
|
||
exception,
|
||
code_count ? code : nullptr,
|
||
code_count,
|
||
flavor,
|
||
old_state_count ? old_state : nullptr,
|
||
old_state_count,
|
||
new_state_count ? new_state : nullptr,
|
||
new_state_count,
|
||
trailer,
|
||
destroy_request);
|
||
}
|
||
|
||
private:
|
||
Interface* interface_; // weak
|
||
|
||
DISALLOW_COPY_AND_ASSIGN(SimplifiedExcServer);
|
||
};
|
||
|
||
} // namespace
|
||
|
||
namespace internal {
|
||
|
||
class UniversalMachExcServerImpl final
|
||
: public CompositeMachMessageServer,
|
||
public SimplifiedExcServer<ExcTraits>::Interface,
|
||
public SimplifiedExcServer<MachExcTraits>::Interface {
|
||
public:
|
||
explicit UniversalMachExcServerImpl(
|
||
UniversalMachExcServer::Interface* interface)
|
||
: CompositeMachMessageServer(),
|
||
SimplifiedExcServer<ExcTraits>::Interface(),
|
||
SimplifiedExcServer<MachExcTraits>::Interface(),
|
||
exc_server_(this),
|
||
mach_exc_server_(this),
|
||
interface_(interface) {
|
||
AddHandler(&exc_server_);
|
||
AddHandler(&mach_exc_server_);
|
||
}
|
||
|
||
~UniversalMachExcServerImpl() {}
|
||
|
||
// SimplifiedExcServer<ExcTraits>::Interface:
|
||
kern_return_t CatchException(exception_behavior_t behavior,
|
||
exception_handler_t exception_port,
|
||
thread_t thread,
|
||
task_t task,
|
||
exception_type_t exception,
|
||
const exception_data_type_t* code,
|
||
mach_msg_type_number_t code_count,
|
||
thread_state_flavor_t* flavor,
|
||
ConstThreadState old_state,
|
||
mach_msg_type_number_t old_state_count,
|
||
thread_state_t new_state,
|
||
mach_msg_type_number_t* new_state_count,
|
||
const mach_msg_trailer_t* trailer,
|
||
bool* destroy_complex_request) {
|
||
std::vector<mach_exception_data_type_t> mach_codes;
|
||
mach_codes.reserve(code_count);
|
||
for (size_t index = 0; index < code_count; ++index) {
|
||
mach_codes.push_back(code[index]);
|
||
}
|
||
|
||
return interface_->CatchMachException(behavior,
|
||
exception_port,
|
||
thread,
|
||
task,
|
||
exception,
|
||
code_count ? &mach_codes[0] : nullptr,
|
||
code_count,
|
||
flavor,
|
||
old_state_count ? old_state : nullptr,
|
||
old_state_count,
|
||
new_state_count ? new_state : nullptr,
|
||
new_state_count,
|
||
trailer,
|
||
destroy_complex_request);
|
||
}
|
||
|
||
// SimplifiedExcServer<MachExcTraits>::Interface:
|
||
kern_return_t CatchException(exception_behavior_t behavior,
|
||
exception_handler_t exception_port,
|
||
thread_t thread,
|
||
task_t task,
|
||
exception_type_t exception,
|
||
const mach_exception_data_type_t* code,
|
||
mach_msg_type_number_t code_count,
|
||
thread_state_flavor_t* flavor,
|
||
ConstThreadState old_state,
|
||
mach_msg_type_number_t old_state_count,
|
||
thread_state_t new_state,
|
||
mach_msg_type_number_t* new_state_count,
|
||
const mach_msg_trailer_t* trailer,
|
||
bool* destroy_complex_request) {
|
||
return interface_->CatchMachException(behavior,
|
||
exception_port,
|
||
thread,
|
||
task,
|
||
exception,
|
||
code_count ? code : nullptr,
|
||
code_count,
|
||
flavor,
|
||
old_state_count ? old_state : nullptr,
|
||
old_state_count,
|
||
new_state_count ? new_state : nullptr,
|
||
new_state_count,
|
||
trailer,
|
||
destroy_complex_request);
|
||
}
|
||
|
||
private:
|
||
SimplifiedExcServer<ExcTraits> exc_server_;
|
||
SimplifiedExcServer<MachExcTraits> mach_exc_server_;
|
||
UniversalMachExcServer::Interface* interface_; // weak
|
||
|
||
DISALLOW_COPY_AND_ASSIGN(UniversalMachExcServerImpl);
|
||
};
|
||
|
||
} // namespace internal
|
||
|
||
UniversalMachExcServer::UniversalMachExcServer(
|
||
UniversalMachExcServer::Interface* interface)
|
||
: MachMessageServer::Interface(),
|
||
impl_(new internal::UniversalMachExcServerImpl(interface)) {
|
||
}
|
||
|
||
UniversalMachExcServer::~UniversalMachExcServer() {
|
||
}
|
||
|
||
bool UniversalMachExcServer::MachMessageServerFunction(
|
||
const mach_msg_header_t* in_header,
|
||
mach_msg_header_t* out_header,
|
||
bool* destroy_complex_request) {
|
||
return impl_->MachMessageServerFunction(
|
||
in_header, out_header, destroy_complex_request);
|
||
}
|
||
|
||
std::set<mach_msg_id_t> UniversalMachExcServer::MachMessageServerRequestIDs() {
|
||
return impl_->MachMessageServerRequestIDs();
|
||
}
|
||
|
||
mach_msg_size_t UniversalMachExcServer::MachMessageServerRequestSize() {
|
||
return impl_->MachMessageServerRequestSize();
|
||
}
|
||
|
||
mach_msg_size_t UniversalMachExcServer::MachMessageServerReplySize() {
|
||
return impl_->MachMessageServerReplySize();
|
||
}
|
||
|
||
kern_return_t ExcServerSuccessfulReturnValue(exception_type_t exception,
|
||
exception_behavior_t behavior,
|
||
bool set_thread_state) {
|
||
if (exception == EXC_CRASH
|
||
#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_11
|
||
&& MacOSXMinorVersion() >= 11
|
||
#endif
|
||
) {
|
||
return KERN_SUCCESS;
|
||
}
|
||
|
||
if (!set_thread_state && ExceptionBehaviorHasState(behavior)) {
|
||
return MACH_RCV_PORT_DIED;
|
||
}
|
||
|
||
return KERN_SUCCESS;
|
||
}
|
||
|
||
void ExcServerCopyState(exception_behavior_t behavior,
|
||
ConstThreadState old_state,
|
||
mach_msg_type_number_t old_state_count,
|
||
thread_state_t new_state,
|
||
mach_msg_type_number_t* new_state_count) {
|
||
if (ExceptionBehaviorHasState(behavior)) {
|
||
*new_state_count = std::min(old_state_count, *new_state_count);
|
||
memcpy(new_state, old_state, *new_state_count * sizeof(old_state[0]));
|
||
}
|
||
}
|
||
|
||
} // namespace crashpad
|