Debian Codegraph @

src/basic/signal-util.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <threads.h>
4 #include <unistd.h>
5
6 #include "errno-util.h"
7 #include "parse-util.h"
8 #include "process-util.h"
9 #include "signal-util.h"
10 #include "stdio-util.h"
11 #include "string-table.h"
12 #include "string-util.h"
13
14 int reset_all_signal_handlers(void) {
15 int ret = 0, r;
16
17 for (int sig = 1; sig < _NSIG; sig++) {
18
19 /* These two cannot be caught... */
20 if (IN_SET(sig, SIGKILL, SIGSTOP))
21 continue;
22
23 /* On Linux the first two RT signals are reserved by glibc, and sigaction() will return
24 * EINVAL for them. */
25 r = RET_NERRNO(sigaction(sig, &sigaction_default, NULL));
26 if (r != -EINVAL)
27 RET_GATHER(ret, r);
28 }
29
30 return ret;
31 }
32
33 int reset_signal_mask(void) {
34 sigset_t ss;
35
36 if (sigemptyset(&ss) < 0)
37 return -errno;
38
39 return RET_NERRNO(sigprocmask(SIG_SETMASK, &ss, NULL));
40 }
41
42 int sigaction_many_internal(const struct sigaction *sa, ...) {
43 int sig, r = 0;
44 va_list ap;
45
46 va_start(ap, sa);
47
48 /* negative signal ends the list. 0 signal is skipped. */
49 while ((sig = va_arg(ap, int)) >= 0) {
50
51 if (sig == 0)
52 continue;
53
54 RET_GATHER(r, RET_NERRNO(sigaction(sig, sa, NULL)));
55 }
56
57 va_end(ap);
58
59 return r;
60 }
61
62 static int sigset_add_many_ap(sigset_t *ss, va_list ap) {
63 int sig, r = 0;
64
65 assert(ss);
66
67 while ((sig = va_arg(ap, int)) >= 0) {
68
69 if (sig == 0)
70 continue;
71
72 if (sigaddset(ss, sig) < 0) {
73 if (r >= 0)
74 r = -errno;
75 }
76 }
77
78 return r;
79 }
80
81 int sigset_add_many_internal(sigset_t *ss, ...) {
82 va_list ap;
83 int r;
84
85 va_start(ap, ss);
86 r = sigset_add_many_ap(ss, ap);
87 va_end(ap);
88
89 return r;
90 }
91
92 int sigprocmask_many_internal(int how, sigset_t *ret_old_mask, ...) {
93 va_list ap;
94 sigset_t ss;
95 int r;
96
97 if (sigemptyset(&ss) < 0)
98 return -errno;
99
100 va_start(ap, ret_old_mask);
101 r = sigset_add_many_ap(&ss, ap);
102 va_end(ap);
103
104 if (r < 0)
105 return r;
106
107 return RET_NERRNO(sigprocmask(how, &ss, ret_old_mask));
108 }
109
110 static const char *const static_signal_table[] = {
111 [SIGHUP] = "HUP",
112 [SIGINT] = "INT",
113 [SIGQUIT] = "QUIT",
114 [SIGILL] = "ILL",
115 [SIGTRAP] = "TRAP",
116 [SIGABRT] = "ABRT",
117 [SIGBUS] = "BUS",
118 [SIGFPE] = "FPE",
119 [SIGKILL] = "KILL",
120 [SIGUSR1] = "USR1",
121 [SIGSEGV] = "SEGV",
122 [SIGUSR2] = "USR2",
123 [SIGPIPE] = "PIPE",
124 [SIGALRM] = "ALRM",
125 [SIGTERM] = "TERM",
126 #ifdef SIGSTKFLT
127 [SIGSTKFLT] = "STKFLT", /* Linux on SPARC doesn't know SIGSTKFLT */
128 #endif
129 [SIGCHLD] = "CHLD",
130 [SIGCONT] = "CONT",
131 [SIGSTOP] = "STOP",
132 [SIGTSTP] = "TSTP",
133 [SIGTTIN] = "TTIN",
134 [SIGTTOU] = "TTOU",
135 [SIGURG] = "URG",
136 [SIGXCPU] = "XCPU",
137 [SIGXFSZ] = "XFSZ",
138 [SIGVTALRM] = "VTALRM",
139 [SIGPROF] = "PROF",
140 [SIGWINCH] = "WINCH",
141 [SIGIO] = "IO",
142 [SIGPWR] = "PWR",
143 [SIGSYS] = "SYS"
144 };
145
146 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(static_signal, int);
147
148 const char* signal_to_string(int signo) {
149 static thread_local char buf[STRLEN("RTMIN+") + DECIMAL_STR_MAX(int)];
150 const char *name;
151
152 name = static_signal_to_string(signo);
153 if (name)
154 return name;
155
156 if (signo >= SIGRTMIN && signo <= SIGRTMAX)
157 xsprintf(buf, "RTMIN+%d", signo - SIGRTMIN);
158 else
159 xsprintf(buf, "%d", signo);
160
161 return buf;
162 }
163
164 int signal_from_string(const char *s) {
165 const char *p;
166 int signo, r;
167
168 /* Check that the input is a signal number. */
169 if (safe_atoi(s, &signo) >= 0) {
170 if (SIGNAL_VALID(signo))
171 return signo;
172 else
173 return -ERANGE;
174 }
175
176 /* Drop "SIG" prefix. */
177 if (startswith(s, "SIG"))
178 s += 3;
179
180 /* Check that the input is a signal name. */
181 signo = static_signal_from_string(s);
182 if (signo > 0)
183 return signo;
184
185 /* Check that the input is RTMIN or
186 * RTMIN+n (0 <= n <= SIGRTMAX-SIGRTMIN). */
187 p = startswith(s, "RTMIN");
188 if (p) {
189 if (*p == '\0')
190 return SIGRTMIN;
191 if (*p != '+')
192 return -EINVAL;
193
194 r = safe_atoi(p, &signo);
195 if (r < 0)
196 return r;
197
198 if (signo < 0 || signo > SIGRTMAX - SIGRTMIN)
199 return -ERANGE;
200
201 return signo + SIGRTMIN;
202 }
203
204 /* Check that the input is RTMAX or
205 * RTMAX-n (0 <= n <= SIGRTMAX-SIGRTMIN). */
206 p = startswith(s, "RTMAX");
207 if (p) {
208 if (*p == '\0')
209 return SIGRTMAX;
210 if (*p != '-')
211 return -EINVAL;
212
213 r = safe_atoi(p, &signo);
214 if (r < 0)
215 return r;
216
217 if (signo > 0 || signo < SIGRTMIN - SIGRTMAX)
218 return -ERANGE;
219
220 return signo + SIGRTMAX;
221 }
222
223 return -EINVAL;
224 }
225
226 static const char *const sigill_code_table[] = {
227 [ILL_ILLOPC] = "ILL_ILLOPC",
228 [ILL_ILLOPN] = "ILL_ILLOPN",
229 [ILL_ILLADR] = "ILL_ILLADR",
230 [ILL_ILLTRP] = "ILL_ILLTRP",
231 [ILL_PRVOPC] = "ILL_PRVOPC",
232 [ILL_PRVREG] = "ILL_PRVREG",
233 [ILL_COPROC] = "ILL_COPROC",
234 [ILL_BADSTK] = "ILL_BADSTK",
235 [ILL_BADIADDR] = "ILL_BADIADDR",
236 };
237
238 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(sigill_code, int);
239
240 static const char *const sigfpe_code_table[] = {
241 [FPE_INTDIV] = "FPE_INTDIV",
242 [FPE_INTOVF] = "FPE_INTOVF",
243 [FPE_FLTDIV] = "FPE_FLTDIV",
244 [FPE_FLTOVF] = "FPE_FLTOVF",
245 [FPE_FLTUND] = "FPE_FLTUND",
246 [FPE_FLTRES] = "FPE_FLTRES",
247 [FPE_FLTINV] = "FPE_FLTINV",
248 [FPE_FLTSUB] = "FPE_FLTSUB",
249 [FPE_FLTUNK] = "FPE_FLTUNK",
250 [FPE_CONDTRAP] = "FPE_CONDTRAP",
251 };
252
253 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(sigfpe_code, int);
254
255 static const char *const sigsegv_code_table[] = {
256 [SEGV_MAPERR] = "SEGV_MAPERR",
257 [SEGV_ACCERR] = "SEGV_ACCERR",
258 [SEGV_BNDERR] = "SEGV_BNDERR",
259 [SEGV_PKUERR] = "SEGV_PKUERR",
260 [SEGV_ACCADI] = "SEGV_ACCADI",
261 [SEGV_ADIDERR] = "SEGV_ADIDERR",
262 [SEGV_ADIPERR] = "SEGV_ADIPERR",
263 [SEGV_MTEAERR] = "SEGV_MTEAERR",
264 [SEGV_MTESERR] = "SEGV_MTESERR",
265 [SEGV_CPERR] = "SEGV_CPERR",
266 };
267
268 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(sigsegv_code, int);
269
270 static const char *const sigbus_code_table[] = {
271 [BUS_ADRALN] = "BUS_ADRALN",
272 [BUS_ADRERR] = "BUS_ADRERR",
273 [BUS_OBJERR] = "BUS_OBJERR",
274 [BUS_MCEERR_AR] = "BUS_MCEERR_AR",
275 [BUS_MCEERR_AO] = "BUS_MCEERR_AO",
276 };
277
278 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(sigbus_code, int);
279
280 static const char *const sigtrap_code_table[] = {
281 [TRAP_BRKPT] = "TRAP_BRKPT",
282 [TRAP_TRACE] = "TRAP_TRACE",
283 [TRAP_BRANCH] = "TRAP_BRANCH",
284 [TRAP_HWBKPT] = "TRAP_HWBKPT",
285 [TRAP_UNK] = "TRAP_UNK",
286 [TRAP_PERF] = "TRAP_PERF",
287 };
288
289 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(sigtrap_code, int);
290
291 static const char *const sigsys_code_table[] = {
292 [SYS_SECCOMP] = "SYS_SECCOMP",
293 [SYS_USER_DISPATCH] = "SYS_USER_DISPATCH",
294 };
295
296 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(sigsys_code, int);
297
298 /* sigchld_code_table is already defined in src/basic/process-util.c with
299 * decoded, lower-case values (CLD_EXITED -> "exited"). For consistency with
300 * all other values decoded here, provide an uppercase variant. */
301 static const char *const sigchld_uppercase_code_table[] = {
302 [CLD_EXITED] = "CLD_EXITED",
303 [CLD_KILLED] = "CLD_KILLED",
304 [CLD_DUMPED] = "CLD_DUMPED",
305 [CLD_TRAPPED] = "CLD_TRAPPED",
306 [CLD_STOPPED] = "CLD_STOPPED",
307 [CLD_CONTINUED] = "CLD_CONTINUED",
308 };
309
310 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(sigchld_uppercase_code, int);
311
312 static const char *const sigpoll_code_table[] = {
313 [POLL_IN] = "POLL_IN",
314 [POLL_OUT] = "POLL_OUT",
315 [POLL_MSG] = "POLL_MSG",
316 [POLL_ERR] = "POLL_ERR",
317 [POLL_PRI] = "POLL_PRI",
318 [POLL_HUP] = "POLL_HUP",
319 };
320
321 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(sigpoll_code, int);
322
323 const char* signal_code_to_string(int signo, int code) {
324 switch (code) {
325 /* SI_KERNEL is 0x80 (128). Defining a table just for SI_KERNEL and
326 * SI_USER would be a waste of .rodata space: special case them instead. */
327 case SI_KERNEL:
328 return "SI_KERNEL";
329 case SI_USER:
330 return "SI_USER";
331 /* The following values are all negatives. SI_ASYNCNL is -60. Similarly
332 * to the special case for SI_KERNEL above, avoid using a table for negative
333 * values as well. */
334 case SI_ASYNCNL:
335 return "SI_ASYNCNL";
336 case SI_DETHREAD:
337 return "SI_DETHREAD";
338 case SI_TKILL:
339 return "SI_TKILL";
340 case SI_SIGIO:
341 return "SI_SIGIO";
342 case SI_ASYNCIO:
343 return "SI_ASYNCIO";
344 case SI_MESGQ:
345 return "SI_MESGQ";
346 case SI_TIMER:
347 return "SI_TIMER";
348 case SI_QUEUE:
349 return "SI_QUEUE";
350 }
351
352 switch (signo) {
353 case SIGILL:
354 return sigill_code_to_string(code);
355 case SIGFPE:
356 return sigfpe_code_to_string(code);
357 case SIGSEGV:
358 return sigsegv_code_to_string(code);
359 case SIGBUS:
360 return sigbus_code_to_string(code);
361 case SIGTRAP:
362 return sigtrap_code_to_string(code);
363 case SIGCHLD:
364 return sigchld_uppercase_code_to_string(code);
365 case SIGPOLL:
366 return sigpoll_code_to_string(code);
367 case SIGSYS:
368 return sigsys_code_to_string(code);
369 default:
370 return NULL;
371 }
372 }
373
374 void nop_signal_handler(int sig) {
375 /* nothing here */
376 }
377
378 int signal_is_blocked(int sig) {
379 sigset_t ss;
380 int r;
381
382 r = pthread_sigmask(SIG_SETMASK, NULL, &ss);
383 if (r != 0)
384 return -r;
385
386 return RET_NERRNO(sigismember(&ss, sig));
387 }
388
389 int autoreaping_enabled(void) {
390 struct sigaction sa;
391
392 if (sigaction(SIGCHLD, /* act= */ NULL, &sa) < 0)
393 return -errno;
394
395 return sa.sa_handler == SIG_IGN || FLAGS_SET(sa.sa_flags, SA_NOCLDWAIT);
396 }
397
398 int pop_pending_signal_internal(int sig, ...) {
399 sigset_t ss;
400 va_list ap;
401 int r;
402
403 if (sig < 0) /* Empty list? */
404 return -EINVAL;
405
406 if (sigemptyset(&ss) < 0)
407 return -errno;
408
409 /* Add first signal (if the signal is zero, we'll silently skip it, to make it easier to build
410 * parameter lists where some element are sometimes off, similar to how sigset_add_many_ap() handles
411 * this.) */
412 if (sig > 0 && sigaddset(&ss, sig) < 0)
413 return -errno;
414
415 /* Add all other signals */
416 va_start(ap, sig);
417 r = sigset_add_many_ap(&ss, ap);
418 va_end(ap);
419 if (r < 0)
420 return r;
421
422 r = sigtimedwait(&ss, NULL, &(const struct timespec) {});
423 if (r < 0) {
424 if (errno == EAGAIN)
425 return 0;
426
427 return -errno;
428 }
429
430 return r; /* Returns the signal popped */
431 }
432
433 void propagate_signal(int sig, siginfo_t *siginfo) {
434 pid_t p;
435
436 /* To be called from a signal handler. Will raise the same signal again, in our process + in our threads.
437 *
438 * Note that we use getpid() instead of getpid_cached(). We might have forked with raw_clone()
439 * earlier (see PID 1), and hence let's go to the raw syscall here. In particular as this is not
440 * performance sensitive code.
441 *
442 * Note that we use kill() rather than raise() as fallback, for similar reasons. */
443
444 p = getpid();
445
446 if (rt_tgsigqueueinfo(p, gettid(), sig, siginfo) < 0)
447 assert_se(kill(p, sig) >= 0);
448 }
449
450 const struct sigaction sigaction_ignore = {
451 .sa_handler = SIG_IGN,
452 .sa_flags = SA_RESTART,
453 };
454
455 const struct sigaction sigaction_default = {
456 .sa_handler = SIG_DFL,
457 .sa_flags = SA_RESTART,
458 };
459
460 const struct sigaction sigaction_nop_nocldstop = {
461 .sa_handler = nop_signal_handler,
462 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
463 };
464
465 int parse_signo(const char *s, int *ret) {
466 int sig, r;
467
468 r = safe_atoi(s, &sig);
469 if (r < 0)
470 return r;
471
472 if (!SIGNAL_VALID(sig))
473 return -EINVAL;
474
475 if (ret)
476 *ret = sig;
477
478 return 0;
479 }
480
481 void sigterm_process_group_handler(int signal, siginfo_t *info, void *ucontext) {
482 assert(signal == SIGTERM);
483 assert(info);
484
485 /* If the sender is not us, propagate the signal to all processes in
486 * the same process group */
487 if (si_code_from_process(info->si_code) &&
488 pid_is_valid(info->si_pid) &&
489 info->si_pid != getpid_cached())
490 (void) kill(0, signal);
491 }