mirror of
https://github.com/chromium/crashpad.git
synced 2024-12-27 07:14:10 +08:00
6a9e2e6003
This CL rolls mini_chromium to pick up the move of a bunch of files to base/apple, and makes changes to adjust. Bug: chromium:1444927 Change-Id: Ib692e2a1628e2c0c8228795eaecdb7f35b1c09fa Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/4786387 Reviewed-by: Mark Mentovai <mark@chromium.org> Commit-Queue: Avi Drissman <avi@chromium.org>
847 lines
31 KiB
C++
847 lines
31 KiB
C++
// 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/exception_ports.h"
|
||
|
||
#include <mach/mach.h>
|
||
#include <pthread.h>
|
||
#include <signal.h>
|
||
#include <unistd.h>
|
||
|
||
#include "base/apple/mach_logging.h"
|
||
#include "base/apple/scoped_mach_port.h"
|
||
#include "base/check.h"
|
||
#include "base/notreached.h"
|
||
#include "build/build_config.h"
|
||
#include "gtest/gtest.h"
|
||
#include "test/mac/mach_errors.h"
|
||
#include "test/mac/mach_multiprocess.h"
|
||
#include "util/file/file_io.h"
|
||
#include "util/mach/exc_server_variants.h"
|
||
#include "util/mach/exception_types.h"
|
||
#include "util/mach/mach_extensions.h"
|
||
#include "util/mach/mach_message.h"
|
||
#include "util/mach/mach_message_server.h"
|
||
#include "util/misc/scoped_forbid_return.h"
|
||
#include "util/synchronization/semaphore.h"
|
||
|
||
namespace crashpad {
|
||
namespace test {
|
||
namespace {
|
||
|
||
// Calls GetExceptionPorts() on its |exception_ports| argument to look up the
|
||
// EXC_MASK_CRASH handler. If |expect_port| is not MACH_PORT_NULL, it expects to
|
||
// find a handler for this mask whose port matches |expect_port| and whose
|
||
// behavior matches |expect_behavior| exactly. In this case, if
|
||
// |expect_behavior| is a state-carrying behavior, the looked-up thread state
|
||
// flavor is expected to be MACHINE_THREAD_STATE, otherwise, it is expected to
|
||
// be THREAD_STATE_NONE. If |expect_port| is MACH_PORT_NULL, no handler for
|
||
// EXC_MASK_CRASH is expected to be found.
|
||
//
|
||
// A second GetExceptionPorts() lookup is also performed on a wider exception
|
||
// mask, EXC_MASK_ALL | EXC_MASK_CRASH. The EXC_MASK_CRASH handler’s existence
|
||
// and properties from this second lookup are validated in the same way.
|
||
//
|
||
// This function uses Google Test EXPECT_* and ASSERT_* macros to perform its
|
||
// validation.
|
||
void TestGetExceptionPorts(const ExceptionPorts& exception_ports,
|
||
mach_port_t expect_port,
|
||
exception_behavior_t expect_behavior) {
|
||
constexpr exception_mask_t kExceptionMask = EXC_MASK_CRASH;
|
||
|
||
thread_state_flavor_t expect_flavor = (expect_behavior == EXCEPTION_DEFAULT)
|
||
? THREAD_STATE_NONE
|
||
: MACHINE_THREAD_STATE;
|
||
|
||
ExceptionPorts::ExceptionHandlerVector crash_handler;
|
||
ASSERT_TRUE(
|
||
exception_ports.GetExceptionPorts(kExceptionMask, &crash_handler));
|
||
|
||
if (expect_port != MACH_PORT_NULL) {
|
||
ASSERT_EQ(crash_handler.size(), 1u);
|
||
|
||
EXPECT_EQ(crash_handler[0].mask, kExceptionMask);
|
||
EXPECT_EQ(crash_handler[0].port, expect_port);
|
||
EXPECT_EQ(crash_handler[0].behavior, expect_behavior);
|
||
EXPECT_EQ(crash_handler[0].flavor, expect_flavor);
|
||
} else {
|
||
EXPECT_TRUE(crash_handler.empty());
|
||
}
|
||
|
||
ExceptionPorts::ExceptionHandlerVector handlers;
|
||
ASSERT_TRUE(exception_ports.GetExceptionPorts(ExcMaskValid(), &handlers));
|
||
|
||
EXPECT_GE(handlers.size(), crash_handler.size());
|
||
bool found = false;
|
||
for (const ExceptionPorts::ExceptionHandler& handler : handlers) {
|
||
if ((handler.mask & kExceptionMask) != 0) {
|
||
EXPECT_FALSE(found);
|
||
found = true;
|
||
EXPECT_EQ(handler.port, expect_port);
|
||
EXPECT_EQ(handler.behavior, expect_behavior);
|
||
EXPECT_EQ(handler.flavor, expect_flavor);
|
||
}
|
||
}
|
||
|
||
if (expect_port != MACH_PORT_NULL) {
|
||
EXPECT_TRUE(found);
|
||
} else {
|
||
EXPECT_FALSE(found);
|
||
}
|
||
}
|
||
|
||
class TestExceptionPorts : public MachMultiprocess,
|
||
public UniversalMachExcServer::Interface {
|
||
public:
|
||
// Whether to call SetExceptionPort or SwapExceptionPorts.
|
||
enum SetOrSwap {
|
||
kSetExceptionPort = 0,
|
||
kSwapExceptionPorts,
|
||
};
|
||
|
||
// Which entities to set exception ports for.
|
||
enum SetOn {
|
||
kSetOnTaskOnly = 0,
|
||
kSetOnTaskAndThreads,
|
||
};
|
||
|
||
// Where to call ExceptionPorts::SetExceptionPort() from.
|
||
enum SetType {
|
||
// Call it from the child process on itself.
|
||
kSetInProcess = 0,
|
||
|
||
// Call it from the parent process on the child.
|
||
kSetOutOfProcess,
|
||
};
|
||
|
||
// Which thread in the child process is expected to crash.
|
||
enum WhoCrashes {
|
||
kNobodyCrashes = 0,
|
||
kMainThreadCrashes,
|
||
kOtherThreadCrashes,
|
||
};
|
||
|
||
TestExceptionPorts(SetOrSwap set_or_swap,
|
||
SetOn set_on,
|
||
SetType set_type,
|
||
WhoCrashes who_crashes)
|
||
: MachMultiprocess(),
|
||
UniversalMachExcServer::Interface(),
|
||
set_or_swap_(set_or_swap),
|
||
set_on_(set_on),
|
||
set_type_(set_type),
|
||
who_crashes_(who_crashes),
|
||
handled_(false) {
|
||
if (who_crashes_ != kNobodyCrashes) {
|
||
SetExpectedChildTerminationBuiltinTrap();
|
||
}
|
||
}
|
||
|
||
TestExceptionPorts(const TestExceptionPorts&) = delete;
|
||
TestExceptionPorts& operator=(const TestExceptionPorts&) = delete;
|
||
|
||
SetOrSwap set_or_swap() const { return set_or_swap_; }
|
||
SetOn set_on() const { return set_on_; }
|
||
SetType set_type() const { return set_type_; }
|
||
WhoCrashes who_crashes() const { return who_crashes_; }
|
||
|
||
// 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;
|
||
|
||
// To be able to distinguish between which handler was actually triggered,
|
||
// the different handlers are registered with different behavior values.
|
||
exception_behavior_t expect_behavior;
|
||
if (set_on_ == kSetOnTaskOnly) {
|
||
expect_behavior = EXCEPTION_DEFAULT;
|
||
} else if (who_crashes_ == kMainThreadCrashes) {
|
||
expect_behavior = EXCEPTION_STATE;
|
||
} else if (who_crashes_ == kOtherThreadCrashes) {
|
||
expect_behavior = EXCEPTION_STATE_IDENTITY;
|
||
} else {
|
||
NOTREACHED();
|
||
expect_behavior = 0;
|
||
}
|
||
|
||
EXPECT_EQ(behavior, expect_behavior);
|
||
|
||
EXPECT_EQ(exception_port, LocalPort());
|
||
|
||
EXPECT_EQ(exception, EXC_CRASH);
|
||
EXPECT_EQ(code_count, 2u);
|
||
|
||
// 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);
|
||
|
||
#if defined(ARCH_CPU_X86_FAMILY)
|
||
constexpr int kBuiltinTrapSignal = SIGILL;
|
||
#elif defined(ARCH_CPU_ARM64)
|
||
constexpr int kBuiltinTrapSignal = SIGTRAP;
|
||
#else
|
||
#error Port
|
||
#endif
|
||
EXPECT_EQ(signal, kBuiltinTrapSignal);
|
||
}
|
||
|
||
EXPECT_EQ(AuditPIDFromMachMessageTrailer(trailer), 0);
|
||
|
||
ExcServerCopyState(
|
||
behavior, old_state, old_state_count, new_state, new_state_count);
|
||
return ExcServerSuccessfulReturnValue(exception, behavior, false);
|
||
}
|
||
|
||
private:
|
||
class Child {
|
||
public:
|
||
explicit Child(TestExceptionPorts* test_exception_ports)
|
||
: test_exception_ports_(test_exception_ports),
|
||
thread_(),
|
||
init_semaphore_(0),
|
||
crash_semaphore_(0) {}
|
||
|
||
Child(const Child&) = delete;
|
||
Child& operator=(const Child&) = delete;
|
||
|
||
~Child() {}
|
||
|
||
void Run() {
|
||
ExceptionPorts self_task_ports(ExceptionPorts::kTargetTypeTask,
|
||
TASK_NULL);
|
||
ExceptionPorts self_thread_ports(ExceptionPorts::kTargetTypeThread,
|
||
THREAD_NULL);
|
||
|
||
mach_port_t remote_port = test_exception_ports_->RemotePort();
|
||
|
||
// Set the task’s and this thread’s exception ports, if appropriate.
|
||
if (test_exception_ports_->set_type() == kSetInProcess) {
|
||
switch (test_exception_ports_->set_or_swap()) {
|
||
case kSetExceptionPort: {
|
||
ASSERT_TRUE(self_task_ports.SetExceptionPort(EXC_MASK_CRASH,
|
||
remote_port,
|
||
EXCEPTION_DEFAULT,
|
||
THREAD_STATE_NONE));
|
||
|
||
if (test_exception_ports_->set_on() == kSetOnTaskAndThreads) {
|
||
ASSERT_TRUE(
|
||
self_thread_ports.SetExceptionPort(EXC_MASK_CRASH,
|
||
remote_port,
|
||
EXCEPTION_STATE,
|
||
MACHINE_THREAD_STATE));
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
case kSwapExceptionPorts: {
|
||
ExceptionPorts::ExceptionHandlerVector old_handlers;
|
||
ASSERT_TRUE(self_task_ports.SwapExceptionPorts(EXC_MASK_CRASH,
|
||
remote_port,
|
||
EXCEPTION_DEFAULT,
|
||
THREAD_STATE_NONE,
|
||
&old_handlers));
|
||
|
||
if (test_exception_ports_->set_on() == kSetOnTaskAndThreads) {
|
||
ASSERT_TRUE(
|
||
self_thread_ports.SwapExceptionPorts(EXC_MASK_CRASH,
|
||
remote_port,
|
||
EXCEPTION_STATE,
|
||
MACHINE_THREAD_STATE,
|
||
&old_handlers));
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
default: {
|
||
NOTREACHED();
|
||
}
|
||
}
|
||
}
|
||
|
||
int rv_int = pthread_create(&thread_, nullptr, ThreadMainThunk, this);
|
||
ASSERT_EQ(rv_int, 0);
|
||
|
||
// Wait for the new thread to be ready.
|
||
init_semaphore_.Wait();
|
||
|
||
// Tell the parent process that everything is set up.
|
||
char c = '\0';
|
||
CheckedWriteFile(test_exception_ports_->WritePipeHandle(), &c, 1);
|
||
|
||
// Wait for the parent process to say that its end is set up.
|
||
CheckedReadFileExactly(test_exception_ports_->ReadPipeHandle(), &c, 1);
|
||
EXPECT_EQ(c, '\0');
|
||
|
||
// Regardless of where ExceptionPorts::SetExceptionPort() ran,
|
||
// ExceptionPorts::GetExceptionPorts() can always be tested in-process.
|
||
{
|
||
SCOPED_TRACE("task");
|
||
TestGetExceptionPorts(self_task_ports, remote_port, EXCEPTION_DEFAULT);
|
||
}
|
||
|
||
{
|
||
SCOPED_TRACE("main_thread");
|
||
mach_port_t thread_handler =
|
||
(test_exception_ports_->set_on() == kSetOnTaskAndThreads)
|
||
? remote_port
|
||
: MACH_PORT_NULL;
|
||
TestGetExceptionPorts(
|
||
self_thread_ports, thread_handler, EXCEPTION_STATE);
|
||
}
|
||
|
||
// Let the other thread know it’s safe to proceed.
|
||
crash_semaphore_.Signal();
|
||
|
||
// If this thread is the one that crashes, do it.
|
||
if (test_exception_ports_->who_crashes() == kMainThreadCrashes) {
|
||
Crash();
|
||
}
|
||
|
||
// Reap the other thread.
|
||
rv_int = pthread_join(thread_, nullptr);
|
||
ASSERT_EQ(rv_int, 0);
|
||
}
|
||
|
||
private:
|
||
// Calls ThreadMain().
|
||
static void* ThreadMainThunk(void* argument) {
|
||
Child* self = reinterpret_cast<Child*>(argument);
|
||
return self->ThreadMain();
|
||
}
|
||
|
||
// Runs the “other” thread.
|
||
void* ThreadMain() {
|
||
ExceptionPorts self_thread_ports(ExceptionPorts::kTargetTypeThread,
|
||
THREAD_NULL);
|
||
mach_port_t remote_port = test_exception_ports_->RemotePort();
|
||
|
||
// Set this thread’s exception handler, if appropriate.
|
||
if (test_exception_ports_->set_type() == kSetInProcess &&
|
||
test_exception_ports_->set_on() == kSetOnTaskAndThreads) {
|
||
switch (test_exception_ports_->set_or_swap()) {
|
||
case kSetExceptionPort: {
|
||
CHECK(self_thread_ports.SetExceptionPort(EXC_MASK_CRASH,
|
||
remote_port,
|
||
EXCEPTION_STATE_IDENTITY,
|
||
MACHINE_THREAD_STATE));
|
||
break;
|
||
}
|
||
case kSwapExceptionPorts: {
|
||
ExceptionPorts::ExceptionHandlerVector old_handlers;
|
||
CHECK(self_thread_ports.SwapExceptionPorts(EXC_MASK_CRASH,
|
||
remote_port,
|
||
EXCEPTION_STATE_IDENTITY,
|
||
MACHINE_THREAD_STATE,
|
||
&old_handlers));
|
||
break;
|
||
}
|
||
default: {
|
||
NOTREACHED();
|
||
}
|
||
}
|
||
}
|
||
|
||
// Let the main thread know that this thread is ready.
|
||
init_semaphore_.Signal();
|
||
|
||
// Wait for the main thread to signal that it’s safe to proceed.
|
||
crash_semaphore_.Wait();
|
||
|
||
// Regardless of where ExceptionPorts::SetExceptionPort() ran,
|
||
// ExceptionPorts::GetExceptionPorts() can always be tested in-process.
|
||
{
|
||
SCOPED_TRACE("other_thread");
|
||
mach_port_t thread_handler =
|
||
(test_exception_ports_->set_on() == kSetOnTaskAndThreads)
|
||
? remote_port
|
||
: MACH_PORT_NULL;
|
||
TestGetExceptionPorts(
|
||
self_thread_ports, thread_handler, EXCEPTION_STATE_IDENTITY);
|
||
}
|
||
|
||
// If this thread is the one that crashes, do it.
|
||
if (test_exception_ports_->who_crashes() == kOtherThreadCrashes) {
|
||
Crash();
|
||
}
|
||
|
||
return nullptr;
|
||
}
|
||
|
||
static void Crash() {
|
||
__builtin_trap();
|
||
}
|
||
|
||
// The parent object.
|
||
TestExceptionPorts* test_exception_ports_; // weak
|
||
|
||
// The “other” thread.
|
||
pthread_t thread_;
|
||
|
||
// The main thread waits on this for the other thread to start up and
|
||
// perform its own initialization.
|
||
Semaphore init_semaphore_;
|
||
|
||
// The child thread waits on this for the parent thread to indicate that the
|
||
// child can test its exception ports and possibly crash, as appropriate.
|
||
Semaphore crash_semaphore_;
|
||
};
|
||
|
||
// MachMultiprocess:
|
||
|
||
void MachMultiprocessParent() override {
|
||
// Wait for the child process to be ready. It needs to have all of its
|
||
// threads set up before proceeding if in kSetOutOfProcess mode.
|
||
char c;
|
||
CheckedReadFileExactly(ReadPipeHandle(), &c, 1);
|
||
EXPECT_EQ(c, '\0');
|
||
|
||
mach_port_t local_port = LocalPort();
|
||
|
||
// Get an ExceptionPorts object for the task and each of its threads.
|
||
ExceptionPorts task_ports(ExceptionPorts::kTargetTypeTask, ChildTask());
|
||
EXPECT_STREQ("task", task_ports.TargetTypeName());
|
||
|
||
// Hopefully the threads returned by task_threads() are in order, with the
|
||
// main thread first and the other thread second. This is currently always
|
||
// the case, although nothing guarantees that it will remain so.
|
||
thread_act_array_t threads;
|
||
mach_msg_type_number_t thread_count = 0;
|
||
kern_return_t kr = task_threads(ChildTask(), &threads, &thread_count);
|
||
ASSERT_EQ(kr, KERN_SUCCESS) << MachErrorMessage(kr, "task_threads");
|
||
|
||
ScopedForbidReturn threads_need_owners;
|
||
ASSERT_EQ(thread_count, 2u);
|
||
base::apple::ScopedMachSendRight main_thread(threads[0]);
|
||
base::apple::ScopedMachSendRight other_thread(threads[1]);
|
||
threads_need_owners.Disarm();
|
||
|
||
ExceptionPorts main_thread_ports(ExceptionPorts::kTargetTypeThread,
|
||
main_thread.get());
|
||
ExceptionPorts other_thread_ports(ExceptionPorts::kTargetTypeThread,
|
||
other_thread.get());
|
||
EXPECT_STREQ("thread", main_thread_ports.TargetTypeName());
|
||
EXPECT_STREQ("thread", other_thread_ports.TargetTypeName());
|
||
|
||
if (set_type_ == kSetOutOfProcess) {
|
||
// Test ExceptionPorts::SetExceptionPort() being called from
|
||
// out-of-process.
|
||
//
|
||
// local_port is only a receive right, but a send right is needed for
|
||
// ExceptionPorts::SetExceptionPort(). Make a send right, which can be
|
||
// deallocated once the calls to ExceptionPorts::SetExceptionPort() are
|
||
// done.
|
||
kr = mach_port_insert_right(
|
||
mach_task_self(), local_port, local_port, MACH_MSG_TYPE_MAKE_SEND);
|
||
ASSERT_EQ(kr, KERN_SUCCESS)
|
||
<< MachErrorMessage(kr, "mach_port_insert_right");
|
||
base::apple::ScopedMachSendRight send_owner(local_port);
|
||
|
||
switch (set_or_swap_) {
|
||
case kSetExceptionPort: {
|
||
ASSERT_TRUE(task_ports.SetExceptionPort(EXC_MASK_CRASH,
|
||
local_port,
|
||
EXCEPTION_DEFAULT,
|
||
THREAD_STATE_NONE));
|
||
|
||
if (set_on_ == kSetOnTaskAndThreads) {
|
||
ASSERT_TRUE(
|
||
main_thread_ports.SetExceptionPort(EXC_MASK_CRASH,
|
||
local_port,
|
||
EXCEPTION_STATE,
|
||
MACHINE_THREAD_STATE));
|
||
|
||
ASSERT_TRUE(
|
||
other_thread_ports.SetExceptionPort(EXC_MASK_CRASH,
|
||
local_port,
|
||
EXCEPTION_STATE_IDENTITY,
|
||
MACHINE_THREAD_STATE));
|
||
}
|
||
break;
|
||
}
|
||
|
||
case kSwapExceptionPorts: {
|
||
ExceptionPorts::ExceptionHandlerVector old_handlers;
|
||
|
||
ASSERT_TRUE(task_ports.SwapExceptionPorts(EXC_MASK_CRASH,
|
||
local_port,
|
||
EXCEPTION_DEFAULT,
|
||
THREAD_STATE_NONE,
|
||
&old_handlers));
|
||
|
||
if (set_on_ == kSetOnTaskAndThreads) {
|
||
ASSERT_TRUE(
|
||
main_thread_ports.SwapExceptionPorts(EXC_MASK_CRASH,
|
||
local_port,
|
||
EXCEPTION_STATE,
|
||
MACHINE_THREAD_STATE,
|
||
&old_handlers));
|
||
|
||
ASSERT_TRUE(
|
||
other_thread_ports.SwapExceptionPorts(EXC_MASK_CRASH,
|
||
local_port,
|
||
EXCEPTION_STATE_IDENTITY,
|
||
MACHINE_THREAD_STATE,
|
||
&old_handlers));
|
||
}
|
||
break;
|
||
}
|
||
|
||
default: {
|
||
NOTREACHED();
|
||
}
|
||
}
|
||
}
|
||
|
||
// Regardless of where ExceptionPorts::SetExceptionPort() ran,
|
||
// ExceptionPorts::GetExceptionPorts() can always be tested out-of-process.
|
||
{
|
||
SCOPED_TRACE("task");
|
||
TestGetExceptionPorts(task_ports, local_port, EXCEPTION_DEFAULT);
|
||
}
|
||
|
||
mach_port_t thread_handler =
|
||
(set_on_ == kSetOnTaskAndThreads) ? local_port : MACH_PORT_NULL;
|
||
|
||
{
|
||
SCOPED_TRACE("main_thread");
|
||
TestGetExceptionPorts(main_thread_ports, thread_handler, EXCEPTION_STATE);
|
||
}
|
||
|
||
{
|
||
SCOPED_TRACE("other_thread");
|
||
TestGetExceptionPorts(
|
||
other_thread_ports, thread_handler, EXCEPTION_STATE_IDENTITY);
|
||
}
|
||
|
||
// Let the child process know that everything in the parent process is set
|
||
// up.
|
||
c = '\0';
|
||
CheckedWriteFile(WritePipeHandle(), &c, 1);
|
||
|
||
if (who_crashes_ != kNobodyCrashes) {
|
||
UniversalMachExcServer universal_mach_exc_server(this);
|
||
|
||
constexpr mach_msg_timeout_t kTimeoutMs = 50;
|
||
kr = MachMessageServer::Run(&universal_mach_exc_server,
|
||
local_port,
|
||
kMachMessageReceiveAuditTrailer,
|
||
MachMessageServer::kOneShot,
|
||
MachMessageServer::kReceiveLargeError,
|
||
kTimeoutMs);
|
||
EXPECT_EQ(kr, KERN_SUCCESS)
|
||
<< MachErrorMessage(kr, "MachMessageServer::Run");
|
||
|
||
EXPECT_TRUE(handled_);
|
||
}
|
||
|
||
// Wait for the child process to exit or terminate, as indicated by it
|
||
// closing its pipe. This keeps LocalPort() alive in the child as
|
||
// RemotePort(), for the child’s use in its TestGetExceptionPorts().
|
||
CheckedReadFileAtEOF(ReadPipeHandle());
|
||
}
|
||
|
||
void MachMultiprocessChild() override {
|
||
Child child(this);
|
||
child.Run();
|
||
}
|
||
|
||
SetOrSwap set_or_swap_;
|
||
SetOn set_on_;
|
||
SetType set_type_;
|
||
WhoCrashes who_crashes_;
|
||
|
||
// true if an exception message was handled.
|
||
bool handled_;
|
||
};
|
||
|
||
TEST(ExceptionPorts, TaskExceptionPorts_SetInProcess_NoCrash) {
|
||
TestExceptionPorts test_exception_ports(TestExceptionPorts::kSetExceptionPort,
|
||
TestExceptionPorts::kSetOnTaskOnly,
|
||
TestExceptionPorts::kSetInProcess,
|
||
TestExceptionPorts::kNobodyCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskExceptionPorts_SetInProcess_MainThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSetExceptionPort,
|
||
TestExceptionPorts::kSetOnTaskOnly,
|
||
TestExceptionPorts::kSetInProcess,
|
||
TestExceptionPorts::kMainThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskExceptionPorts_SetInProcess_OtherThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSetExceptionPort,
|
||
TestExceptionPorts::kSetOnTaskOnly,
|
||
TestExceptionPorts::kSetInProcess,
|
||
TestExceptionPorts::kOtherThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskAndThreadExceptionPorts_SetInProcess_NoCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSetExceptionPort,
|
||
TestExceptionPorts::kSetOnTaskAndThreads,
|
||
TestExceptionPorts::kSetInProcess,
|
||
TestExceptionPorts::kNobodyCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskAndThreadExceptionPorts_SetInProcess_MainThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSetExceptionPort,
|
||
TestExceptionPorts::kSetOnTaskAndThreads,
|
||
TestExceptionPorts::kSetInProcess,
|
||
TestExceptionPorts::kMainThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts,
|
||
TaskAndThreadExceptionPorts_SetInProcess_OtherThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSetExceptionPort,
|
||
TestExceptionPorts::kSetOnTaskAndThreads,
|
||
TestExceptionPorts::kSetInProcess,
|
||
TestExceptionPorts::kOtherThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskExceptionPorts_SetOutOfProcess_NoCrash) {
|
||
TestExceptionPorts test_exception_ports(TestExceptionPorts::kSetExceptionPort,
|
||
TestExceptionPorts::kSetOnTaskOnly,
|
||
TestExceptionPorts::kSetOutOfProcess,
|
||
TestExceptionPorts::kNobodyCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskExceptionPorts_SetOutOfProcess_MainThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSetExceptionPort,
|
||
TestExceptionPorts::kSetOnTaskOnly,
|
||
TestExceptionPorts::kSetOutOfProcess,
|
||
TestExceptionPorts::kMainThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskExceptionPorts_SetOutOfProcess_OtherThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSetExceptionPort,
|
||
TestExceptionPorts::kSetOnTaskOnly,
|
||
TestExceptionPorts::kSetOutOfProcess,
|
||
TestExceptionPorts::kOtherThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskAndThreadExceptionPorts_SetOutOfProcess_NoCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSetExceptionPort,
|
||
TestExceptionPorts::kSetOnTaskAndThreads,
|
||
TestExceptionPorts::kSetOutOfProcess,
|
||
TestExceptionPorts::kNobodyCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts,
|
||
TaskAndThreadExceptionPorts_SetOutOfProcess_MainThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSetExceptionPort,
|
||
TestExceptionPorts::kSetOnTaskAndThreads,
|
||
TestExceptionPorts::kSetOutOfProcess,
|
||
TestExceptionPorts::kMainThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts,
|
||
TaskAndThreadExceptionPorts_SetOutOfProcess_OtherThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSetExceptionPort,
|
||
TestExceptionPorts::kSetOnTaskAndThreads,
|
||
TestExceptionPorts::kSetOutOfProcess,
|
||
TestExceptionPorts::kOtherThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskExceptionPorts_SwapInProcess_NoCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSwapExceptionPorts,
|
||
TestExceptionPorts::kSetOnTaskOnly,
|
||
TestExceptionPorts::kSetInProcess,
|
||
TestExceptionPorts::kNobodyCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskExceptionPorts_SwapInProcess_MainThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSwapExceptionPorts,
|
||
TestExceptionPorts::kSetOnTaskOnly,
|
||
TestExceptionPorts::kSetInProcess,
|
||
TestExceptionPorts::kMainThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskExceptionPorts_SwapInProcess_OtherThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSwapExceptionPorts,
|
||
TestExceptionPorts::kSetOnTaskOnly,
|
||
TestExceptionPorts::kSetInProcess,
|
||
TestExceptionPorts::kOtherThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskAndThreadExceptionPorts_SwapInProcess_NoCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSwapExceptionPorts,
|
||
TestExceptionPorts::kSetOnTaskAndThreads,
|
||
TestExceptionPorts::kSetInProcess,
|
||
TestExceptionPorts::kNobodyCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts,
|
||
TaskAndThreadExceptionPorts_SwapInProcess_MainThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSwapExceptionPorts,
|
||
TestExceptionPorts::kSetOnTaskAndThreads,
|
||
TestExceptionPorts::kSetInProcess,
|
||
TestExceptionPorts::kMainThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts,
|
||
TaskAndThreadExceptionPorts_SwapInProcess_OtherThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSwapExceptionPorts,
|
||
TestExceptionPorts::kSetOnTaskAndThreads,
|
||
TestExceptionPorts::kSetInProcess,
|
||
TestExceptionPorts::kOtherThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskExceptionPorts_SwapOutOfProcess_NoCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSwapExceptionPorts,
|
||
TestExceptionPorts::kSetOnTaskOnly,
|
||
TestExceptionPorts::kSetOutOfProcess,
|
||
TestExceptionPorts::kNobodyCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskExceptionPorts_SwapOutOfProcess_MainThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSwapExceptionPorts,
|
||
TestExceptionPorts::kSetOnTaskOnly,
|
||
TestExceptionPorts::kSetOutOfProcess,
|
||
TestExceptionPorts::kMainThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskExceptionPorts_SwapOutOfProcess_OtherThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSwapExceptionPorts,
|
||
TestExceptionPorts::kSetOnTaskOnly,
|
||
TestExceptionPorts::kSetOutOfProcess,
|
||
TestExceptionPorts::kOtherThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, TaskAndThreadExceptionPorts_SwapOutOfProcess_NoCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSwapExceptionPorts,
|
||
TestExceptionPorts::kSetOnTaskAndThreads,
|
||
TestExceptionPorts::kSetOutOfProcess,
|
||
TestExceptionPorts::kNobodyCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts,
|
||
TaskAndThreadExceptionPorts_SwapOutOfProcess_MainThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSwapExceptionPorts,
|
||
TestExceptionPorts::kSetOnTaskAndThreads,
|
||
TestExceptionPorts::kSetOutOfProcess,
|
||
TestExceptionPorts::kMainThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts,
|
||
TaskAndThreadExceptionPorts_SwapOutOfProcess_OtherThreadCrash) {
|
||
TestExceptionPorts test_exception_ports(
|
||
TestExceptionPorts::kSwapExceptionPorts,
|
||
TestExceptionPorts::kSetOnTaskAndThreads,
|
||
TestExceptionPorts::kSetOutOfProcess,
|
||
TestExceptionPorts::kOtherThreadCrashes);
|
||
test_exception_ports.Run();
|
||
}
|
||
|
||
TEST(ExceptionPorts, HostExceptionPorts) {
|
||
// ExceptionPorts isn’t expected to work as non-root. Just do a quick test to
|
||
// make sure that TargetTypeName() returns the right string, and that the
|
||
// underlying host_get_exception_ports() function appears to be called by
|
||
// looking for a KERN_INVALID_ARGUMENT return value. Or, on the off chance
|
||
// that the test is being run as root, just look for KERN_SUCCESS.
|
||
// host_set_exception_ports() is not tested, because if the test were running
|
||
// as root and the call succeeded, it would have global effects.
|
||
|
||
const bool expect_success = geteuid() == 0;
|
||
|
||
base::apple::ScopedMachSendRight host(mach_host_self());
|
||
ExceptionPorts explicit_host_ports(ExceptionPorts::kTargetTypeHost,
|
||
host.get());
|
||
EXPECT_STREQ("host", explicit_host_ports.TargetTypeName());
|
||
|
||
ExceptionPorts::ExceptionHandlerVector explicit_handlers;
|
||
bool rv =
|
||
explicit_host_ports.GetExceptionPorts(ExcMaskValid(), &explicit_handlers);
|
||
EXPECT_EQ(rv, expect_success);
|
||
|
||
ExceptionPorts implicit_host_ports(ExceptionPorts::kTargetTypeHost,
|
||
HOST_NULL);
|
||
EXPECT_STREQ("host", implicit_host_ports.TargetTypeName());
|
||
|
||
ExceptionPorts::ExceptionHandlerVector implicit_handlers;
|
||
rv =
|
||
implicit_host_ports.GetExceptionPorts(ExcMaskValid(), &implicit_handlers);
|
||
EXPECT_EQ(rv, expect_success);
|
||
|
||
EXPECT_EQ(implicit_handlers.size(), explicit_handlers.size());
|
||
}
|
||
|
||
} // namespace
|
||
} // namespace test
|
||
} // namespace crashpad
|