mirror of
https://github.com/chromium/crashpad.git
synced 2024-12-28 15:50:26 +08:00
6d2d31d2d1
This was done in Chromium’s local copy of Crashpad in 562827afb599. This change is similar to that one, except more care was taken to avoid including headers from a .cc or _test.cc when already included by the associated .h. Rather than using <stddef.h> for size_t, Crashpad has always used <sys/types.h>, so that’s used here as well. This updates mini_chromium to 8a2363f486e3a0dc562a68884832d06d28d38dcc, which removes base/basictypes.h. e128dcf10122 Remove base/move.h; use std::move() instead of Pass() 8a2363f486e3 Move basictypes.h to macros.h R=avi@chromium.org Review URL: https://codereview.chromium.org/1566713002 .
1346 lines
48 KiB
C++
1346 lines
48 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 <mach/mach.h>
|
||
#include <stdint.h>
|
||
#include <string.h>
|
||
#include <sys/types.h>
|
||
|
||
#include "base/strings/stringprintf.h"
|
||
#include "build/build_config.h"
|
||
#include "gmock/gmock.h"
|
||
#include "gtest/gtest.h"
|
||
#include "test/mac/mach_errors.h"
|
||
#include "test/mac/mach_multiprocess.h"
|
||
#include "util/mac/mac_util.h"
|
||
#include "util/mach/exception_behaviors.h"
|
||
#include "util/mach/exception_types.h"
|
||
#include "util/mach/mach_message.h"
|
||
#include "util/misc/implicit_cast.h"
|
||
|
||
namespace crashpad {
|
||
namespace test {
|
||
namespace {
|
||
|
||
using testing::DefaultValue;
|
||
using testing::Eq;
|
||
using testing::Pointee;
|
||
using testing::Return;
|
||
|
||
// Fake Mach ports. These aren’t used as ports in these tests, they’re just used
|
||
// as cookies to make sure that the correct values get passed to the correct
|
||
// places.
|
||
const mach_port_t kClientRemotePort = 0x01010101;
|
||
const mach_port_t kServerLocalPort = 0x02020202;
|
||
const thread_t kExceptionThreadPort = 0x03030303;
|
||
const task_t kExceptionTaskPort = 0x04040404;
|
||
|
||
// Other fake exception values.
|
||
const exception_type_t kExceptionType = EXC_BAD_ACCESS;
|
||
|
||
// Test using an exception code with the high bit set to ensure that it gets
|
||
// promoted to the wider mach_exception_data_type_t type as a signed quantity.
|
||
const exception_data_type_t kTestExceptonCodes[] = {
|
||
KERN_PROTECTION_FAILURE,
|
||
implicit_cast<exception_data_type_t>(0xfedcba98),
|
||
};
|
||
|
||
const mach_exception_data_type_t kTestMachExceptionCodes[] = {
|
||
KERN_PROTECTION_FAILURE,
|
||
implicit_cast<mach_exception_data_type_t>(0xfedcba9876543210),
|
||
};
|
||
|
||
const thread_state_flavor_t kThreadStateFlavor = MACHINE_THREAD_STATE;
|
||
const mach_msg_type_number_t kThreadStateFlavorCount =
|
||
MACHINE_THREAD_STATE_COUNT;
|
||
|
||
void InitializeMachMsgPortDescriptor(mach_msg_port_descriptor_t* descriptor,
|
||
mach_port_t port) {
|
||
descriptor->name = port;
|
||
descriptor->disposition = MACH_MSG_TYPE_PORT_SEND;
|
||
descriptor->type = MACH_MSG_PORT_DESCRIPTOR;
|
||
}
|
||
|
||
// The definitions of the request and reply structures from mach_exc.h aren’t
|
||
// available here. They need custom initialization code, and the reply
|
||
// structures need verification code too, so duplicate the expected definitions
|
||
// of the structures from both exc.h and mach_exc.h here in this file, and
|
||
// provide the initialization and verification code as methods in true
|
||
// object-oriented fashion.
|
||
|
||
struct __attribute__((packed, aligned(4))) ExceptionRaiseRequest {
|
||
ExceptionRaiseRequest() {
|
||
memset(this, 0xa5, sizeof(*this));
|
||
Head.msgh_bits =
|
||
MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
|
||
MACH_MSGH_BITS_COMPLEX;
|
||
Head.msgh_size = sizeof(*this) - sizeof(trailer);
|
||
Head.msgh_remote_port = kClientRemotePort;
|
||
Head.msgh_local_port = kServerLocalPort;
|
||
Head.msgh_id = 2401;
|
||
msgh_body.msgh_descriptor_count = 2;
|
||
InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
|
||
InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
|
||
NDR = NDR_record;
|
||
exception = kExceptionType;
|
||
codeCnt = 2;
|
||
code[0] = kTestExceptonCodes[0];
|
||
code[1] = kTestExceptonCodes[1];
|
||
}
|
||
|
||
mach_msg_header_t Head;
|
||
mach_msg_body_t msgh_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 codeCnt;
|
||
integer_t code[2];
|
||
mach_msg_trailer_t trailer;
|
||
};
|
||
|
||
struct __attribute__((packed, aligned(4))) ExceptionRaiseReply {
|
||
ExceptionRaiseReply() {
|
||
memset(this, 0x5a, sizeof(*this));
|
||
RetCode = KERN_FAILURE;
|
||
}
|
||
|
||
// Verify accepts a |behavior| parameter because the same message format and
|
||
// verification function is used for ExceptionRaiseReply and
|
||
// MachExceptionRaiseReply. Knowing which behavior is expected allows the
|
||
// message ID to be checked.
|
||
void Verify(exception_behavior_t behavior) {
|
||
EXPECT_EQ(implicit_cast<mach_msg_bits_t>(
|
||
MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND_ONCE, 0)),
|
||
Head.msgh_bits);
|
||
EXPECT_EQ(sizeof(*this), Head.msgh_size);
|
||
EXPECT_EQ(kClientRemotePort, Head.msgh_remote_port);
|
||
EXPECT_EQ(kMachPortNull, Head.msgh_local_port);
|
||
switch (behavior) {
|
||
case EXCEPTION_DEFAULT:
|
||
EXPECT_EQ(2501, Head.msgh_id);
|
||
break;
|
||
case EXCEPTION_DEFAULT | kMachExceptionCodes:
|
||
EXPECT_EQ(2505, Head.msgh_id);
|
||
break;
|
||
default:
|
||
ADD_FAILURE() << "behavior " << behavior << ", Head.msgh_id "
|
||
<< Head.msgh_id;
|
||
break;
|
||
}
|
||
EXPECT_EQ(0, memcmp(&NDR, &NDR_record, sizeof(NDR)));
|
||
EXPECT_EQ(KERN_SUCCESS, RetCode);
|
||
}
|
||
|
||
mach_msg_header_t Head;
|
||
NDR_record_t NDR;
|
||
kern_return_t RetCode;
|
||
};
|
||
|
||
struct __attribute__((packed, aligned(4))) ExceptionRaiseStateRequest {
|
||
ExceptionRaiseStateRequest() {
|
||
memset(this, 0xa5, sizeof(*this));
|
||
Head.msgh_bits =
|
||
MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND);
|
||
Head.msgh_size = sizeof(*this) - sizeof(trailer);
|
||
Head.msgh_remote_port = kClientRemotePort;
|
||
Head.msgh_local_port = kServerLocalPort;
|
||
Head.msgh_id = 2402;
|
||
NDR = NDR_record;
|
||
exception = kExceptionType;
|
||
codeCnt = 2;
|
||
code[0] = kTestExceptonCodes[0];
|
||
code[1] = kTestExceptonCodes[1];
|
||
flavor = kThreadStateFlavor;
|
||
old_stateCnt = kThreadStateFlavorCount;
|
||
|
||
// Adjust the message size for the data that it’s actually carrying, which
|
||
// may be smaller than the maximum that it can carry.
|
||
Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
|
||
}
|
||
|
||
// Because the message size has been adjusted, the trailer may not appear in
|
||
// its home member variable. This computes the actual address of the trailer.
|
||
const mach_msg_trailer_t* Trailer() const {
|
||
return MachMessageTrailerFromHeader(&Head);
|
||
}
|
||
|
||
mach_msg_header_t Head;
|
||
NDR_record_t NDR;
|
||
exception_type_t exception;
|
||
mach_msg_type_number_t codeCnt;
|
||
integer_t code[2];
|
||
int flavor;
|
||
mach_msg_type_number_t old_stateCnt;
|
||
natural_t old_state[THREAD_STATE_MAX];
|
||
mach_msg_trailer_t trailer;
|
||
};
|
||
|
||
struct __attribute__((packed, aligned(4))) ExceptionRaiseStateReply {
|
||
ExceptionRaiseStateReply() {
|
||
memset(this, 0x5a, sizeof(*this));
|
||
RetCode = KERN_FAILURE;
|
||
}
|
||
|
||
// Verify accepts a |behavior| parameter because the same message format and
|
||
// verification function is used for ExceptionRaiseStateReply,
|
||
// ExceptionRaiseStateIdentityReply, MachExceptionRaiseStateReply, and
|
||
// MachExceptionRaiseStateIdentityReply. Knowing which behavior is expected
|
||
// allows the message ID to be checked.
|
||
void Verify(exception_behavior_t behavior) {
|
||
EXPECT_EQ(implicit_cast<mach_msg_bits_t>(
|
||
MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND_ONCE, 0)),
|
||
Head.msgh_bits);
|
||
EXPECT_EQ(sizeof(*this), Head.msgh_size);
|
||
EXPECT_EQ(kClientRemotePort, Head.msgh_remote_port);
|
||
EXPECT_EQ(kMachPortNull, Head.msgh_local_port);
|
||
switch (behavior) {
|
||
case EXCEPTION_STATE:
|
||
EXPECT_EQ(2502, Head.msgh_id);
|
||
break;
|
||
case EXCEPTION_STATE_IDENTITY:
|
||
EXPECT_EQ(2503, Head.msgh_id);
|
||
break;
|
||
case EXCEPTION_STATE | kMachExceptionCodes:
|
||
EXPECT_EQ(2506, Head.msgh_id);
|
||
break;
|
||
case EXCEPTION_STATE_IDENTITY | kMachExceptionCodes:
|
||
EXPECT_EQ(2507, Head.msgh_id);
|
||
break;
|
||
default:
|
||
ADD_FAILURE() << "behavior " << behavior << ", Head.msgh_id "
|
||
<< Head.msgh_id;
|
||
break;
|
||
}
|
||
EXPECT_EQ(0, memcmp(&NDR, &NDR_record, sizeof(NDR)));
|
||
EXPECT_EQ(KERN_SUCCESS, RetCode);
|
||
EXPECT_EQ(kThreadStateFlavor, flavor);
|
||
EXPECT_EQ(arraysize(new_state), new_stateCnt);
|
||
}
|
||
|
||
mach_msg_header_t Head;
|
||
NDR_record_t NDR;
|
||
kern_return_t RetCode;
|
||
int flavor;
|
||
mach_msg_type_number_t new_stateCnt;
|
||
natural_t new_state[THREAD_STATE_MAX];
|
||
};
|
||
|
||
struct __attribute__((packed, aligned(4))) ExceptionRaiseStateIdentityRequest {
|
||
ExceptionRaiseStateIdentityRequest() {
|
||
memset(this, 0xa5, sizeof(*this));
|
||
Head.msgh_bits =
|
||
MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
|
||
MACH_MSGH_BITS_COMPLEX;
|
||
Head.msgh_size = sizeof(*this) - sizeof(trailer);
|
||
Head.msgh_remote_port = kClientRemotePort;
|
||
Head.msgh_local_port = kServerLocalPort;
|
||
Head.msgh_id = 2403;
|
||
msgh_body.msgh_descriptor_count = 2;
|
||
InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
|
||
InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
|
||
NDR = NDR_record;
|
||
exception = kExceptionType;
|
||
codeCnt = 2;
|
||
code[0] = kTestExceptonCodes[0];
|
||
code[1] = kTestExceptonCodes[1];
|
||
flavor = kThreadStateFlavor;
|
||
old_stateCnt = kThreadStateFlavorCount;
|
||
|
||
// Adjust the message size for the data that it’s actually carrying, which
|
||
// may be smaller than the maximum that it can carry.
|
||
Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
|
||
}
|
||
|
||
// Because the message size has been adjusted, the trailer may not appear in
|
||
// its home member variable. This computes the actual address of the trailer.
|
||
const mach_msg_trailer_t* Trailer() const {
|
||
return MachMessageTrailerFromHeader(&Head);
|
||
}
|
||
|
||
mach_msg_header_t Head;
|
||
mach_msg_body_t msgh_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 codeCnt;
|
||
integer_t code[2];
|
||
int flavor;
|
||
mach_msg_type_number_t old_stateCnt;
|
||
natural_t old_state[THREAD_STATE_MAX];
|
||
mach_msg_trailer_t trailer;
|
||
};
|
||
|
||
// The reply messages for exception_raise_state and
|
||
// exception_raise_state_identity are identical.
|
||
using ExceptionRaiseStateIdentityReply = ExceptionRaiseStateReply;
|
||
|
||
struct __attribute__((packed, aligned(4))) MachExceptionRaiseRequest {
|
||
MachExceptionRaiseRequest() {
|
||
memset(this, 0xa5, sizeof(*this));
|
||
Head.msgh_bits =
|
||
MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
|
||
MACH_MSGH_BITS_COMPLEX;
|
||
Head.msgh_size = sizeof(*this) - sizeof(trailer);
|
||
Head.msgh_remote_port = kClientRemotePort;
|
||
Head.msgh_local_port = kServerLocalPort;
|
||
Head.msgh_id = 2405;
|
||
msgh_body.msgh_descriptor_count = 2;
|
||
InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
|
||
InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
|
||
NDR = NDR_record;
|
||
exception = kExceptionType;
|
||
codeCnt = 2;
|
||
code[0] = kTestMachExceptionCodes[0];
|
||
code[1] = kTestMachExceptionCodes[1];
|
||
}
|
||
|
||
mach_msg_header_t Head;
|
||
mach_msg_body_t msgh_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 codeCnt;
|
||
int64_t code[2];
|
||
mach_msg_trailer_t trailer;
|
||
};
|
||
|
||
// The reply messages for exception_raise and mach_exception_raise are
|
||
// identical.
|
||
using MachExceptionRaiseReply = ExceptionRaiseReply;
|
||
|
||
struct __attribute__((packed, aligned(4))) MachExceptionRaiseStateRequest {
|
||
MachExceptionRaiseStateRequest() {
|
||
memset(this, 0xa5, sizeof(*this));
|
||
Head.msgh_bits =
|
||
MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND);
|
||
Head.msgh_size = sizeof(*this) - sizeof(trailer);
|
||
Head.msgh_remote_port = kClientRemotePort;
|
||
Head.msgh_local_port = kServerLocalPort;
|
||
Head.msgh_id = 2406;
|
||
NDR = NDR_record;
|
||
exception = kExceptionType;
|
||
codeCnt = 2;
|
||
code[0] = kTestMachExceptionCodes[0];
|
||
code[1] = kTestMachExceptionCodes[1];
|
||
flavor = kThreadStateFlavor;
|
||
old_stateCnt = kThreadStateFlavorCount;
|
||
|
||
// Adjust the message size for the data that it’s actually carrying, which
|
||
// may be smaller than the maximum that it can carry.
|
||
Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
|
||
}
|
||
|
||
// Because the message size has been adjusted, the trailer may not appear in
|
||
// its home member variable. This computes the actual address of the trailer.
|
||
const mach_msg_trailer_t* Trailer() const {
|
||
return MachMessageTrailerFromHeader(&Head);
|
||
}
|
||
|
||
mach_msg_header_t Head;
|
||
NDR_record_t NDR;
|
||
exception_type_t exception;
|
||
mach_msg_type_number_t codeCnt;
|
||
int64_t code[2];
|
||
int flavor;
|
||
mach_msg_type_number_t old_stateCnt;
|
||
natural_t old_state[THREAD_STATE_MAX];
|
||
mach_msg_trailer_t trailer;
|
||
};
|
||
|
||
// The reply messages for exception_raise_state and mach_exception_raise_state
|
||
// are identical.
|
||
using MachExceptionRaiseStateReply = ExceptionRaiseStateReply;
|
||
|
||
struct __attribute__((packed,
|
||
aligned(4))) MachExceptionRaiseStateIdentityRequest {
|
||
MachExceptionRaiseStateIdentityRequest() {
|
||
memset(this, 0xa5, sizeof(*this));
|
||
Head.msgh_bits =
|
||
MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
|
||
MACH_MSGH_BITS_COMPLEX;
|
||
Head.msgh_size = sizeof(*this) - sizeof(trailer);
|
||
Head.msgh_remote_port = kClientRemotePort;
|
||
Head.msgh_local_port = kServerLocalPort;
|
||
Head.msgh_id = 2407;
|
||
msgh_body.msgh_descriptor_count = 2;
|
||
InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
|
||
InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
|
||
NDR = NDR_record;
|
||
exception = kExceptionType;
|
||
codeCnt = 2;
|
||
code[0] = kTestMachExceptionCodes[0];
|
||
code[1] = kTestMachExceptionCodes[1];
|
||
flavor = kThreadStateFlavor;
|
||
old_stateCnt = kThreadStateFlavorCount;
|
||
|
||
// Adjust the message size for the data that it’s actually carrying, which
|
||
// may be smaller than the maximum that it can carry.
|
||
Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
|
||
}
|
||
|
||
// Because the message size has been adjusted, the trailer may not appear in
|
||
// its home member variable. This computes the actual address of the trailer.
|
||
const mach_msg_trailer_t* Trailer() const {
|
||
return MachMessageTrailerFromHeader(&Head);
|
||
}
|
||
|
||
mach_msg_header_t Head;
|
||
mach_msg_body_t msgh_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 codeCnt;
|
||
int64_t code[2];
|
||
int flavor;
|
||
mach_msg_type_number_t old_stateCnt;
|
||
natural_t old_state[THREAD_STATE_MAX];
|
||
mach_msg_trailer_t trailer;
|
||
};
|
||
|
||
// The reply messages for exception_raise_state_identity and
|
||
// mach_exception_raise_state_identity are identical.
|
||
using MachExceptionRaiseStateIdentityReply = ExceptionRaiseStateIdentityReply;
|
||
|
||
// InvalidRequest and BadIDErrorReply are used to test that
|
||
// UniversalMachExcServer deals appropriately with messages that it does not
|
||
// understand: messages with an unknown Head.msgh_id.
|
||
|
||
struct InvalidRequest : public mach_msg_empty_send_t {
|
||
explicit InvalidRequest(mach_msg_id_t id) {
|
||
memset(this, 0xa5, sizeof(*this));
|
||
header.msgh_bits =
|
||
MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND);
|
||
header.msgh_size = sizeof(*this);
|
||
header.msgh_remote_port = kClientRemotePort;
|
||
header.msgh_local_port = kServerLocalPort;
|
||
header.msgh_id = id;
|
||
}
|
||
};
|
||
|
||
struct BadIDErrorReply : public mig_reply_error_t {
|
||
BadIDErrorReply() {
|
||
memset(this, 0x5a, sizeof(*this));
|
||
RetCode = KERN_FAILURE;
|
||
}
|
||
|
||
void Verify(mach_msg_id_t id) {
|
||
EXPECT_EQ(implicit_cast<mach_msg_bits_t>(
|
||
MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND_ONCE, 0)),
|
||
Head.msgh_bits);
|
||
EXPECT_EQ(sizeof(*this), Head.msgh_size);
|
||
EXPECT_EQ(kClientRemotePort, Head.msgh_remote_port);
|
||
EXPECT_EQ(kMachPortNull, Head.msgh_local_port);
|
||
EXPECT_EQ(id + 100, Head.msgh_id);
|
||
EXPECT_EQ(0, memcmp(&NDR, &NDR_record, sizeof(NDR)));
|
||
EXPECT_EQ(MIG_BAD_ID, RetCode);
|
||
}
|
||
};
|
||
|
||
class MockUniversalMachExcServer : public UniversalMachExcServer::Interface {
|
||
public:
|
||
struct ConstExceptionCodes {
|
||
const mach_exception_data_type_t* code;
|
||
mach_msg_type_number_t code_count;
|
||
};
|
||
struct ThreadStateAndCount {
|
||
thread_state_t state;
|
||
mach_msg_type_number_t* state_count;
|
||
};
|
||
struct ConstThreadStateAndCount {
|
||
ConstThreadState state;
|
||
mach_msg_type_number_t* state_count;
|
||
};
|
||
|
||
// UniversalMachExcServer::Interface:
|
||
|
||
// CatchMachException is the method to mock, but it has 13 parameters, and
|
||
// gmock can only mock methods with up to 10 parameters. Coalesce some related
|
||
// parameters together into structs, and call a mocked method.
|
||
virtual kern_return_t CatchMachException(
|
||
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) override {
|
||
*destroy_complex_request = true;
|
||
const ConstExceptionCodes exception_codes = {code, code_count};
|
||
const ConstThreadStateAndCount old_thread_state = {old_state,
|
||
&old_state_count};
|
||
ThreadStateAndCount new_thread_state = {new_state, new_state_count};
|
||
return MockCatchMachException(behavior,
|
||
exception_port,
|
||
thread,
|
||
task,
|
||
exception,
|
||
&exception_codes,
|
||
flavor,
|
||
&old_thread_state,
|
||
&new_thread_state,
|
||
trailer);
|
||
}
|
||
|
||
MOCK_METHOD10(MockCatchMachException,
|
||
kern_return_t(exception_behavior_t behavior,
|
||
exception_handler_t exception_port,
|
||
thread_t thread,
|
||
task_t task,
|
||
exception_type_t exception,
|
||
const ConstExceptionCodes* exception_codes,
|
||
thread_state_flavor_t* flavor,
|
||
const ConstThreadStateAndCount* old_thread_state,
|
||
ThreadStateAndCount* new_thread_state,
|
||
const mach_msg_trailer_t* trailer));
|
||
};
|
||
|
||
// Matcher for ConstExceptionCodes, testing that it carries 2 codes matching
|
||
// code_0 and code_1.
|
||
MATCHER_P2(AreExceptionCodes, code_0, code_1, "") {
|
||
if (!arg) {
|
||
return false;
|
||
}
|
||
|
||
if (arg->code_count == 2 && arg->code[0] == code_0 &&
|
||
arg->code[1] == code_1) {
|
||
return true;
|
||
}
|
||
|
||
*result_listener << "codes (";
|
||
for (size_t index = 0; index < arg->code_count; ++index) {
|
||
*result_listener << arg->code[index];
|
||
if (index < arg->code_count - 1) {
|
||
*result_listener << ", ";
|
||
}
|
||
}
|
||
*result_listener << ")";
|
||
|
||
return false;
|
||
}
|
||
|
||
// Matcher for ThreadStateAndCount and ConstThreadStateAndCount, testing that
|
||
// *state_count is present and matches the specified value. If 0 is specified
|
||
// for the count, |state| must be nullptr (not present), otherwise |state| must
|
||
// not be nullptr (present).
|
||
MATCHER_P(IsThreadStateAndCount, state_count, "") {
|
||
if (!arg) {
|
||
return false;
|
||
}
|
||
if (!arg->state_count) {
|
||
*result_listener << "state_count nullptr";
|
||
return false;
|
||
}
|
||
if (*(arg->state_count) != state_count) {
|
||
*result_listener << "*state_count " << *(arg->state_count);
|
||
return false;
|
||
}
|
||
if (state_count) {
|
||
if (!arg->state) {
|
||
*result_listener << "*state_count " << state_count << ", state nullptr";
|
||
return false;
|
||
}
|
||
} else {
|
||
if (arg->state) {
|
||
*result_listener << "*state_count 0, state non-nullptr (" << arg->state
|
||
<< ")";
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
template <typename T>
|
||
class ScopedDefaultValue {
|
||
public:
|
||
explicit ScopedDefaultValue(const T& default_value) {
|
||
DefaultValue<T>::Set(default_value);
|
||
}
|
||
|
||
~ScopedDefaultValue() { DefaultValue<T>::Clear(); }
|
||
};
|
||
|
||
TEST(ExcServerVariants, MockExceptionRaise) {
|
||
ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
|
||
|
||
MockUniversalMachExcServer server;
|
||
UniversalMachExcServer universal_mach_exc_server(&server);
|
||
|
||
std::set<mach_msg_id_t> ids =
|
||
universal_mach_exc_server.MachMessageServerRequestIDs();
|
||
EXPECT_NE(ids.end(), ids.find(2401)); // There is no constant for this.
|
||
|
||
ExceptionRaiseRequest request;
|
||
EXPECT_LE(request.Head.msgh_size,
|
||
universal_mach_exc_server.MachMessageServerRequestSize());
|
||
|
||
ExceptionRaiseReply reply;
|
||
EXPECT_LE(sizeof(reply),
|
||
universal_mach_exc_server.MachMessageServerReplySize());
|
||
|
||
const exception_behavior_t kExceptionBehavior = EXCEPTION_DEFAULT;
|
||
|
||
EXPECT_CALL(server,
|
||
MockCatchMachException(kExceptionBehavior,
|
||
kServerLocalPort,
|
||
kExceptionThreadPort,
|
||
kExceptionTaskPort,
|
||
kExceptionType,
|
||
AreExceptionCodes(kTestExceptonCodes[0],
|
||
kTestExceptonCodes[1]),
|
||
Pointee(Eq(THREAD_STATE_NONE)),
|
||
IsThreadStateAndCount(0u),
|
||
IsThreadStateAndCount(0u),
|
||
Eq(&request.trailer)))
|
||
.WillOnce(Return(KERN_SUCCESS))
|
||
.RetiresOnSaturation();
|
||
|
||
bool destroy_complex_request = false;
|
||
EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
|
||
reinterpret_cast<mach_msg_header_t*>(&request),
|
||
reinterpret_cast<mach_msg_header_t*>(&reply),
|
||
&destroy_complex_request));
|
||
EXPECT_TRUE(destroy_complex_request);
|
||
|
||
reply.Verify(kExceptionBehavior);
|
||
}
|
||
|
||
TEST(ExcServerVariants, MockExceptionRaiseState) {
|
||
ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
|
||
|
||
MockUniversalMachExcServer server;
|
||
UniversalMachExcServer universal_mach_exc_server(&server);
|
||
|
||
std::set<mach_msg_id_t> ids =
|
||
universal_mach_exc_server.MachMessageServerRequestIDs();
|
||
EXPECT_NE(ids.end(), ids.find(2402)); // There is no constant for this.
|
||
|
||
ExceptionRaiseStateRequest request;
|
||
EXPECT_LE(request.Head.msgh_size,
|
||
universal_mach_exc_server.MachMessageServerRequestSize());
|
||
|
||
ExceptionRaiseStateReply reply;
|
||
EXPECT_LE(sizeof(reply),
|
||
universal_mach_exc_server.MachMessageServerReplySize());
|
||
|
||
const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE;
|
||
|
||
EXPECT_CALL(
|
||
server,
|
||
MockCatchMachException(
|
||
kExceptionBehavior,
|
||
kServerLocalPort,
|
||
THREAD_NULL,
|
||
TASK_NULL,
|
||
kExceptionType,
|
||
AreExceptionCodes(kTestExceptonCodes[0], kTestExceptonCodes[1]),
|
||
Pointee(Eq(kThreadStateFlavor)),
|
||
IsThreadStateAndCount(kThreadStateFlavorCount),
|
||
IsThreadStateAndCount(arraysize(reply.new_state)),
|
||
Eq(request.Trailer())))
|
||
.WillOnce(Return(KERN_SUCCESS))
|
||
.RetiresOnSaturation();
|
||
|
||
bool destroy_complex_request = false;
|
||
EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
|
||
reinterpret_cast<mach_msg_header_t*>(&request),
|
||
reinterpret_cast<mach_msg_header_t*>(&reply),
|
||
&destroy_complex_request));
|
||
|
||
// The request wasn’t complex, so nothing got a chance to change the value of
|
||
// this variable.
|
||
EXPECT_FALSE(destroy_complex_request);
|
||
|
||
reply.Verify(kExceptionBehavior);
|
||
}
|
||
|
||
TEST(ExcServerVariants, MockExceptionRaiseStateIdentity) {
|
||
ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
|
||
|
||
MockUniversalMachExcServer server;
|
||
UniversalMachExcServer universal_mach_exc_server(&server);
|
||
|
||
std::set<mach_msg_id_t> ids =
|
||
universal_mach_exc_server.MachMessageServerRequestIDs();
|
||
EXPECT_NE(ids.end(), ids.find(2403)); // There is no constant for this.
|
||
|
||
ExceptionRaiseStateIdentityRequest request;
|
||
EXPECT_LE(request.Head.msgh_size,
|
||
universal_mach_exc_server.MachMessageServerRequestSize());
|
||
|
||
ExceptionRaiseStateIdentityReply reply;
|
||
EXPECT_LE(sizeof(reply),
|
||
universal_mach_exc_server.MachMessageServerReplySize());
|
||
|
||
const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE_IDENTITY;
|
||
|
||
EXPECT_CALL(
|
||
server,
|
||
MockCatchMachException(
|
||
kExceptionBehavior,
|
||
kServerLocalPort,
|
||
kExceptionThreadPort,
|
||
kExceptionTaskPort,
|
||
kExceptionType,
|
||
AreExceptionCodes(kTestExceptonCodes[0], kTestExceptonCodes[1]),
|
||
Pointee(Eq(kThreadStateFlavor)),
|
||
IsThreadStateAndCount(kThreadStateFlavorCount),
|
||
IsThreadStateAndCount(arraysize(reply.new_state)),
|
||
Eq(request.Trailer())))
|
||
.WillOnce(Return(KERN_SUCCESS))
|
||
.RetiresOnSaturation();
|
||
|
||
bool destroy_complex_request = false;
|
||
EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
|
||
reinterpret_cast<mach_msg_header_t*>(&request),
|
||
reinterpret_cast<mach_msg_header_t*>(&reply),
|
||
&destroy_complex_request));
|
||
EXPECT_TRUE(destroy_complex_request);
|
||
|
||
reply.Verify(kExceptionBehavior);
|
||
}
|
||
|
||
TEST(ExcServerVariants, MockMachExceptionRaise) {
|
||
ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
|
||
|
||
MockUniversalMachExcServer server;
|
||
UniversalMachExcServer universal_mach_exc_server(&server);
|
||
|
||
std::set<mach_msg_id_t> ids =
|
||
universal_mach_exc_server.MachMessageServerRequestIDs();
|
||
EXPECT_NE(ids.end(), ids.find(2405)); // There is no constant for this.
|
||
|
||
MachExceptionRaiseRequest request;
|
||
EXPECT_LE(request.Head.msgh_size,
|
||
universal_mach_exc_server.MachMessageServerRequestSize());
|
||
|
||
MachExceptionRaiseReply reply;
|
||
EXPECT_LE(sizeof(reply),
|
||
universal_mach_exc_server.MachMessageServerReplySize());
|
||
|
||
const exception_behavior_t kExceptionBehavior =
|
||
EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES;
|
||
|
||
EXPECT_CALL(
|
||
server,
|
||
MockCatchMachException(kExceptionBehavior,
|
||
kServerLocalPort,
|
||
kExceptionThreadPort,
|
||
kExceptionTaskPort,
|
||
kExceptionType,
|
||
AreExceptionCodes(kTestMachExceptionCodes[0],
|
||
kTestMachExceptionCodes[1]),
|
||
Pointee(Eq(THREAD_STATE_NONE)),
|
||
IsThreadStateAndCount(0u),
|
||
IsThreadStateAndCount(0u),
|
||
Eq(&request.trailer)))
|
||
.WillOnce(Return(KERN_SUCCESS))
|
||
.RetiresOnSaturation();
|
||
|
||
bool destroy_complex_request = false;
|
||
EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
|
||
reinterpret_cast<mach_msg_header_t*>(&request),
|
||
reinterpret_cast<mach_msg_header_t*>(&reply),
|
||
&destroy_complex_request));
|
||
EXPECT_TRUE(destroy_complex_request);
|
||
|
||
reply.Verify(kExceptionBehavior);
|
||
}
|
||
|
||
TEST(ExcServerVariants, MockMachExceptionRaiseState) {
|
||
ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
|
||
|
||
MockUniversalMachExcServer server;
|
||
UniversalMachExcServer universal_mach_exc_server(&server);
|
||
|
||
std::set<mach_msg_id_t> ids =
|
||
universal_mach_exc_server.MachMessageServerRequestIDs();
|
||
EXPECT_NE(ids.end(), ids.find(2406)); // There is no constant for this.
|
||
|
||
MachExceptionRaiseStateRequest request;
|
||
EXPECT_LE(request.Head.msgh_size,
|
||
universal_mach_exc_server.MachMessageServerRequestSize());
|
||
|
||
MachExceptionRaiseStateReply reply;
|
||
EXPECT_LE(sizeof(reply),
|
||
universal_mach_exc_server.MachMessageServerReplySize());
|
||
|
||
const exception_behavior_t kExceptionBehavior =
|
||
EXCEPTION_STATE | MACH_EXCEPTION_CODES;
|
||
|
||
EXPECT_CALL(
|
||
server,
|
||
MockCatchMachException(kExceptionBehavior,
|
||
kServerLocalPort,
|
||
THREAD_NULL,
|
||
TASK_NULL,
|
||
kExceptionType,
|
||
AreExceptionCodes(kTestMachExceptionCodes[0],
|
||
kTestMachExceptionCodes[1]),
|
||
Pointee(Eq(kThreadStateFlavor)),
|
||
IsThreadStateAndCount(kThreadStateFlavorCount),
|
||
IsThreadStateAndCount(arraysize(reply.new_state)),
|
||
Eq(request.Trailer())))
|
||
.WillOnce(Return(KERN_SUCCESS))
|
||
.RetiresOnSaturation();
|
||
|
||
bool destroy_complex_request = false;
|
||
EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
|
||
reinterpret_cast<mach_msg_header_t*>(&request),
|
||
reinterpret_cast<mach_msg_header_t*>(&reply),
|
||
&destroy_complex_request));
|
||
|
||
// The request wasn’t complex, so nothing got a chance to change the value of
|
||
// this variable.
|
||
EXPECT_FALSE(destroy_complex_request);
|
||
|
||
reply.Verify(kExceptionBehavior);
|
||
}
|
||
|
||
TEST(ExcServerVariants, MockMachExceptionRaiseStateIdentity) {
|
||
ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
|
||
|
||
MockUniversalMachExcServer server;
|
||
UniversalMachExcServer universal_mach_exc_server(&server);
|
||
|
||
std::set<mach_msg_id_t> ids =
|
||
universal_mach_exc_server.MachMessageServerRequestIDs();
|
||
EXPECT_NE(ids.end(), ids.find(2407)); // There is no constant for this.
|
||
|
||
MachExceptionRaiseStateIdentityRequest request;
|
||
EXPECT_LE(request.Head.msgh_size,
|
||
universal_mach_exc_server.MachMessageServerRequestSize());
|
||
|
||
MachExceptionRaiseStateIdentityReply reply;
|
||
EXPECT_LE(sizeof(reply),
|
||
universal_mach_exc_server.MachMessageServerReplySize());
|
||
|
||
const exception_behavior_t kExceptionBehavior =
|
||
EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES;
|
||
|
||
EXPECT_CALL(
|
||
server,
|
||
MockCatchMachException(kExceptionBehavior,
|
||
kServerLocalPort,
|
||
kExceptionThreadPort,
|
||
kExceptionTaskPort,
|
||
kExceptionType,
|
||
AreExceptionCodes(kTestMachExceptionCodes[0],
|
||
kTestMachExceptionCodes[1]),
|
||
Pointee(Eq(kThreadStateFlavor)),
|
||
IsThreadStateAndCount(kThreadStateFlavorCount),
|
||
IsThreadStateAndCount(arraysize(reply.new_state)),
|
||
Eq(request.Trailer())))
|
||
.WillOnce(Return(KERN_SUCCESS))
|
||
.RetiresOnSaturation();
|
||
|
||
bool destroy_complex_request = false;
|
||
EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
|
||
reinterpret_cast<mach_msg_header_t*>(&request),
|
||
reinterpret_cast<mach_msg_header_t*>(&reply),
|
||
&destroy_complex_request));
|
||
EXPECT_TRUE(destroy_complex_request);
|
||
|
||
reply.Verify(kExceptionBehavior);
|
||
}
|
||
|
||
TEST(ExcServerVariants, MockUnknownID) {
|
||
ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
|
||
|
||
MockUniversalMachExcServer server;
|
||
UniversalMachExcServer universal_mach_exc_server(&server);
|
||
|
||
// Make sure that a message with an unknown ID is handled appropriately.
|
||
// UniversalMachExcServer should not dispatch the message to
|
||
// MachMessageServerFunction, but should generate a MIG_BAD_ID error reply.
|
||
|
||
const mach_msg_id_t unknown_ids[] = {
|
||
// Reasonable things to check.
|
||
-101,
|
||
-100,
|
||
-99,
|
||
-1,
|
||
0,
|
||
1,
|
||
99,
|
||
100,
|
||
101,
|
||
|
||
// Invalid IDs right around valid ones.
|
||
2400,
|
||
2404,
|
||
2408,
|
||
|
||
// Valid and invalid IDs in the range used for replies, not requests.
|
||
2500,
|
||
2501,
|
||
2502,
|
||
2503,
|
||
2504,
|
||
2505,
|
||
2506,
|
||
2507,
|
||
2508,
|
||
};
|
||
|
||
for (size_t index = 0; index < arraysize(unknown_ids); ++index) {
|
||
mach_msg_id_t id = unknown_ids[index];
|
||
|
||
SCOPED_TRACE(base::StringPrintf("unknown id %d", id));
|
||
|
||
std::set<mach_msg_id_t> ids =
|
||
universal_mach_exc_server.MachMessageServerRequestIDs();
|
||
EXPECT_EQ(ids.end(), ids.find(id));
|
||
|
||
InvalidRequest request(id);
|
||
EXPECT_LE(sizeof(request),
|
||
universal_mach_exc_server.MachMessageServerRequestSize());
|
||
|
||
BadIDErrorReply reply;
|
||
EXPECT_LE(sizeof(reply),
|
||
universal_mach_exc_server.MachMessageServerReplySize());
|
||
|
||
bool destroy_complex_request = false;
|
||
EXPECT_FALSE(universal_mach_exc_server.MachMessageServerFunction(
|
||
reinterpret_cast<mach_msg_header_t*>(&request),
|
||
reinterpret_cast<mach_msg_header_t*>(&reply),
|
||
&destroy_complex_request));
|
||
|
||
// The request wasn’t handled, nothing got a chance to change the value of
|
||
// this variable. MachMessageServer would destroy the request if it was
|
||
// complex, regardless of what was done to this variable, because the
|
||
// return code was not KERN_SUCCESS or MIG_NO_REPLY.
|
||
EXPECT_FALSE(destroy_complex_request);
|
||
|
||
reply.Verify(id);
|
||
}
|
||
}
|
||
|
||
TEST(ExcServerVariants, MachMessageServerRequestIDs) {
|
||
std::set<mach_msg_id_t> expect_request_ids;
|
||
|
||
// There are no constants for these.
|
||
expect_request_ids.insert(2401);
|
||
expect_request_ids.insert(2402);
|
||
expect_request_ids.insert(2403);
|
||
expect_request_ids.insert(2405);
|
||
expect_request_ids.insert(2406);
|
||
expect_request_ids.insert(2407);
|
||
|
||
MockUniversalMachExcServer server;
|
||
UniversalMachExcServer universal_mach_exc_server(&server);
|
||
|
||
EXPECT_EQ(expect_request_ids,
|
||
universal_mach_exc_server.MachMessageServerRequestIDs());
|
||
}
|
||
|
||
class TestExcServerVariants : public MachMultiprocess,
|
||
public UniversalMachExcServer::Interface {
|
||
public:
|
||
TestExcServerVariants(exception_behavior_t behavior,
|
||
thread_state_flavor_t flavor,
|
||
mach_msg_type_number_t state_count)
|
||
: MachMultiprocess(),
|
||
UniversalMachExcServer::Interface(),
|
||
behavior_(behavior),
|
||
flavor_(flavor),
|
||
state_count_(state_count),
|
||
handled_(false) {}
|
||
|
||
// UniversalMachExcServer::Interface:
|
||
|
||
virtual kern_return_t CatchMachException(
|
||
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) override {
|
||
*destroy_complex_request = true;
|
||
|
||
EXPECT_FALSE(handled_);
|
||
handled_ = true;
|
||
|
||
EXPECT_EQ(behavior_, behavior);
|
||
|
||
EXPECT_EQ(LocalPort(), exception_port);
|
||
|
||
if (ExceptionBehaviorHasIdentity(behavior)) {
|
||
EXPECT_NE(THREAD_NULL, thread);
|
||
EXPECT_EQ(ChildTask(), task);
|
||
} else {
|
||
EXPECT_EQ(THREAD_NULL, thread);
|
||
EXPECT_EQ(TASK_NULL, task);
|
||
}
|
||
|
||
EXPECT_EQ(EXC_CRASH, exception);
|
||
EXPECT_EQ(2u, code_count);
|
||
|
||
// The exception and code_count checks above would ideally use ASSERT_EQ so
|
||
// that the next conditional would not be necessary, but ASSERT_* requires a
|
||
// function returning type void, and the interface dictates otherwise here.
|
||
if (exception == EXC_CRASH && code_count >= 1) {
|
||
int signal;
|
||
ExcCrashRecoverOriginalException(code[0], nullptr, &signal);
|
||
SetExpectedChildTermination(kTerminationSignal, signal);
|
||
}
|
||
|
||
const bool has_state = ExceptionBehaviorHasState(behavior);
|
||
if (has_state) {
|
||
EXPECT_EQ(flavor_, *flavor);
|
||
EXPECT_EQ(state_count_, old_state_count);
|
||
EXPECT_NE(nullptr, old_state);
|
||
EXPECT_EQ(implicit_cast<mach_msg_type_number_t>(THREAD_STATE_MAX),
|
||
*new_state_count);
|
||
EXPECT_NE(nullptr, new_state);
|
||
} else {
|
||
EXPECT_EQ(THREAD_STATE_NONE, *flavor);
|
||
EXPECT_EQ(0u, old_state_count);
|
||
EXPECT_EQ(nullptr, old_state);
|
||
EXPECT_EQ(0u, *new_state_count);
|
||
EXPECT_EQ(nullptr, new_state);
|
||
}
|
||
|
||
EXPECT_EQ(implicit_cast<mach_msg_trailer_type_t>(MACH_MSG_TRAILER_FORMAT_0),
|
||
trailer->msgh_trailer_type);
|
||
EXPECT_EQ(REQUESTED_TRAILER_SIZE(kMachMessageOptions),
|
||
trailer->msgh_trailer_size);
|
||
|
||
ExcServerCopyState(
|
||
behavior, old_state, old_state_count, new_state, new_state_count);
|
||
|
||
return ExcServerSuccessfulReturnValue(exception, behavior, false);
|
||
}
|
||
|
||
private:
|
||
// MachMultiprocess:
|
||
|
||
void MachMultiprocessParent() override {
|
||
UniversalMachExcServer universal_mach_exc_server(this);
|
||
|
||
kern_return_t kr =
|
||
MachMessageServer::Run(&universal_mach_exc_server,
|
||
LocalPort(),
|
||
kMachMessageOptions,
|
||
MachMessageServer::kOneShot,
|
||
MachMessageServer::kReceiveLargeError,
|
||
kMachMessageTimeoutWaitIndefinitely);
|
||
EXPECT_EQ(KERN_SUCCESS, kr)
|
||
<< MachErrorMessage(kr, "MachMessageServer::Run");
|
||
|
||
EXPECT_TRUE(handled_);
|
||
}
|
||
|
||
void MachMultiprocessChild() override {
|
||
// Set the parent as the exception handler for EXC_CRASH.
|
||
kern_return_t kr = task_set_exception_ports(
|
||
mach_task_self(), EXC_MASK_CRASH, RemotePort(), behavior_, flavor_);
|
||
ASSERT_EQ(KERN_SUCCESS, kr)
|
||
<< MachErrorMessage(kr, "task_set_exception_ports");
|
||
|
||
// Now crash.
|
||
__builtin_trap();
|
||
}
|
||
|
||
exception_behavior_t behavior_;
|
||
thread_state_flavor_t flavor_;
|
||
mach_msg_type_number_t state_count_;
|
||
bool handled_;
|
||
|
||
static const mach_msg_option_t kMachMessageOptions =
|
||
MACH_RCV_TRAILER_TYPE(MACH_MSG_TRAILER_FORMAT_0);
|
||
|
||
DISALLOW_COPY_AND_ASSIGN(TestExcServerVariants);
|
||
};
|
||
|
||
TEST(ExcServerVariants, ExceptionRaise) {
|
||
TestExcServerVariants test_exc_server_variants(
|
||
EXCEPTION_DEFAULT, THREAD_STATE_NONE, 0);
|
||
test_exc_server_variants.Run();
|
||
}
|
||
|
||
TEST(ExcServerVariants, ExceptionRaiseState) {
|
||
TestExcServerVariants test_exc_server_variants(
|
||
EXCEPTION_STATE, MACHINE_THREAD_STATE, MACHINE_THREAD_STATE_COUNT);
|
||
test_exc_server_variants.Run();
|
||
}
|
||
|
||
TEST(ExcServerVariants, ExceptionRaiseStateIdentity) {
|
||
TestExcServerVariants test_exc_server_variants(EXCEPTION_STATE_IDENTITY,
|
||
MACHINE_THREAD_STATE,
|
||
MACHINE_THREAD_STATE_COUNT);
|
||
test_exc_server_variants.Run();
|
||
}
|
||
|
||
TEST(ExcServerVariants, MachExceptionRaise) {
|
||
TestExcServerVariants test_exc_server_variants(
|
||
MACH_EXCEPTION_CODES | EXCEPTION_DEFAULT, THREAD_STATE_NONE, 0);
|
||
test_exc_server_variants.Run();
|
||
}
|
||
|
||
TEST(ExcServerVariants, MachExceptionRaiseState) {
|
||
TestExcServerVariants test_exc_server_variants(
|
||
MACH_EXCEPTION_CODES | EXCEPTION_STATE,
|
||
MACHINE_THREAD_STATE,
|
||
MACHINE_THREAD_STATE_COUNT);
|
||
test_exc_server_variants.Run();
|
||
}
|
||
|
||
TEST(ExcServerVariants, MachExceptionRaiseStateIdentity) {
|
||
TestExcServerVariants test_exc_server_variants(
|
||
MACH_EXCEPTION_CODES | EXCEPTION_STATE_IDENTITY,
|
||
MACHINE_THREAD_STATE,
|
||
MACHINE_THREAD_STATE_COUNT);
|
||
test_exc_server_variants.Run();
|
||
}
|
||
|
||
TEST(ExcServerVariants, ThreadStates) {
|
||
// So far, all of the tests worked with MACHINE_THREAD_STATE. Now try all of
|
||
// the other thread state flavors that are expected to work.
|
||
|
||
struct TestData {
|
||
thread_state_flavor_t flavor;
|
||
mach_msg_type_number_t count;
|
||
};
|
||
const TestData test_data[] = {
|
||
#if defined(ARCH_CPU_X86_FAMILY)
|
||
// For the x86 family, exception handlers can only properly receive the
|
||
// thread, float, and exception state flavors. There’s a bug in the kernel
|
||
// that causes it to call thread_getstatus() (a wrapper for the more
|
||
// familiar thread_get_state()) with an incorrect state buffer size
|
||
// parameter when delivering an exception. 10.9.4
|
||
// xnu-2422.110.17/osfmk/kern/exception.c exception_deliver() uses the
|
||
// _MachineStateCount[] array indexed by the flavor number to obtain the
|
||
// buffer size. 10.9.4 xnu-2422.110.17/osfmk/i386/pcb.c contains the
|
||
// definition of this array for the x86 family. The slots corresponding to
|
||
// thread, float, and exception state flavors in both native-width (32-
|
||
// and 64-bit) and universal are correct, but the remaining elements in
|
||
// the array are not. This includes elements that would correspond to
|
||
// debug and AVX state flavors, so these cannot be tested here.
|
||
//
|
||
// When machine_thread_get_state() (the machine-specific implementation of
|
||
// thread_get_state()) encounters an undersized buffer as reported by the
|
||
// buffer size parameter, it returns KERN_INVALID_ARGUMENT, which causes
|
||
// exception_deliver() to not actually deliver the exception and instead
|
||
// return that error code to exception_triage() as well.
|
||
//
|
||
// This bug is filed as radar 18312067.
|
||
//
|
||
// Additionaly, the AVX state flavors are also not tested because they’re
|
||
// not available on all CPUs and OS versions.
|
||
#if defined(ARCH_CPU_X86)
|
||
{x86_THREAD_STATE32, x86_THREAD_STATE32_COUNT},
|
||
{x86_FLOAT_STATE32, x86_FLOAT_STATE32_COUNT},
|
||
{x86_EXCEPTION_STATE32, x86_EXCEPTION_STATE32_COUNT},
|
||
#endif
|
||
#if defined(ARCH_CPU_X86_64)
|
||
{x86_THREAD_STATE64, x86_THREAD_STATE64_COUNT},
|
||
{x86_FLOAT_STATE64, x86_FLOAT_STATE64_COUNT},
|
||
{x86_EXCEPTION_STATE64, x86_EXCEPTION_STATE64_COUNT},
|
||
#endif
|
||
{x86_THREAD_STATE, x86_THREAD_STATE_COUNT},
|
||
{x86_FLOAT_STATE, x86_FLOAT_STATE_COUNT},
|
||
{x86_EXCEPTION_STATE, x86_EXCEPTION_STATE_COUNT},
|
||
#else
|
||
#error Port this test to your CPU architecture.
|
||
#endif
|
||
};
|
||
|
||
for (size_t index = 0; index < arraysize(test_data); ++index) {
|
||
const TestData& test = test_data[index];
|
||
SCOPED_TRACE(
|
||
base::StringPrintf("index %zu, flavor %d", index, test.flavor));
|
||
|
||
TestExcServerVariants test_exc_server_variants(
|
||
MACH_EXCEPTION_CODES | EXCEPTION_STATE_IDENTITY,
|
||
test.flavor,
|
||
test.count);
|
||
test_exc_server_variants.Run();
|
||
}
|
||
}
|
||
|
||
TEST(ExcServerVariants, ExcServerSuccessfulReturnValue) {
|
||
const kern_return_t prefer_not_set_thread_state =
|
||
MacOSXMinorVersion() < 11 ? MACH_RCV_PORT_DIED : KERN_SUCCESS;
|
||
|
||
struct TestData {
|
||
exception_type_t exception;
|
||
exception_behavior_t behavior;
|
||
bool set_thread_state;
|
||
kern_return_t kr;
|
||
};
|
||
const TestData kTestData[] = {
|
||
{EXC_CRASH, EXCEPTION_DEFAULT, false, KERN_SUCCESS},
|
||
{EXC_CRASH, EXCEPTION_STATE, false, prefer_not_set_thread_state},
|
||
{EXC_CRASH, EXCEPTION_STATE_IDENTITY, false, prefer_not_set_thread_state},
|
||
{EXC_CRASH, kMachExceptionCodes | EXCEPTION_DEFAULT, false, KERN_SUCCESS},
|
||
{EXC_CRASH,
|
||
kMachExceptionCodes | EXCEPTION_STATE,
|
||
false,
|
||
prefer_not_set_thread_state},
|
||
{EXC_CRASH,
|
||
kMachExceptionCodes | EXCEPTION_STATE_IDENTITY,
|
||
false,
|
||
prefer_not_set_thread_state},
|
||
{EXC_CRASH, EXCEPTION_DEFAULT, true, KERN_SUCCESS},
|
||
{EXC_CRASH, EXCEPTION_STATE, true, KERN_SUCCESS},
|
||
{EXC_CRASH, EXCEPTION_STATE_IDENTITY, true, KERN_SUCCESS},
|
||
{EXC_CRASH, kMachExceptionCodes | EXCEPTION_DEFAULT, true, KERN_SUCCESS},
|
||
{EXC_CRASH, kMachExceptionCodes | EXCEPTION_STATE, true, KERN_SUCCESS},
|
||
{EXC_CRASH,
|
||
kMachExceptionCodes | EXCEPTION_STATE_IDENTITY,
|
||
true,
|
||
KERN_SUCCESS},
|
||
{EXC_BAD_ACCESS, EXCEPTION_DEFAULT, false, KERN_SUCCESS},
|
||
{EXC_BAD_INSTRUCTION, EXCEPTION_STATE, false, MACH_RCV_PORT_DIED},
|
||
{EXC_ARITHMETIC, EXCEPTION_STATE_IDENTITY, false, MACH_RCV_PORT_DIED},
|
||
{EXC_EMULATION,
|
||
kMachExceptionCodes | EXCEPTION_DEFAULT,
|
||
false,
|
||
KERN_SUCCESS},
|
||
{EXC_SOFTWARE,
|
||
kMachExceptionCodes | EXCEPTION_STATE,
|
||
false,
|
||
MACH_RCV_PORT_DIED},
|
||
{EXC_BREAKPOINT,
|
||
kMachExceptionCodes | EXCEPTION_STATE_IDENTITY,
|
||
false,
|
||
MACH_RCV_PORT_DIED},
|
||
{EXC_SYSCALL, EXCEPTION_DEFAULT, true, KERN_SUCCESS},
|
||
{EXC_MACH_SYSCALL, EXCEPTION_STATE, true, KERN_SUCCESS},
|
||
{EXC_RPC_ALERT, EXCEPTION_STATE_IDENTITY, true, KERN_SUCCESS},
|
||
{EXC_RESOURCE,
|
||
kMachExceptionCodes | EXCEPTION_DEFAULT,
|
||
true,
|
||
KERN_SUCCESS},
|
||
{EXC_GUARD, kMachExceptionCodes | EXCEPTION_STATE, true, KERN_SUCCESS},
|
||
{EXC_CORPSE_NOTIFY,
|
||
kMachExceptionCodes | EXCEPTION_STATE_IDENTITY,
|
||
true,
|
||
KERN_SUCCESS},
|
||
};
|
||
|
||
for (size_t index = 0; index < arraysize(kTestData); ++index) {
|
||
const TestData& test_data = kTestData[index];
|
||
SCOPED_TRACE(
|
||
base::StringPrintf("index %zu, behavior %d, set_thread_state %s",
|
||
index,
|
||
test_data.behavior,
|
||
test_data.set_thread_state ? "true" : "false"));
|
||
|
||
EXPECT_EQ(test_data.kr,
|
||
ExcServerSuccessfulReturnValue(test_data.exception,
|
||
test_data.behavior,
|
||
test_data.set_thread_state));
|
||
}
|
||
}
|
||
|
||
TEST(ExcServerVariants, ExcServerCopyState) {
|
||
const natural_t old_state[] = {1, 2, 3, 4, 5};
|
||
natural_t new_state[10] = {};
|
||
|
||
const mach_msg_type_number_t old_state_count = arraysize(old_state);
|
||
mach_msg_type_number_t new_state_count = arraysize(new_state);
|
||
|
||
// EXCEPTION_DEFAULT (with or without MACH_EXCEPTION_CODES) is not
|
||
// state-carrying. new_state and new_state_count should be untouched.
|
||
ExcServerCopyState(EXCEPTION_DEFAULT,
|
||
old_state,
|
||
old_state_count,
|
||
new_state,
|
||
&new_state_count);
|
||
EXPECT_EQ(arraysize(new_state), new_state_count);
|
||
for (size_t i = 0; i < arraysize(new_state); ++i) {
|
||
EXPECT_EQ(0u, new_state[i]) << "i " << i;
|
||
}
|
||
|
||
ExcServerCopyState(MACH_EXCEPTION_CODES | EXCEPTION_DEFAULT,
|
||
old_state,
|
||
old_state_count,
|
||
new_state,
|
||
&new_state_count);
|
||
EXPECT_EQ(arraysize(new_state), new_state_count);
|
||
for (size_t i = 0; i < arraysize(new_state); ++i) {
|
||
EXPECT_EQ(0u, new_state[i]) << "i " << i;
|
||
}
|
||
|
||
// This is a state-carrying exception where old_state_count is small.
|
||
mach_msg_type_number_t copy_limit = 2;
|
||
ExcServerCopyState(
|
||
EXCEPTION_STATE, old_state, copy_limit, new_state, &new_state_count);
|
||
EXPECT_EQ(copy_limit, new_state_count);
|
||
for (size_t i = 0; i < copy_limit; ++i) {
|
||
EXPECT_EQ(old_state[i], new_state[i]) << "i " << i;
|
||
}
|
||
for (size_t i = copy_limit; i < arraysize(new_state); ++i) {
|
||
EXPECT_EQ(0u, new_state[i]) << "i " << i;
|
||
}
|
||
|
||
// This is a state-carrying exception where new_state_count is small.
|
||
copy_limit = 3;
|
||
new_state_count = copy_limit;
|
||
ExcServerCopyState(EXCEPTION_STATE_IDENTITY,
|
||
old_state,
|
||
old_state_count,
|
||
new_state,
|
||
&new_state_count);
|
||
EXPECT_EQ(copy_limit, new_state_count);
|
||
for (size_t i = 0; i < copy_limit; ++i) {
|
||
EXPECT_EQ(old_state[i], new_state[i]) << "i " << i;
|
||
}
|
||
for (size_t i = copy_limit; i < arraysize(new_state); ++i) {
|
||
EXPECT_EQ(0u, new_state[i]) << "i " << i;
|
||
}
|
||
|
||
// This is a state-carrying exception where all of old_state is copied to
|
||
// new_state, which is large enough to receive it and then some.
|
||
new_state_count = arraysize(new_state);
|
||
ExcServerCopyState(MACH_EXCEPTION_CODES | EXCEPTION_STATE_IDENTITY,
|
||
old_state,
|
||
old_state_count,
|
||
new_state,
|
||
&new_state_count);
|
||
EXPECT_EQ(old_state_count, new_state_count);
|
||
for (size_t i = 0; i < arraysize(old_state); ++i) {
|
||
EXPECT_EQ(old_state[i], new_state[i]) << "i " << i;
|
||
}
|
||
for (size_t i = arraysize(old_state); i < arraysize(new_state); ++i) {
|
||
EXPECT_EQ(0u, new_state[i]) << "i " << i;
|
||
}
|
||
}
|
||
|
||
} // namespace
|
||
} // namespace test
|
||
} // namespace crashpad
|