| 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 |
} |