crashpad/test/multiprocess_posix.cc
Mark Mentovai 6278690abe Update copyright boilerplate, 2022 edition (Crashpad)
sed -i '' -E -e 's/Copyright (.+) The Crashpad Authors\. All rights reserved\.$/Copyright \1 The Crashpad Authors/' $(git grep -El 'Copyright (.+) The Crashpad Authors\. All rights reserved\.$')

Bug: chromium:1098010
Change-Id: I8d6138469ddbe3d281a5d83f64cf918ec2491611
Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/3878262
Reviewed-by: Joshua Peraza <jperaza@chromium.org>
Commit-Queue: Mark Mentovai <mark@chromium.org>
2022-09-06 23:54:07 +00:00

260 lines
7.4 KiB
C++
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// 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 "test/multiprocess.h"
#include <signal.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
#include <memory>
#include <string>
#include "base/auto_reset.h"
#include "base/check_op.h"
#include "base/files/scoped_file.h"
#include "base/posix/eintr_wrapper.h"
#include "base/strings/stringprintf.h"
#include "build/build_config.h"
#include "gtest/gtest.h"
#include "test/errors.h"
#include "util/misc/scoped_forbid_return.h"
#include "util/posix/signals.h"
#if BUILDFLAG(IS_APPLE)
#include "test/mac/exception_swallower.h"
#endif
namespace crashpad {
namespace test {
namespace internal {
struct MultiprocessInfo {
MultiprocessInfo()
: pipe_c2p_read(-1),
pipe_c2p_write(-1),
pipe_p2c_read(-1),
pipe_p2c_write(-1),
child_pid(0) {}
base::ScopedFD pipe_c2p_read; // child to parent
base::ScopedFD pipe_c2p_write; // child to parent
base::ScopedFD pipe_p2c_read; // parent to child
base::ScopedFD pipe_p2c_write; // parent to child
pid_t child_pid; // valid only in parent
};
} // namespace internal
Multiprocess::Multiprocess()
: info_(nullptr),
code_(EXIT_SUCCESS),
reason_(kTerminationNormal) {
}
void Multiprocess::Run() {
ASSERT_EQ(info_, nullptr);
std::unique_ptr<internal::MultiprocessInfo> info(
new internal::MultiprocessInfo);
base::AutoReset<internal::MultiprocessInfo*> reset_info(&info_, info.get());
ASSERT_NO_FATAL_FAILURE(PreFork());
#if BUILDFLAG(IS_APPLE)
// If the child is expected to crash, set up an exception swallower to swallow
// the exception instead of allowing it to be seen by the systems crash
// reporter.
std::unique_ptr<ExceptionSwallower> exception_swallower;
if (reason_ == kTerminationSignal && Signals::IsCrashSignal(code_)) {
exception_swallower.reset(new ExceptionSwallower());
}
#endif // BUILDFLAG(IS_APPLE)
pid_t pid = fork();
ASSERT_GE(pid, 0) << ErrnoMessage("fork");
if (pid > 0) {
info_->child_pid = pid;
RunParent();
// Waiting for the child happens here instead of in RunParent() because even
// if RunParent() returns early due to a Google Test fatal assertion
// failure, the child should still be reaped.
// This will make the parent hang up on the child as much as would be
// visible from the childs perspective. The childs side of the pipe will
// be broken, the childs remote port will become a dead name, and an
// attempt by the child to look up the service will fail. If this werent
// done, the child might hang while waiting for a parent that has already
// triggered a fatal assertion failure to do something.
info.reset();
info_ = nullptr;
int status;
pid_t wait_pid = HANDLE_EINTR(waitpid(pid, &status, 0));
ASSERT_EQ(wait_pid, pid) << ErrnoMessage("waitpid");
TerminationReason reason;
int code;
std::string message;
if (WIFEXITED(status)) {
reason = kTerminationNormal;
code = WEXITSTATUS(status);
message = base::StringPrintf("Child exited with code %d", code);
} else if (WIFSIGNALED(status)) {
reason = kTerminationSignal;
code = WTERMSIG(status);
message =
base::StringPrintf("Child terminated by signal %d (%s)%s",
code,
strsignal(code),
WCOREDUMP(status) ? " (core dumped)" : "");
} else {
FAIL() << base::StringPrintf("Unknown termination reason 0x%x", status);
}
if (reason_ == kTerminationNormal) {
message += base::StringPrintf(", expected exit with code %d", code_);
} else if (reason_ == kTerminationSignal) {
message += base::StringPrintf(", expected termination by signal %d (%s)",
code_,
strsignal(code_));
}
if (reason != reason_ || code != code_) {
ADD_FAILURE() << message;
}
} else {
#if BUILDFLAG(IS_APPLE)
if (exception_swallower.get()) {
ExceptionSwallower::SwallowExceptions();
}
#elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
if (reason_ == kTerminationSignal && Signals::IsCrashSignal(code_)) {
Signals::InstallDefaultHandler(code_);
}
#endif // BUILDFLAG(IS_APPLE)
RunChild();
}
}
void Multiprocess::SetExpectedChildTermination(TerminationReason reason,
ReturnCodeType code) {
EXPECT_EQ(info_, nullptr)
<< "SetExpectedChildTermination() must be called before Run()";
reason_ = reason;
code_ = code;
}
void Multiprocess::SetExpectedChildTerminationBuiltinTrap() {
#if defined(ARCH_CPU_ARM64) || defined(ARCH_CPU_MIPS_FAMILY)
SetExpectedChildTermination(kTerminationSignal, SIGTRAP);
#else
SetExpectedChildTermination(kTerminationSignal, SIGILL);
#endif
}
Multiprocess::~Multiprocess() {
}
void Multiprocess::PreFork() {
int pipe_fds_c2p[2];
int rv = pipe(pipe_fds_c2p);
ASSERT_EQ(rv, 0) << ErrnoMessage("pipe");
info_->pipe_c2p_read.reset(pipe_fds_c2p[0]);
info_->pipe_c2p_write.reset(pipe_fds_c2p[1]);
int pipe_fds_p2c[2];
rv = pipe(pipe_fds_p2c);
ASSERT_EQ(rv, 0) << ErrnoMessage("pipe");
info_->pipe_p2c_read.reset(pipe_fds_p2c[0]);
info_->pipe_p2c_write.reset(pipe_fds_p2c[1]);
}
pid_t Multiprocess::ChildPID() const {
EXPECT_NE(info_->child_pid, 0);
return info_->child_pid;
}
FileHandle Multiprocess::ReadPipeHandle() const {
int fd = info_->child_pid ? info_->pipe_c2p_read.get()
: info_->pipe_p2c_read.get();
CHECK_NE(fd, -1);
return fd;
}
FileHandle Multiprocess::WritePipeHandle() const {
int fd = info_->child_pid ? info_->pipe_p2c_write.get()
: info_->pipe_c2p_write.get();
CHECK_NE(fd, -1);
return fd;
}
void Multiprocess::CloseReadPipe() {
if (info_->child_pid) {
info_->pipe_c2p_read.reset();
} else {
info_->pipe_p2c_read.reset();
}
}
void Multiprocess::CloseWritePipe() {
if (info_->child_pid) {
info_->pipe_p2c_write.reset();
} else {
info_->pipe_c2p_write.reset();
}
}
void Multiprocess::RunParent() {
// The parent uses the read end of c2p and the write end of p2c.
info_->pipe_c2p_write.reset();
info_->pipe_p2c_read.reset();
MultiprocessParent();
info_->pipe_c2p_read.reset();
info_->pipe_p2c_write.reset();
}
void Multiprocess::RunChild() {
ScopedForbidReturn forbid_return;
// The child uses the write end of c2p and the read end of p2c.
info_->pipe_c2p_read.reset();
info_->pipe_p2c_write.reset();
MultiprocessChild();
info_->pipe_c2p_write.reset();
info_->pipe_p2c_read.reset();
if (testing::Test::HasFailure()) {
// Trigger the ScopedForbidReturn destructor.
return;
}
// In a forked child, exit() is unsafe. Use _exit() instead.
_exit(EXIT_SUCCESS);
}
} // namespace test
} // namespace crashpad