| 1 |
//===-- UnixSignalsTest.cpp -----------------------------------------------===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
#include <string> |
| 9 |
|
| 10 |
#include "gtest/gtest.h" |
| 11 |
|
| 12 |
#include "lldb/Target/UnixSignals.h" |
| 13 |
#include "llvm/Support/FormatVariadic.h" |
| 14 |
|
| 15 |
using namespace lldb; |
| 16 |
using namespace lldb_private; |
| 17 |
|
| 18 |
class TestSignals : public UnixSignals { |
| 19 |
public: |
| 20 |
TestSignals() { |
| 21 |
m_signals.clear(); |
| 22 |
AddSignal(2, "SIG2", false, true, true, "DESC2"); |
| 23 |
AddSignal(4, "SIG4", true, false, true, "DESC4"); |
| 24 |
AddSignal(8, "SIG8", true, true, true, "DESC8"); |
| 25 |
AddSignal(16, "SIG16", true, false, false, "DESC16"); |
| 26 |
AddSignalCode(16, 1, "a specific type of SIG16"); |
| 27 |
AddSignalCode(16, 2, "SIG16 with a fault address", |
| 28 |
SignalCodePrintOption::Address); |
| 29 |
AddSignalCode(16, 3, "bounds violation", SignalCodePrintOption::Bounds); |
| 30 |
AddSignalCode(16, -6, "sent by tkill system call", |
| 31 |
SignalCodePrintOption::Sender); |
| 32 |
} |
| 33 |
}; |
| 34 |
|
| 35 |
void ExpectEqArrays(llvm::ArrayRef<int32_t> expected, |
| 36 |
llvm::ArrayRef<int32_t> observed, const char *file, |
| 37 |
int line) { |
| 38 |
std::string location = llvm::formatv("{0}:{1}", file, line); |
| 39 |
ASSERT_EQ(expected.size(), observed.size()) << location; |
| 40 |
|
| 41 |
for (size_t i = 0; i < observed.size(); ++i) { |
| 42 |
ASSERT_EQ(expected[i], observed[i]) |
| 43 |
<< "array index: " << i << "location:" << location; |
| 44 |
} |
| 45 |
} |
| 46 |
|
| 47 |
#define EXPECT_EQ_ARRAYS(expected, observed) \ |
| 48 |
ExpectEqArrays((expected), (observed), __FILE__, __LINE__); |
| 49 |
|
| 50 |
TEST(UnixSignalsTest, Iteration) { |
| 51 |
TestSignals signals; |
| 52 |
|
| 53 |
EXPECT_EQ(4, signals.GetNumSignals()); |
| 54 |
EXPECT_EQ(2, signals.GetFirstSignalNumber()); |
| 55 |
EXPECT_EQ(4, signals.GetNextSignalNumber(2)); |
| 56 |
EXPECT_EQ(8, signals.GetNextSignalNumber(4)); |
| 57 |
EXPECT_EQ(16, signals.GetNextSignalNumber(8)); |
| 58 |
EXPECT_EQ(LLDB_INVALID_SIGNAL_NUMBER, signals.GetNextSignalNumber(16)); |
| 59 |
} |
| 60 |
|
| 61 |
TEST(UnixSignalsTest, Reset) { |
| 62 |
TestSignals signals; |
| 63 |
bool stop_val = signals.GetShouldStop(2); |
| 64 |
bool notify_val = signals.GetShouldNotify(2); |
| 65 |
bool suppress_val = signals.GetShouldSuppress(2); |
| 66 |
|
| 67 |
// Change two, then reset one and make sure only that one was reset: |
| 68 |
EXPECT_EQ(true, signals.SetShouldNotify(2, !notify_val)); |
| 69 |
EXPECT_EQ(true, signals.SetShouldSuppress(2, !suppress_val)); |
| 70 |
EXPECT_EQ(true, signals.ResetSignal(2, false, true, false)); |
| 71 |
EXPECT_EQ(stop_val, signals.GetShouldStop(2)); |
| 72 |
EXPECT_EQ(notify_val, signals.GetShouldStop(2)); |
| 73 |
EXPECT_EQ(!suppress_val, signals.GetShouldNotify(2)); |
| 74 |
|
| 75 |
// Make sure reset with no arguments resets them all: |
| 76 |
EXPECT_EQ(true, signals.SetShouldSuppress(2, !suppress_val)); |
| 77 |
EXPECT_EQ(true, signals.SetShouldNotify(2, !notify_val)); |
| 78 |
EXPECT_EQ(true, signals.ResetSignal(2)); |
| 79 |
EXPECT_EQ(stop_val, signals.GetShouldStop(2)); |
| 80 |
EXPECT_EQ(notify_val, signals.GetShouldNotify(2)); |
| 81 |
EXPECT_EQ(suppress_val, signals.GetShouldSuppress(2)); |
| 82 |
} |
| 83 |
|
| 84 |
TEST(UnixSignalsTest, GetInfo) { |
| 85 |
TestSignals signals; |
| 86 |
|
| 87 |
bool should_suppress = false, should_stop = false, should_notify = false; |
| 88 |
int32_t signo = 4; |
| 89 |
bool success = |
| 90 |
signals.GetSignalInfo(signo, should_suppress, should_stop, should_notify); |
| 91 |
ASSERT_TRUE(success); |
| 92 |
EXPECT_EQ(true, should_suppress); |
| 93 |
EXPECT_EQ(false, should_stop); |
| 94 |
EXPECT_EQ(true, should_notify); |
| 95 |
|
| 96 |
EXPECT_EQ(true, signals.GetShouldSuppress(signo)); |
| 97 |
EXPECT_EQ(false, signals.GetShouldStop(signo)); |
| 98 |
EXPECT_EQ(true, signals.GetShouldNotify(signo)); |
| 99 |
} |
| 100 |
|
| 101 |
TEST(UnixSignalsTest, GetAsStringRef) { |
| 102 |
TestSignals signals; |
| 103 |
|
| 104 |
ASSERT_EQ(llvm::StringRef(), signals.GetSignalAsStringRef(100)); |
| 105 |
ASSERT_EQ("SIG16", signals.GetSignalAsStringRef(16)); |
| 106 |
} |
| 107 |
|
| 108 |
TEST(UnixSignalsTest, GetAsString) { |
| 109 |
TestSignals signals; |
| 110 |
|
| 111 |
ASSERT_EQ("", signals.GetSignalDescription(100, std::nullopt)); |
| 112 |
ASSERT_EQ("SIG16", signals.GetSignalDescription(16, std::nullopt)); |
| 113 |
ASSERT_EQ("", signals.GetSignalDescription(100, 100)); |
| 114 |
ASSERT_EQ("SIG16", signals.GetSignalDescription(16, 100)); |
| 115 |
ASSERT_EQ("SIG16: a specific type of SIG16", |
| 116 |
signals.GetSignalDescription(16, 1)); |
| 117 |
|
| 118 |
// Unknown code, won't use the address. |
| 119 |
ASSERT_EQ("SIG16", signals.GetSignalDescription(16, 100, 0xCAFEF00D)); |
| 120 |
// Known code, that shouldn't print fault address. |
| 121 |
ASSERT_EQ("SIG16: a specific type of SIG16", |
| 122 |
signals.GetSignalDescription(16, 1, 0xCAFEF00D)); |
| 123 |
// Known code that should. |
| 124 |
ASSERT_EQ("SIG16: SIG16 with a fault address (fault address=0xcafef00d)", |
| 125 |
signals.GetSignalDescription(16, 2, 0xCAFEF00D)); |
| 126 |
// No address given just print the code description. |
| 127 |
ASSERT_EQ("SIG16: SIG16 with a fault address", |
| 128 |
signals.GetSignalDescription(16, 2)); |
| 129 |
// TKill, but with no sender |
| 130 |
ASSERT_EQ("SIG16: sent by tkill system call", |
| 131 |
signals.GetSignalDescription(16, -6, 0xCAFEF00D)); |
| 132 |
// TKill, but with no sender |
| 133 |
ASSERT_EQ("SIG16: sent by tkill system call (sender pid=912, uid=99)", |
| 134 |
signals.GetSignalDescription(16, -6, 0xCAFEF00D, std::nullopt, |
| 135 |
std::nullopt, 912, 99)); |
| 136 |
|
| 137 |
const char *expected = "SIG16: bounds violation"; |
| 138 |
// Must pass all needed info to get full output. |
| 139 |
ASSERT_EQ(expected, signals.GetSignalDescription(16, 3)); |
| 140 |
ASSERT_EQ(expected, signals.GetSignalDescription(16, 3, 0xcafef00d)); |
| 141 |
ASSERT_EQ(expected, signals.GetSignalDescription(16, 3, 0xcafef00d, 0x1234)); |
| 142 |
|
| 143 |
ASSERT_EQ("SIG16: upper bound violation (fault address=0x5679, lower bound=" |
| 144 |
"0x1234, upper bound=0x5678)", |
| 145 |
signals.GetSignalDescription(16, 3, 0x5679, 0x1234, 0x5678)); |
| 146 |
ASSERT_EQ("SIG16: lower bound violation (fault address=0x1233, lower bound=" |
| 147 |
"0x1234, upper bound=0x5678)", |
| 148 |
signals.GetSignalDescription(16, 3, 0x1233, 0x1234, 0x5678)); |
| 149 |
} |
| 150 |
|
| 151 |
TEST(UnixSignalsTest, VersionChange) { |
| 152 |
TestSignals signals; |
| 153 |
|
| 154 |
int32_t signo = 8; |
| 155 |
uint64_t ver = signals.GetVersion(); |
| 156 |
EXPECT_GT(ver, 0ull); |
| 157 |
EXPECT_EQ(true, signals.GetShouldSuppress(signo)); |
| 158 |
EXPECT_EQ(true, signals.GetShouldStop(signo)); |
| 159 |
EXPECT_EQ(true, signals.GetShouldNotify(signo)); |
| 160 |
|
| 161 |
EXPECT_EQ(signals.GetVersion(), ver); |
| 162 |
|
| 163 |
signals.SetShouldSuppress(signo, false); |
| 164 |
EXPECT_LT(ver, signals.GetVersion()); |
| 165 |
ver = signals.GetVersion(); |
| 166 |
|
| 167 |
signals.SetShouldStop(signo, true); |
| 168 |
EXPECT_LT(ver, signals.GetVersion()); |
| 169 |
ver = signals.GetVersion(); |
| 170 |
|
| 171 |
signals.SetShouldNotify(signo, false); |
| 172 |
EXPECT_LT(ver, signals.GetVersion()); |
| 173 |
ver = signals.GetVersion(); |
| 174 |
|
| 175 |
EXPECT_EQ(false, signals.GetShouldSuppress(signo)); |
| 176 |
EXPECT_EQ(true, signals.GetShouldStop(signo)); |
| 177 |
EXPECT_EQ(false, signals.GetShouldNotify(signo)); |
| 178 |
|
| 179 |
EXPECT_EQ(ver, signals.GetVersion()); |
| 180 |
} |
| 181 |
|
| 182 |
TEST(UnixSignalsTest, GetFilteredSignals) { |
| 183 |
TestSignals signals; |
| 184 |
|
| 185 |
auto all_signals = |
| 186 |
signals.GetFilteredSignals(std::nullopt, std::nullopt, std::nullopt); |
| 187 |
std::vector<int32_t> expected = {2, 4, 8, 16}; |
| 188 |
EXPECT_EQ_ARRAYS(expected, all_signals); |
| 189 |
|
| 190 |
auto supressed = signals.GetFilteredSignals(true, std::nullopt, std::nullopt); |
| 191 |
expected = {4, 8, 16}; |
| 192 |
EXPECT_EQ_ARRAYS(expected, supressed); |
| 193 |
|
| 194 |
auto not_supressed = |
| 195 |
signals.GetFilteredSignals(false, std::nullopt, std::nullopt); |
| 196 |
expected = {2}; |
| 197 |
EXPECT_EQ_ARRAYS(expected, not_supressed); |
| 198 |
|
| 199 |
auto stopped = signals.GetFilteredSignals(std::nullopt, true, std::nullopt); |
| 200 |
expected = {2, 8}; |
| 201 |
EXPECT_EQ_ARRAYS(expected, stopped); |
| 202 |
|
| 203 |
auto not_stopped = |
| 204 |
signals.GetFilteredSignals(std::nullopt, false, std::nullopt); |
| 205 |
expected = {4, 16}; |
| 206 |
EXPECT_EQ_ARRAYS(expected, not_stopped); |
| 207 |
|
| 208 |
auto notified = signals.GetFilteredSignals(std::nullopt, std::nullopt, true); |
| 209 |
expected = {2, 4, 8}; |
| 210 |
EXPECT_EQ_ARRAYS(expected, notified); |
| 211 |
|
| 212 |
auto not_notified = |
| 213 |
signals.GetFilteredSignals(std::nullopt, std::nullopt, false); |
| 214 |
expected = {16}; |
| 215 |
EXPECT_EQ_ARRAYS(expected, not_notified); |
| 216 |
|
| 217 |
auto signal4 = signals.GetFilteredSignals(true, false, true); |
| 218 |
expected = {4}; |
| 219 |
EXPECT_EQ_ARRAYS(expected, signal4); |
| 220 |
} |