// Copyright 2014 The Crashpad Authors
//
// 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_client_variants.h"
#include <mach/mach.h>
#include <pthread.h>
#include <string.h>
#include <sys/types.h>
#include <iterator>
#include "base/strings/stringprintf.h"
#include "gtest/gtest.h"
#include "test/mac/mach_errors.h"
#include "test/mac/mach_multiprocess.h"
#include "util/mach/exc_server_variants.h"
#include "util/mach/exception_behaviors.h"
#include "util/mach/mach_extensions.h"
#include "util/mach/mach_message.h"
#include "util/mach/mach_message_server.h"
#include "util/misc/implicit_cast.h"
namespace crashpad {
namespace test {
namespace {
class TestExcClientVariants : public MachMultiprocess,
public UniversalMachExcServer::Interface {
public:
TestExcClientVariants(exception_behavior_t behavior, bool all_fields)
: MachMultiprocess(),
UniversalMachExcServer::Interface(),
behavior_(behavior),
all_fields_(all_fields),
handled_(false) {
++exception_;
++exception_code_;
++exception_subcode_;
}
TestExcClientVariants(const TestExcClientVariants&) = delete;
TestExcClientVariants& operator=(const TestExcClientVariants&) = delete;
// 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(exception_port, LocalPort());
if (HasIdentity()) {
EXPECT_NE(thread, THREAD_NULL);
EXPECT_EQ(task, ChildTask());
} else {
EXPECT_EQ(thread, THREAD_NULL);
EXPECT_EQ(task, TASK_NULL);
}
mach_exception_code_t expect_code = exception_code_;
mach_exception_subcode_t expect_subcode = exception_subcode_;
if ((behavior & MACH_EXCEPTION_CODES) == 0) {
expect_code = implicit_cast<exception_data_type_t>(expect_code);
expect_subcode = implicit_cast<exception_data_type_t>(expect_subcode);
}
EXPECT_EQ(exception, exception_);
EXPECT_EQ(code_count, 2u);
// The code_count check above would ideally use ASSERT_EQ so that the next
// conditionals would not be necessary, but ASSERT_* requires a function
// returning type void, and the interface dictates otherwise here.
if (code_count >= 1) {
EXPECT_EQ(code[0], expect_code);
}
if (code_count >= 2) {
EXPECT_EQ(code[1], expect_subcode);
}
if (HasState()) {
EXPECT_EQ(*flavor, exception_ + 10);
EXPECT_EQ(old_state_count, MACHINE_THREAD_STATE_COUNT);
EXPECT_NE(old_state, nullptr);
EXPECT_EQ(*new_state_count,
implicit_cast<mach_msg_type_number_t>(THREAD_STATE_MAX));
EXPECT_NE(new_state, nullptr);
for (size_t index = 0; index < old_state_count; ++index) {
EXPECT_EQ(old_state[index], index);
}
// Use a flavor known to be different from the incoming flavor, for a test
// of the “out” side of the in-out flavor parameter.
*flavor = exception_ + 20;
*new_state_count = MACHINE_THREAD_STATE_COUNT;
// Send a new state back to the client.
for (size_t index = 0; index < *new_state_count; ++index) {
new_state[index] = MACHINE_THREAD_STATE_COUNT - index;
}
} else {
EXPECT_EQ(*flavor, THREAD_STATE_NONE);
EXPECT_EQ(old_state_count, 0u);
EXPECT_EQ(old_state, nullptr);
EXPECT_EQ(*new_state_count, 0u);
EXPECT_EQ(new_state, nullptr);
}
return KERN_SUCCESS;
}
private:
// MachMultiprocess:
void MachMultiprocessParent() override {
UniversalMachExcServer universal_mach_exc_server(this);
kern_return_t kr =
MachMessageServer::Run(&universal_mach_exc_server,
LocalPort(),
MACH_MSG_OPTION_NONE,
MachMessageServer::kOneShot,
MachMessageServer::kReceiveLargeError,
kMachMessageTimeoutWaitIndefinitely);
EXPECT_EQ(kr, KERN_SUCCESS)
<< MachErrorMessage(kr, "MachMessageServer::Run");
EXPECT_TRUE(handled_);
}
void MachMultiprocessChild() override {
const exception_type_t exception = exception_;
const mach_exception_data_type_t code[] = {
exception_code_,
exception_subcode_
};
thread_t thread = THREAD_NULL;
task_t task = TASK_NULL;
if (all_fields_ || HasIdentity()) {
thread = MachThreadSelf();
task = mach_task_self();
}
thread_state_flavor_t flavor;
thread_state_flavor_t* flavor_p = nullptr;
natural_t old_state[MACHINE_THREAD_STATE_COUNT];
thread_state_t old_state_p = nullptr;
mach_msg_type_number_t old_state_count = 0;
natural_t new_state[THREAD_STATE_MAX];
thread_state_t new_state_p = nullptr;
mach_msg_type_number_t new_state_count;
mach_msg_type_number_t* new_state_count_p = nullptr;
if (all_fields_ || HasState()) {
// Pick a different flavor each time based on the value of exception_.
// These aren’t real flavors, it’s just for testing.
flavor = exception_ + 10;
flavor_p = &flavor;
for (size_t index = 0; index < std::size(old_state); ++index) {
old_state[index] = index;
}
old_state_p = reinterpret_cast<thread_state_t>(&old_state);
old_state_count = std::size(old_state);
// new_state and new_state_count are out parameters that the server should
// never see or use, so set them to bogus values. The call to the server
// should overwrite these.
memset(new_state, 0xa5, sizeof(new_state));
new_state_p = reinterpret_cast<thread_state_t>(&new_state);
new_state_count = 0x5a;
new_state_count_p = &new_state_count;
}
EXPECT_EQ(UniversalExceptionRaise(behavior_,
RemotePort(),
thread,
task,
exception,
code,
std::size(code),
flavor_p,
old_state_p,
old_state_count,
new_state_p,
new_state_count_p),
KERN_SUCCESS);
if (HasState()) {
// Verify the out parameters.
EXPECT_EQ(flavor, exception_ + 20);
EXPECT_EQ(new_state_count, MACHINE_THREAD_STATE_COUNT);
for (size_t index = 0; index < new_state_count; ++index) {
EXPECT_EQ(new_state[index], MACHINE_THREAD_STATE_COUNT - index);
}
}
}
bool HasIdentity() const {
return ExceptionBehaviorHasIdentity(behavior_);
}
bool HasState() const {
return ExceptionBehaviorHasState(behavior_);
}
// The behavior to test.
exception_behavior_t behavior_;
// If false, only fields required for the current value of behavior_ are set
// in a call to UniversalExceptionRaise(). The thread and task fields are only
// set for identity-carrying behaviors, and the flavor and state fields are
// only set for state-carrying behaviors. If true, all fields are set
// regardless of the behavior. Testing in both ways verifies that
// UniversalExceptionRaise() can tolerate the null arguments documented as
// usable when the behavior allows it, and that it ignores these arguments
// even when set when the behavior does not make use of them.
bool all_fields_;
// true if an exception message was handled.
bool handled_;
// These fields will increment for each instantiation of the test class.
static exception_type_t exception_;
static mach_exception_code_t exception_code_;
static mach_exception_subcode_t exception_subcode_;
};
exception_type_t TestExcClientVariants::exception_ = 0;
// exception_code_ and exception_subcode_ are always large enough to require
// 64 bits, so that when the 32-bit-only variants not using MACH_EXCEPITON_CODES
// are tested, the code and subcode fields can be checked for proper truncation.
mach_exception_code_t TestExcClientVariants::exception_code_ = 0x100000000;
mach_exception_subcode_t TestExcClientVariants::exception_subcode_ =
0xffffffff00000000;
TEST(ExcClientVariants, UniversalExceptionRaise) {
static constexpr exception_behavior_t kBehaviors[] = {
EXCEPTION_DEFAULT,
EXCEPTION_STATE,
EXCEPTION_STATE_IDENTITY,
kMachExceptionCodes | EXCEPTION_DEFAULT,
kMachExceptionCodes | EXCEPTION_STATE,
kMachExceptionCodes | EXCEPTION_STATE_IDENTITY,
};
for (size_t index = 0; index < std::size(kBehaviors); ++index) {
exception_behavior_t behavior = kBehaviors[index];
SCOPED_TRACE(base::StringPrintf("index %zu, behavior %d", index, behavior));
{
SCOPED_TRACE("all_fields = false");
TestExcClientVariants test_exc_client_variants(behavior, false);
test_exc_client_variants.Run();
}
{
SCOPED_TRACE("all_fields = true");
TestExcClientVariants test_exc_client_variants(behavior, true);
test_exc_client_variants.Run();
}
}
}
} // namespace
} // namespace test
} // namespace crashpad
Codebase Browser
chromium