1 | //===-- UnixSignals.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 | |
9 | #include "lldb/Target/UnixSignals.h" |
10 | #include "Plugins/Process/Utility/FreeBSDSignals.h" |
11 | #include "Plugins/Process/Utility/LinuxSignals.h" |
12 | #include "Plugins/Process/Utility/NetBSDSignals.h" |
13 | #include "Plugins/Process/Utility/OpenBSDSignals.h" |
14 | #include "lldb/Host/HostInfo.h" |
15 | #include "lldb/Utility/ArchSpec.h" |
16 | #include <optional> |
17 | #include <sstream> |
18 | |
19 | using namespace lldb_private; |
20 | using namespace llvm; |
21 | |
22 | UnixSignals::Signal::Signal(llvm::StringRef name, bool default_suppress, |
23 | bool default_stop, bool default_notify, |
24 | llvm::StringRef description, llvm::StringRef alias) |
25 | : m_name(name), m_alias(alias), m_description(description), |
26 | m_suppress(default_suppress), m_stop(default_stop), |
27 | m_notify(default_notify), m_default_suppress(default_suppress), |
28 | m_default_stop(default_stop), m_default_notify(default_notify) {} |
29 | |
30 | lldb::UnixSignalsSP UnixSignals::Create(const ArchSpec &arch) { |
31 | const auto &triple = arch.GetTriple(); |
32 | switch (triple.getOS()) { |
33 | case llvm::Triple::Linux: |
34 | return std::make_shared<LinuxSignals>(); |
35 | case llvm::Triple::FreeBSD: |
36 | return std::make_shared<FreeBSDSignals>(); |
37 | case llvm::Triple::NetBSD: |
38 | return std::make_shared<NetBSDSignals>(); |
39 | case llvm::Triple::OpenBSD: |
40 | return std::make_shared<OpenBSDSignals>(); |
41 | default: |
42 | return std::make_shared<UnixSignals>(); |
43 | } |
44 | } |
45 | |
46 | lldb::UnixSignalsSP UnixSignals::CreateForHost() { |
47 | static lldb::UnixSignalsSP s_unix_signals_sp = |
48 | Create(arch: HostInfo::GetArchitecture()); |
49 | return s_unix_signals_sp; |
50 | } |
51 | |
52 | // UnixSignals constructor |
53 | UnixSignals::UnixSignals() { Reset(); } |
54 | |
55 | UnixSignals::UnixSignals(const UnixSignals &rhs) : m_signals(rhs.m_signals) {} |
56 | |
57 | UnixSignals::~UnixSignals() = default; |
58 | |
59 | void UnixSignals::Reset() { |
60 | // This builds one standard set of Unix Signals. If yours aren't quite in |
61 | // this order, you can either subclass this class, and use Add & Remove to |
62 | // change them or you can subclass and build them afresh in your constructor. |
63 | // |
64 | // Note: the signals below are the Darwin signals. Do not change these! |
65 | |
66 | m_signals.clear(); |
67 | |
68 | // clang-format off |
69 | // SIGNO NAME SUPPRESS STOP NOTIFY DESCRIPTION |
70 | // ====== ============== ======== ====== ====== =================================================== |
71 | AddSignal(signo: 1, name: "SIGHUP", default_suppress: false, default_stop: true, default_notify: true, description: "hangup"); |
72 | AddSignal(signo: 2, name: "SIGINT", default_suppress: true, default_stop: true, default_notify: true, description: "interrupt"); |
73 | AddSignal(signo: 3, name: "SIGQUIT", default_suppress: false, default_stop: true, default_notify: true, description: "quit"); |
74 | AddSignal(signo: 4, name: "SIGILL", default_suppress: false, default_stop: true, default_notify: true, description: "illegal instruction"); |
75 | AddSignal(signo: 5, name: "SIGTRAP", default_suppress: true, default_stop: true, default_notify: true, description: "trace trap (not reset when caught)"); |
76 | AddSignal(signo: 6, name: "SIGABRT", default_suppress: false, default_stop: true, default_notify: true, description: "abort()"); |
77 | AddSignal(signo: 7, name: "SIGEMT", default_suppress: false, default_stop: true, default_notify: true, description: "pollable event"); |
78 | AddSignal(signo: 8, name: "SIGFPE", default_suppress: false, default_stop: true, default_notify: true, description: "floating point exception"); |
79 | AddSignal(signo: 9, name: "SIGKILL", default_suppress: false, default_stop: true, default_notify: true, description: "kill"); |
80 | AddSignal(signo: 10, name: "SIGBUS", default_suppress: false, default_stop: true, default_notify: true, description: "bus error"); |
81 | AddSignal(signo: 11, name: "SIGSEGV", default_suppress: false, default_stop: true, default_notify: true, description: "segmentation violation"); |
82 | AddSignal(signo: 12, name: "SIGSYS", default_suppress: false, default_stop: true, default_notify: true, description: "bad argument to system call"); |
83 | AddSignal(signo: 13, name: "SIGPIPE", default_suppress: false, default_stop: false, default_notify: false, description: "write on a pipe with no one to read it"); |
84 | AddSignal(signo: 14, name: "SIGALRM", default_suppress: false, default_stop: false, default_notify: false, description: "alarm clock"); |
85 | AddSignal(signo: 15, name: "SIGTERM", default_suppress: false, default_stop: true, default_notify: true, description: "software termination signal from kill"); |
86 | AddSignal(signo: 16, name: "SIGURG", default_suppress: false, default_stop: false, default_notify: false, description: "urgent condition on IO channel"); |
87 | AddSignal(signo: 17, name: "SIGSTOP", default_suppress: true, default_stop: true, default_notify: true, description: "sendable stop signal not from tty"); |
88 | AddSignal(signo: 18, name: "SIGTSTP", default_suppress: false, default_stop: true, default_notify: true, description: "stop signal from tty"); |
89 | AddSignal(signo: 19, name: "SIGCONT", default_suppress: false, default_stop: false, default_notify: true, description: "continue a stopped process"); |
90 | AddSignal(signo: 20, name: "SIGCHLD", default_suppress: false, default_stop: false, default_notify: false, description: "to parent on child stop or exit"); |
91 | AddSignal(signo: 21, name: "SIGTTIN", default_suppress: false, default_stop: true, default_notify: true, description: "to readers process group upon background tty read"); |
92 | AddSignal(signo: 22, name: "SIGTTOU", default_suppress: false, default_stop: true, default_notify: true, description: "to readers process group upon background tty write"); |
93 | AddSignal(signo: 23, name: "SIGIO", default_suppress: false, default_stop: false, default_notify: false, description: "input/output possible signal"); |
94 | AddSignal(signo: 24, name: "SIGXCPU", default_suppress: false, default_stop: true, default_notify: true, description: "exceeded CPU time limit"); |
95 | AddSignal(signo: 25, name: "SIGXFSZ", default_suppress: false, default_stop: true, default_notify: true, description: "exceeded file size limit"); |
96 | AddSignal(signo: 26, name: "SIGVTALRM", default_suppress: false, default_stop: false, default_notify: false, description: "virtual time alarm"); |
97 | AddSignal(signo: 27, name: "SIGPROF", default_suppress: false, default_stop: false, default_notify: false, description: "profiling time alarm"); |
98 | AddSignal(signo: 28, name: "SIGWINCH", default_suppress: false, default_stop: false, default_notify: false, description: "window size changes"); |
99 | AddSignal(signo: 29, name: "SIGINFO", default_suppress: false, default_stop: true, default_notify: true, description: "information request"); |
100 | AddSignal(signo: 30, name: "SIGUSR1", default_suppress: false, default_stop: true, default_notify: true, description: "user defined signal 1"); |
101 | AddSignal(signo: 31, name: "SIGUSR2", default_suppress: false, default_stop: true, default_notify: true, description: "user defined signal 2"); |
102 | // clang-format on |
103 | } |
104 | |
105 | void UnixSignals::AddSignal(int signo, llvm::StringRef name, |
106 | bool default_suppress, bool default_stop, |
107 | bool default_notify, llvm::StringRef description, |
108 | llvm::StringRef alias) { |
109 | Signal new_signal(name, default_suppress, default_stop, default_notify, |
110 | description, alias); |
111 | m_signals.insert(x: std::make_pair(x&: signo, y&: new_signal)); |
112 | ++m_version; |
113 | } |
114 | |
115 | void UnixSignals::AddSignalCode(int signo, int code, |
116 | const llvm::StringLiteral description, |
117 | SignalCodePrintOption print_option) { |
118 | collection::iterator signal = m_signals.find(x: signo); |
119 | assert(signal != m_signals.end() && |
120 | "Tried to add code to signal that does not exist."); |
121 | signal->second.m_codes.insert( |
122 | x: std::pair{code, SignalCode{.m_description: description, .m_print_option: print_option}}); |
123 | ++m_version; |
124 | } |
125 | |
126 | void UnixSignals::RemoveSignal(int signo) { |
127 | collection::iterator pos = m_signals.find(x: signo); |
128 | if (pos != m_signals.end()) |
129 | m_signals.erase(position: pos); |
130 | ++m_version; |
131 | } |
132 | |
133 | llvm::StringRef UnixSignals::GetSignalAsStringRef(int32_t signo) const { |
134 | const auto pos = m_signals.find(x: signo); |
135 | if (pos == m_signals.end()) |
136 | return {}; |
137 | return pos->second.m_name; |
138 | } |
139 | |
140 | std::string UnixSignals::GetSignalDescription( |
141 | int32_t signo, std::optional<int32_t> code, |
142 | std::optional<lldb::addr_t> addr, std::optional<lldb::addr_t> lower, |
143 | std::optional<lldb::addr_t> upper, std::optional<uint32_t> pid, |
144 | std::optional<uint32_t> uid) const { |
145 | std::string str; |
146 | |
147 | collection::const_iterator pos = m_signals.find(x: signo); |
148 | if (pos != m_signals.end()) { |
149 | str = pos->second.m_name.str(); |
150 | |
151 | if (code) { |
152 | std::map<int32_t, SignalCode>::const_iterator cpos = |
153 | pos->second.m_codes.find(x: *code); |
154 | if (cpos != pos->second.m_codes.end()) { |
155 | const SignalCode &sc = cpos->second; |
156 | str += ": "; |
157 | if (sc.m_print_option != SignalCodePrintOption::Bounds) |
158 | str += sc.m_description.str(); |
159 | |
160 | std::stringstream strm; |
161 | switch (sc.m_print_option) { |
162 | case SignalCodePrintOption::None: |
163 | break; |
164 | case SignalCodePrintOption::Address: |
165 | if (addr) |
166 | strm << " (fault address=0x"<< std::hex << *addr << ")"; |
167 | break; |
168 | case SignalCodePrintOption::Bounds: |
169 | if (lower && upper && addr) { |
170 | if ((unsigned long)(*addr) < *lower) |
171 | strm << "lower bound violation "; |
172 | else |
173 | strm << "upper bound violation "; |
174 | |
175 | strm << "(fault address=0x"<< std::hex << *addr; |
176 | strm << ", lower bound=0x"<< std::hex << *lower; |
177 | strm << ", upper bound=0x"<< std::hex << *upper; |
178 | strm << ")"; |
179 | } else |
180 | strm << sc.m_description.str(); |
181 | |
182 | break; |
183 | case SignalCodePrintOption::Sender: |
184 | if (pid && uid) |
185 | strm << " (sender pid="<< *pid << ", uid="<< *uid << ")"; |
186 | break; |
187 | } |
188 | str += strm.str(); |
189 | } |
190 | } |
191 | } |
192 | |
193 | return str; |
194 | } |
195 | |
196 | bool UnixSignals::SignalIsValid(int32_t signo) const { |
197 | return m_signals.find(x: signo) != m_signals.end(); |
198 | } |
199 | |
200 | llvm::StringRef UnixSignals::GetShortName(llvm::StringRef name) const { |
201 | return name.substr(Start: 3); // Remove "SIG" from name |
202 | } |
203 | |
204 | int32_t UnixSignals::GetSignalNumberFromName(const char *name) const { |
205 | llvm::StringRef name_ref(name); |
206 | |
207 | collection::const_iterator pos, end = m_signals.end(); |
208 | for (pos = m_signals.begin(); pos != end; pos++) { |
209 | if ((name_ref == pos->second.m_name) || (name_ref == pos->second.m_alias) || |
210 | (name_ref == GetShortName(name: pos->second.m_name)) || |
211 | (name_ref == GetShortName(name: pos->second.m_alias))) |
212 | return pos->first; |
213 | } |
214 | |
215 | int32_t signo; |
216 | if (llvm::to_integer(S: name, Num&: signo)) |
217 | return signo; |
218 | return LLDB_INVALID_SIGNAL_NUMBER; |
219 | } |
220 | |
221 | int32_t UnixSignals::GetFirstSignalNumber() const { |
222 | if (m_signals.empty()) |
223 | return LLDB_INVALID_SIGNAL_NUMBER; |
224 | |
225 | return (*m_signals.begin()).first; |
226 | } |
227 | |
228 | int32_t UnixSignals::GetNextSignalNumber(int32_t current_signal) const { |
229 | collection::const_iterator pos = m_signals.find(x: current_signal); |
230 | collection::const_iterator end = m_signals.end(); |
231 | if (pos == end) |
232 | return LLDB_INVALID_SIGNAL_NUMBER; |
233 | else { |
234 | pos++; |
235 | if (pos == end) |
236 | return LLDB_INVALID_SIGNAL_NUMBER; |
237 | else |
238 | return pos->first; |
239 | } |
240 | } |
241 | |
242 | bool UnixSignals::GetSignalInfo(int32_t signo, bool &should_suppress, |
243 | bool &should_stop, bool &should_notify) const { |
244 | const auto pos = m_signals.find(x: signo); |
245 | if (pos == m_signals.end()) |
246 | return false; |
247 | |
248 | const Signal &signal = pos->second; |
249 | should_suppress = signal.m_suppress; |
250 | should_stop = signal.m_stop; |
251 | should_notify = signal.m_notify; |
252 | return true; |
253 | } |
254 | |
255 | bool UnixSignals::GetShouldSuppress(int signo) const { |
256 | collection::const_iterator pos = m_signals.find(x: signo); |
257 | if (pos != m_signals.end()) |
258 | return pos->second.m_suppress; |
259 | return false; |
260 | } |
261 | |
262 | bool UnixSignals::SetShouldSuppress(int signo, bool value) { |
263 | collection::iterator pos = m_signals.find(x: signo); |
264 | if (pos != m_signals.end()) { |
265 | pos->second.m_suppress = value; |
266 | ++m_version; |
267 | return true; |
268 | } |
269 | return false; |
270 | } |
271 | |
272 | bool UnixSignals::SetShouldSuppress(const char *signal_name, bool value) { |
273 | const int32_t signo = GetSignalNumberFromName(name: signal_name); |
274 | if (signo != LLDB_INVALID_SIGNAL_NUMBER) |
275 | return SetShouldSuppress(signo, value); |
276 | return false; |
277 | } |
278 | |
279 | bool UnixSignals::GetShouldStop(int signo) const { |
280 | collection::const_iterator pos = m_signals.find(x: signo); |
281 | if (pos != m_signals.end()) |
282 | return pos->second.m_stop; |
283 | return false; |
284 | } |
285 | |
286 | bool UnixSignals::SetShouldStop(int signo, bool value) { |
287 | collection::iterator pos = m_signals.find(x: signo); |
288 | if (pos != m_signals.end()) { |
289 | pos->second.m_stop = value; |
290 | ++m_version; |
291 | return true; |
292 | } |
293 | return false; |
294 | } |
295 | |
296 | bool UnixSignals::SetShouldStop(const char *signal_name, bool value) { |
297 | const int32_t signo = GetSignalNumberFromName(name: signal_name); |
298 | if (signo != LLDB_INVALID_SIGNAL_NUMBER) |
299 | return SetShouldStop(signo, value); |
300 | return false; |
301 | } |
302 | |
303 | bool UnixSignals::GetShouldNotify(int signo) const { |
304 | collection::const_iterator pos = m_signals.find(x: signo); |
305 | if (pos != m_signals.end()) |
306 | return pos->second.m_notify; |
307 | return false; |
308 | } |
309 | |
310 | bool UnixSignals::SetShouldNotify(int signo, bool value) { |
311 | collection::iterator pos = m_signals.find(x: signo); |
312 | if (pos != m_signals.end()) { |
313 | pos->second.m_notify = value; |
314 | ++m_version; |
315 | return true; |
316 | } |
317 | return false; |
318 | } |
319 | |
320 | bool UnixSignals::SetShouldNotify(const char *signal_name, bool value) { |
321 | const int32_t signo = GetSignalNumberFromName(name: signal_name); |
322 | if (signo != LLDB_INVALID_SIGNAL_NUMBER) |
323 | return SetShouldNotify(signo, value); |
324 | return false; |
325 | } |
326 | |
327 | int32_t UnixSignals::GetNumSignals() const { return m_signals.size(); } |
328 | |
329 | int32_t UnixSignals::GetSignalAtIndex(int32_t index) const { |
330 | if (index < 0 || m_signals.size() <= static_cast<size_t>(index)) |
331 | return LLDB_INVALID_SIGNAL_NUMBER; |
332 | auto it = m_signals.begin(); |
333 | std::advance(i&: it, n: index); |
334 | return it->first; |
335 | } |
336 | |
337 | uint64_t UnixSignals::GetVersion() const { return m_version; } |
338 | |
339 | std::vector<int32_t> |
340 | UnixSignals::GetFilteredSignals(std::optional<bool> should_suppress, |
341 | std::optional<bool> should_stop, |
342 | std::optional<bool> should_notify) { |
343 | std::vector<int32_t> result; |
344 | for (int32_t signo = GetFirstSignalNumber(); |
345 | signo != LLDB_INVALID_SIGNAL_NUMBER; |
346 | signo = GetNextSignalNumber(current_signal: signo)) { |
347 | |
348 | bool signal_suppress = false; |
349 | bool signal_stop = false; |
350 | bool signal_notify = false; |
351 | GetSignalInfo(signo, should_suppress&: signal_suppress, should_stop&: signal_stop, should_notify&: signal_notify); |
352 | |
353 | // If any of filtering conditions are not met, we move on to the next |
354 | // signal. |
355 | if (should_suppress && signal_suppress != *should_suppress) |
356 | continue; |
357 | |
358 | if (should_stop && signal_stop != *should_stop) |
359 | continue; |
360 | |
361 | if (should_notify && signal_notify != *should_notify) |
362 | continue; |
363 | |
364 | result.push_back(x: signo); |
365 | } |
366 | |
367 | return result; |
368 | } |
369 | |
370 | void UnixSignals::IncrementSignalHitCount(int signo) { |
371 | collection::iterator pos = m_signals.find(x: signo); |
372 | if (pos != m_signals.end()) |
373 | pos->second.m_hit_count += 1; |
374 | } |
375 | |
376 | json::Value UnixSignals::GetHitCountStatistics() const { |
377 | json::Array json_signals; |
378 | for (const auto &pair : m_signals) { |
379 | if (pair.second.m_hit_count > 0) |
380 | json_signals.emplace_back( |
381 | A: json::Object{{.K: pair.second.m_name, .V: pair.second.m_hit_count}}); |
382 | } |
383 | return std::move(json_signals); |
384 | } |
385 | |
386 | void UnixSignals::Signal::Reset(bool reset_stop, bool reset_notify, |
387 | bool reset_suppress) { |
388 | if (reset_stop) |
389 | m_stop = m_default_stop; |
390 | if (reset_notify) |
391 | m_notify = m_default_notify; |
392 | if (reset_suppress) |
393 | m_suppress = m_default_suppress; |
394 | } |
395 | |
396 | bool UnixSignals::ResetSignal(int32_t signo, bool reset_stop, |
397 | bool reset_notify, bool reset_suppress) { |
398 | auto elem = m_signals.find(x: signo); |
399 | if (elem == m_signals.end()) |
400 | return false; |
401 | (*elem).second.Reset(reset_stop, reset_notify, reset_suppress); |
402 | return true; |
403 | } |
404 |
Definitions
- Signal
- Create
- CreateForHost
- UnixSignals
- UnixSignals
- ~UnixSignals
- Reset
- AddSignal
- AddSignalCode
- RemoveSignal
- GetSignalAsStringRef
- GetSignalDescription
- SignalIsValid
- GetShortName
- GetSignalNumberFromName
- GetFirstSignalNumber
- GetNextSignalNumber
- GetSignalInfo
- GetShouldSuppress
- SetShouldSuppress
- SetShouldSuppress
- GetShouldStop
- SetShouldStop
- SetShouldStop
- GetShouldNotify
- SetShouldNotify
- SetShouldNotify
- GetNumSignals
- GetSignalAtIndex
- GetVersion
- GetFilteredSignals
- IncrementSignalHitCount
- GetHitCountStatistics
- Reset
Learn to use CMake with our Intro Training
Find out more