mirror of
https://github.com/chromium/crashpad.git
synced 2025-01-15 10:07:56 +08:00
c537245de8
Causes test failures on older versions of Android (e.g. Marshmallow). Also reverts follow-up CL "Fix dead-code warning in util/posix/signals.cc". This reverts commits ab9a87fb5463e5d1579e16bacb1f79d0dd71119b and 04431eccfe878570b1c74a5b376d96b4c9c7e0e8. Bug: 1272877 Change-Id: Id9ef420516c932147b6c8b67d9f4daf9d31d9b03 Reviewed-on: https://chromium-review.googlesource.com/c/crashpad/crashpad/+/3300986 Reviewed-by: Peter Boström <pbos@chromium.org> Commit-Queue: Peter Collingbourne <pcc@chromium.org>
583 lines
18 KiB
C++
583 lines
18 KiB
C++
// Copyright 2017 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/posix/signals.h"
|
||
|
||
#include <fcntl.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <sys/time.h>
|
||
#include <unistd.h>
|
||
|
||
#include <limits>
|
||
|
||
#include "base/compiler_specific.h"
|
||
#include "base/cxx17_backports.h"
|
||
#include "base/files/scoped_file.h"
|
||
#include "base/logging.h"
|
||
#include "base/strings/stringprintf.h"
|
||
#include "build/build_config.h"
|
||
#include "gtest/gtest.h"
|
||
#include "test/errors.h"
|
||
#include "test/multiprocess.h"
|
||
#include "test/scoped_temp_dir.h"
|
||
#include "util/posix/scoped_mmap.h"
|
||
|
||
namespace crashpad {
|
||
namespace test {
|
||
namespace {
|
||
|
||
constexpr int kUnexpectedExitStatus = 3;
|
||
|
||
// Keep synchronized with CauseSignal().
|
||
bool CanCauseSignal(int sig) {
|
||
return sig == SIGABRT || sig == SIGALRM || sig == SIGBUS ||
|
||
/* According to DDI0487D (Armv8 Architecture Reference Manual) the expected
|
||
* behavior for division by zero (Section 3.4.8) is: "... results in a
|
||
* zero being written to the destination register, without any
|
||
* indication that the division by zero occurred.".
|
||
* This applies to Armv8 (and not earlier) for both 32bit and 64bit app code.
|
||
*/
|
||
#if defined(ARCH_CPU_X86_FAMILY)
|
||
sig == SIGFPE ||
|
||
#endif
|
||
|
||
#if defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARMEL)
|
||
sig == SIGILL ||
|
||
#endif // defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARMEL)
|
||
sig == SIGPIPE || sig == SIGSEGV ||
|
||
#if defined(OS_APPLE)
|
||
sig == SIGSYS ||
|
||
#endif // OS_APPLE
|
||
#if defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARM64)
|
||
sig == SIGTRAP ||
|
||
#endif // defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARM64)
|
||
false;
|
||
}
|
||
|
||
// Keep synchronized with CanCauseSignal().
|
||
void CauseSignal(int sig) {
|
||
switch (sig) {
|
||
case SIGABRT: {
|
||
abort();
|
||
}
|
||
|
||
case SIGALRM: {
|
||
struct itimerval itimer = {};
|
||
itimer.it_value.tv_usec = 1E3; // 1 millisecond
|
||
if (setitimer(ITIMER_REAL, &itimer, nullptr) != 0) {
|
||
PLOG(ERROR) << "setitimer";
|
||
_exit(kUnexpectedExitStatus);
|
||
}
|
||
|
||
while (true) {
|
||
sleep(std::numeric_limits<unsigned int>::max());
|
||
}
|
||
}
|
||
|
||
case SIGBUS: {
|
||
ScopedMmap mapped_file;
|
||
{
|
||
base::ScopedFD fd;
|
||
{
|
||
ScopedTempDir temp_dir;
|
||
fd.reset(open(temp_dir.path().Append("empty").value().c_str(),
|
||
O_RDWR | O_CREAT | O_EXCL | O_NOCTTY | O_CLOEXEC,
|
||
0644));
|
||
if (fd.get() < 0) {
|
||
PLOG(ERROR) << "open";
|
||
}
|
||
}
|
||
if (fd.get() < 0) {
|
||
_exit(kUnexpectedExitStatus);
|
||
}
|
||
|
||
if (!mapped_file.ResetMmap(nullptr,
|
||
getpagesize(),
|
||
PROT_READ | PROT_WRITE,
|
||
MAP_PRIVATE,
|
||
fd.get(),
|
||
0)) {
|
||
_exit(kUnexpectedExitStatus);
|
||
}
|
||
}
|
||
|
||
*mapped_file.addr_as<char*>() = 0;
|
||
|
||
_exit(kUnexpectedExitStatus);
|
||
}
|
||
|
||
case SIGFPE: {
|
||
/* Enabled only for x86, since a division by zero won't raise a signal
|
||
* on Armv8, please see comment at the top of file concerning the
|
||
* Arm architecture.
|
||
*/
|
||
#if defined(ARCH_CPU_X86_FAMILY)
|
||
volatile int a = 42;
|
||
volatile int b = 0;
|
||
a /= b;
|
||
ALLOW_UNUSED_LOCAL(a);
|
||
#endif
|
||
break;
|
||
}
|
||
|
||
#if defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARMEL)
|
||
case SIGILL: {
|
||
// __builtin_trap() causes SIGTRAP on arm64 on Android.
|
||
__builtin_trap();
|
||
}
|
||
#endif // defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARMEL)
|
||
|
||
case SIGPIPE: {
|
||
int pipe_fds[2];
|
||
if (pipe(pipe_fds) != 0) {
|
||
PLOG(ERROR) << "pipe";
|
||
_exit(kUnexpectedExitStatus);
|
||
}
|
||
|
||
if (close(pipe_fds[0]) != 0) {
|
||
PLOG(ERROR) << "close";
|
||
_exit(kUnexpectedExitStatus);
|
||
}
|
||
|
||
char c = 0;
|
||
ssize_t rv = write(pipe_fds[1], &c, sizeof(c));
|
||
if (rv < 0) {
|
||
PLOG(ERROR) << "write";
|
||
_exit(kUnexpectedExitStatus);
|
||
} else if (rv != sizeof(c)) {
|
||
LOG(ERROR) << "write";
|
||
_exit(kUnexpectedExitStatus);
|
||
}
|
||
break;
|
||
}
|
||
|
||
case SIGSEGV: {
|
||
volatile int* i = nullptr;
|
||
*i = 0;
|
||
break;
|
||
}
|
||
|
||
#if defined(OS_APPLE)
|
||
case SIGSYS: {
|
||
#pragma clang diagnostic push
|
||
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
||
int rv = syscall(4095);
|
||
#pragma clang diagnostic pop
|
||
if (rv != 0) {
|
||
PLOG(ERROR) << "syscall";
|
||
_exit(kUnexpectedExitStatus);
|
||
}
|
||
break;
|
||
}
|
||
#endif // OS_APPLE
|
||
|
||
#if defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARM64)
|
||
case SIGTRAP: {
|
||
#if defined(ARCH_CPU_X86_FAMILY)
|
||
asm("int3");
|
||
#elif defined(ARCH_CPU_ARM64)
|
||
// bkpt #0 should work for 32-bit ARCH_CPU_ARMEL, but according to
|
||
// https://crrev.com/f53167270c44, it only causes SIGTRAP on Linux under a
|
||
// 64-bit kernel. For a pure 32-bit armv7 system, it generates SIGBUS.
|
||
asm("brk #0");
|
||
#endif
|
||
break;
|
||
}
|
||
#endif // defined(ARCH_CPU_X86_FAMILY) || defined(ARCH_CPU_ARM64)
|
||
|
||
default: {
|
||
LOG(ERROR) << "unexpected signal " << sig;
|
||
_exit(kUnexpectedExitStatus);
|
||
}
|
||
}
|
||
}
|
||
|
||
class SignalsTest : public Multiprocess {
|
||
public:
|
||
enum class SignalSource {
|
||
kCause,
|
||
kRaise,
|
||
};
|
||
enum class TestType {
|
||
kDefaultHandler,
|
||
kHandlerExits,
|
||
kHandlerReraisesToDefault,
|
||
kHandlerReraisesToPrevious,
|
||
};
|
||
static constexpr int kExitingHandlerExitStatus = 2;
|
||
|
||
SignalsTest(TestType test_type, SignalSource signal_source, int sig)
|
||
: Multiprocess(),
|
||
sig_(sig),
|
||
test_type_(test_type),
|
||
signal_source_(signal_source) {}
|
||
|
||
SignalsTest(const SignalsTest&) = delete;
|
||
SignalsTest& operator=(const SignalsTest&) = delete;
|
||
|
||
~SignalsTest() {}
|
||
|
||
private:
|
||
static void SignalHandler_Exit(int sig, siginfo_t* siginfo, void* context) {
|
||
_exit(kExitingHandlerExitStatus);
|
||
}
|
||
|
||
static void SignalHandler_ReraiseToDefault(int sig,
|
||
siginfo_t* siginfo,
|
||
void* context) {
|
||
Signals::RestoreHandlerAndReraiseSignalOnReturn(siginfo, nullptr);
|
||
}
|
||
|
||
static void SignalHandler_ReraiseToPrevious(int sig,
|
||
siginfo_t* siginfo,
|
||
void* context) {
|
||
Signals::RestoreHandlerAndReraiseSignalOnReturn(
|
||
siginfo, old_actions_.ActionForSignal(sig));
|
||
}
|
||
|
||
// Multiprocess:
|
||
void MultiprocessParent() override {}
|
||
|
||
void MultiprocessChild() override {
|
||
bool (*install_handlers)(Signals::Handler, int, Signals::OldActions*);
|
||
if (Signals::IsCrashSignal(sig_)) {
|
||
install_handlers = [](Signals::Handler handler,
|
||
int flags,
|
||
Signals::OldActions* old_actions) {
|
||
return Signals::InstallCrashHandlers(
|
||
handler, flags, old_actions, nullptr);
|
||
};
|
||
} else if (Signals::IsTerminateSignal(sig_)) {
|
||
install_handlers = Signals::InstallTerminateHandlers;
|
||
} else {
|
||
_exit(kUnexpectedExitStatus);
|
||
}
|
||
|
||
switch (test_type_) {
|
||
case TestType::kDefaultHandler: {
|
||
// Don’t rely on the default handler being active. Something may have
|
||
// changed it (particularly on Android).
|
||
struct sigaction action;
|
||
sigemptyset(&action.sa_mask);
|
||
action.sa_flags = 0;
|
||
action.sa_handler = SIG_DFL;
|
||
ASSERT_EQ(sigaction(sig_, &action, nullptr), 0)
|
||
<< ErrnoMessage("sigaction");
|
||
break;
|
||
}
|
||
|
||
case TestType::kHandlerExits: {
|
||
ASSERT_TRUE(install_handlers(SignalHandler_Exit, 0, nullptr));
|
||
break;
|
||
}
|
||
|
||
case TestType::kHandlerReraisesToDefault: {
|
||
ASSERT_TRUE(
|
||
install_handlers(SignalHandler_ReraiseToDefault, 0, nullptr));
|
||
break;
|
||
}
|
||
|
||
case TestType::kHandlerReraisesToPrevious: {
|
||
ASSERT_TRUE(install_handlers(SignalHandler_Exit, 0, nullptr));
|
||
ASSERT_TRUE(install_handlers(
|
||
SignalHandler_ReraiseToPrevious, 0, &old_actions_));
|
||
break;
|
||
}
|
||
}
|
||
|
||
switch (signal_source_) {
|
||
case SignalSource::kCause:
|
||
CauseSignal(sig_);
|
||
break;
|
||
case SignalSource::kRaise:
|
||
raise(sig_);
|
||
break;
|
||
}
|
||
|
||
_exit(kUnexpectedExitStatus);
|
||
}
|
||
|
||
int sig_;
|
||
TestType test_type_;
|
||
SignalSource signal_source_;
|
||
static Signals::OldActions old_actions_;
|
||
};
|
||
|
||
Signals::OldActions SignalsTest::old_actions_;
|
||
|
||
bool ShouldTestSignal(int sig) {
|
||
return Signals::IsCrashSignal(sig) || Signals::IsTerminateSignal(sig);
|
||
}
|
||
|
||
TEST(Signals, WillSignalReraiseAutonomously) {
|
||
const struct {
|
||
int sig;
|
||
int code;
|
||
bool result;
|
||
} kTestData[] = {
|
||
{SIGBUS, BUS_ADRALN, true},
|
||
{SIGFPE, FPE_FLTDIV, true},
|
||
{SIGILL, ILL_ILLOPC, true},
|
||
{SIGSEGV, SEGV_MAPERR, true},
|
||
{SIGBUS, 0, false},
|
||
{SIGFPE, -1, false},
|
||
{SIGILL, SI_USER, false},
|
||
{SIGSEGV, SI_QUEUE, false},
|
||
{SIGTRAP, TRAP_BRKPT, false},
|
||
{SIGHUP, SEGV_MAPERR, false},
|
||
{SIGINT, SI_USER, false},
|
||
};
|
||
for (size_t index = 0; index < base::size(kTestData); ++index) {
|
||
const auto test_data = kTestData[index];
|
||
SCOPED_TRACE(base::StringPrintf(
|
||
"index %zu, sig %d, code %d", index, test_data.sig, test_data.code));
|
||
siginfo_t siginfo = {};
|
||
siginfo.si_signo = test_data.sig;
|
||
siginfo.si_code = test_data.code;
|
||
EXPECT_EQ(Signals::WillSignalReraiseAutonomously(&siginfo),
|
||
test_data.result);
|
||
}
|
||
}
|
||
|
||
TEST(Signals, Cause_DefaultHandler) {
|
||
for (int sig = 1; sig < NSIG; ++sig) {
|
||
SCOPED_TRACE(base::StringPrintf("sig %d (%s)", sig, strsignal(sig)));
|
||
|
||
if (!CanCauseSignal(sig)) {
|
||
continue;
|
||
}
|
||
|
||
SignalsTest test(SignalsTest::TestType::kDefaultHandler,
|
||
SignalsTest::SignalSource::kCause,
|
||
sig);
|
||
test.SetExpectedChildTermination(Multiprocess::kTerminationSignal, sig);
|
||
test.Run();
|
||
}
|
||
}
|
||
|
||
TEST(Signals, Cause_HandlerExits) {
|
||
for (int sig = 1; sig < NSIG; ++sig) {
|
||
SCOPED_TRACE(base::StringPrintf("sig %d (%s)", sig, strsignal(sig)));
|
||
|
||
if (!CanCauseSignal(sig)) {
|
||
continue;
|
||
}
|
||
|
||
SignalsTest test(SignalsTest::TestType::kHandlerExits,
|
||
SignalsTest::SignalSource::kCause,
|
||
sig);
|
||
test.SetExpectedChildTermination(Multiprocess::kTerminationNormal,
|
||
SignalsTest::kExitingHandlerExitStatus);
|
||
test.Run();
|
||
}
|
||
}
|
||
|
||
TEST(Signals, Cause_HandlerReraisesToDefault) {
|
||
for (int sig = 1; sig < NSIG; ++sig) {
|
||
SCOPED_TRACE(base::StringPrintf("sig %d (%s)", sig, strsignal(sig)));
|
||
|
||
if (!CanCauseSignal(sig)) {
|
||
continue;
|
||
}
|
||
|
||
SignalsTest test(SignalsTest::TestType::kHandlerReraisesToDefault,
|
||
SignalsTest::SignalSource::kCause,
|
||
sig);
|
||
test.SetExpectedChildTermination(Multiprocess::kTerminationSignal, sig);
|
||
test.Run();
|
||
}
|
||
}
|
||
|
||
TEST(Signals, Cause_HandlerReraisesToPrevious) {
|
||
for (int sig = 1; sig < NSIG; ++sig) {
|
||
SCOPED_TRACE(base::StringPrintf("sig %d (%s)", sig, strsignal(sig)));
|
||
|
||
if (!CanCauseSignal(sig)) {
|
||
continue;
|
||
}
|
||
|
||
SignalsTest test(SignalsTest::TestType::kHandlerReraisesToPrevious,
|
||
SignalsTest::SignalSource::kCause,
|
||
sig);
|
||
test.SetExpectedChildTermination(Multiprocess::kTerminationNormal,
|
||
SignalsTest::kExitingHandlerExitStatus);
|
||
test.Run();
|
||
}
|
||
}
|
||
|
||
TEST(Signals, Raise_DefaultHandler) {
|
||
for (int sig = 1; sig < NSIG; ++sig) {
|
||
SCOPED_TRACE(base::StringPrintf("sig %d (%s)", sig, strsignal(sig)));
|
||
|
||
if (!ShouldTestSignal(sig)) {
|
||
continue;
|
||
}
|
||
|
||
SignalsTest test(SignalsTest::TestType::kDefaultHandler,
|
||
SignalsTest::SignalSource::kRaise,
|
||
sig);
|
||
test.SetExpectedChildTermination(Multiprocess::kTerminationSignal, sig);
|
||
test.Run();
|
||
}
|
||
}
|
||
|
||
TEST(Signals, Raise_HandlerExits) {
|
||
for (int sig = 1; sig < NSIG; ++sig) {
|
||
SCOPED_TRACE(base::StringPrintf("sig %d (%s)", sig, strsignal(sig)));
|
||
|
||
if (!ShouldTestSignal(sig)) {
|
||
continue;
|
||
}
|
||
|
||
SignalsTest test(SignalsTest::TestType::kHandlerExits,
|
||
SignalsTest::SignalSource::kRaise,
|
||
sig);
|
||
test.SetExpectedChildTermination(Multiprocess::kTerminationNormal,
|
||
SignalsTest::kExitingHandlerExitStatus);
|
||
test.Run();
|
||
}
|
||
}
|
||
|
||
TEST(Signals, Raise_HandlerReraisesToDefault) {
|
||
for (int sig = 1; sig < NSIG; ++sig) {
|
||
SCOPED_TRACE(base::StringPrintf("sig %d (%s)", sig, strsignal(sig)));
|
||
|
||
if (!ShouldTestSignal(sig)) {
|
||
continue;
|
||
}
|
||
|
||
#if defined(OS_APPLE)
|
||
if (sig == SIGBUS
|
||
#if defined(ARCH_CPU_ARM64)
|
||
|| sig == SIGILL || sig == SIGSEGV
|
||
#endif // defined(ARCH_CPU_ARM64)
|
||
) {
|
||
// Signal handlers can’t distinguish between these signals arising out of
|
||
// hardware faults and raised asynchronously.
|
||
// Signals::RestoreHandlerAndReraiseSignalOnReturn() assumes that they
|
||
// come from hardware faults, but this test uses raise(), so the re-raise
|
||
// test must be skipped.
|
||
continue;
|
||
}
|
||
#endif // defined(OS_APPLE)
|
||
|
||
SignalsTest test(SignalsTest::TestType::kHandlerReraisesToDefault,
|
||
SignalsTest::SignalSource::kRaise,
|
||
sig);
|
||
test.SetExpectedChildTermination(Multiprocess::kTerminationSignal, sig);
|
||
test.Run();
|
||
}
|
||
}
|
||
|
||
TEST(Signals, Raise_HandlerReraisesToPrevious) {
|
||
for (int sig = 1; sig < NSIG; ++sig) {
|
||
SCOPED_TRACE(base::StringPrintf("sig %d (%s)", sig, strsignal(sig)));
|
||
|
||
if (!ShouldTestSignal(sig)) {
|
||
continue;
|
||
}
|
||
|
||
#if defined(OS_APPLE)
|
||
if (sig == SIGBUS
|
||
#if defined(ARCH_CPU_ARM64)
|
||
|| sig == SIGILL || sig == SIGSEGV
|
||
#endif // defined(ARCH_CPU_ARM64)
|
||
) {
|
||
// Signal handlers can’t distinguish between these signals arising out of
|
||
// hardware faults and raised asynchronously.
|
||
// Signals::RestoreHandlerAndReraiseSignalOnReturn() assumes that they
|
||
// come from hardware faults, but this test uses raise(), so the re-raise
|
||
// test must be skipped.
|
||
continue;
|
||
}
|
||
#endif // defined(OS_APPLE)
|
||
|
||
SignalsTest test(SignalsTest::TestType::kHandlerReraisesToPrevious,
|
||
SignalsTest::SignalSource::kRaise,
|
||
sig);
|
||
test.SetExpectedChildTermination(Multiprocess::kTerminationNormal,
|
||
SignalsTest::kExitingHandlerExitStatus);
|
||
test.Run();
|
||
}
|
||
}
|
||
|
||
TEST(Signals, IsCrashSignal) {
|
||
// Always crash signals.
|
||
EXPECT_TRUE(Signals::IsCrashSignal(SIGABRT));
|
||
EXPECT_TRUE(Signals::IsCrashSignal(SIGBUS));
|
||
EXPECT_TRUE(Signals::IsCrashSignal(SIGFPE));
|
||
EXPECT_TRUE(Signals::IsCrashSignal(SIGILL));
|
||
EXPECT_TRUE(Signals::IsCrashSignal(SIGQUIT));
|
||
EXPECT_TRUE(Signals::IsCrashSignal(SIGSEGV));
|
||
EXPECT_TRUE(Signals::IsCrashSignal(SIGSYS));
|
||
EXPECT_TRUE(Signals::IsCrashSignal(SIGTRAP));
|
||
|
||
// Always terminate signals.
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGALRM));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGHUP));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGINT));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGPIPE));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGPROF));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGTERM));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGUSR1));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGUSR2));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGVTALRM));
|
||
|
||
// Never crash or terminate signals.
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGCHLD));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGCONT));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGTSTP));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGTTIN));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGTTOU));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGURG));
|
||
EXPECT_FALSE(Signals::IsCrashSignal(SIGWINCH));
|
||
}
|
||
|
||
TEST(Signals, IsTerminateSignal) {
|
||
// Always terminate signals.
|
||
EXPECT_TRUE(Signals::IsTerminateSignal(SIGALRM));
|
||
EXPECT_TRUE(Signals::IsTerminateSignal(SIGHUP));
|
||
EXPECT_TRUE(Signals::IsTerminateSignal(SIGINT));
|
||
EXPECT_TRUE(Signals::IsTerminateSignal(SIGPIPE));
|
||
EXPECT_TRUE(Signals::IsTerminateSignal(SIGPROF));
|
||
EXPECT_TRUE(Signals::IsTerminateSignal(SIGTERM));
|
||
EXPECT_TRUE(Signals::IsTerminateSignal(SIGUSR1));
|
||
EXPECT_TRUE(Signals::IsTerminateSignal(SIGUSR2));
|
||
EXPECT_TRUE(Signals::IsTerminateSignal(SIGVTALRM));
|
||
|
||
// Always crash signals.
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGABRT));
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGBUS));
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGFPE));
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGILL));
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGQUIT));
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGSEGV));
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGSYS));
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGTRAP));
|
||
|
||
// Never crash or terminate signals.
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGCHLD));
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGCONT));
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGTSTP));
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGTTIN));
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGTTOU));
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGURG));
|
||
EXPECT_FALSE(Signals::IsTerminateSignal(SIGWINCH));
|
||
}
|
||
|
||
} // namespace
|
||
} // namespace test
|
||
} // namespace crashpad
|