shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2024-11-06 08:26:52 +03:00
Code
e1714f0250
systemd/src/shared/exit-status.c

163 lines
9.0 KiB
C
Raw Normal View History

Add SPDX license identifiers to source files under the LGPL This follows what the kernel is doing, c.f. https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=5fd54ace4721fc5ce2bb5aef6318fcf17f421460.
2017-11-18 19:09:20 +03:00
/* SPDX-License-Identifier: LGPL-2.1+ */
exit-status: add missing files src/exit-status.h src/exit-status.c
2010-08-20 05:26:37 +04:00
exit-status: add missing include for SIG* defines Otherwise building fails with glibc 2.16. It works with glibc >= 2.17 because it is implicitly included via macro.h -> sys/param.h -> signal.h
2015-06-18 10:00:01 +03:00
#include <signal.h>
tree-wide: sort includes Sort the includes accoding to the new coding style.
2015-11-17 00:09:36 +03:00
#include <stdlib.h>
exit-status: list BSD exit codes too Let's optionally translate BSD exit codes to error strings too. My first approach on adding this was to turn ExitStatusLevel into a bitmask rather than a linear level, with one bit for the various feature bits. However, the exit code ranges are generally not defined independently from each other, i.e. our own ones are defined with the LSB ones in mind, and most sets are defined with the ISO C ones. Hence, instead I changed the existing hierarchy of MINIMAL, SYSTEMD, LSB with an alias of FULL == LSB, only slightly by seperating FULL and LSB into two separate levels, so that there's now: 1. MINIMAL (only EXIT_SUCCESS/EXIT_FAILURE) 2. SYSTEMD (incorporating our own exit codes) 3. LSB (like SYSTEMD but adding in LSB service exit codes) 4. FULL (like FULL but adding BSD exit codes) Note that across the codebase only FULL, SYSTEMD, and MINIMAL are used, depending on context, how much we know about the process and whether we are logging for debugging purposes or not. This means the LSB level wouldn't really have to be separate, but it appeared careless to me to fold it into FULL along with the BSD exit codes. Note that this commit doesn't change much for regular codepaths: the FULL exit status level is only used during debug logging, as a helper to the user reading the debug logs.
2018-04-23 20:26:25 +03:00
#include <sysexits.h>
exit-status: add missing files src/exit-status.h src/exit-status.c
2010-08-20 05:26:37 +04:00
#include "exit-status.h"
service: add options RestartPreventExitStatus and SuccessExitStatus In some cases, like wrong configuration, restarting after error does not help, so administrator can specify statuses by RestartPreventExitStatus which will not cause restart of a service. Sometimes you have non-standart exit status, so this can be specified by SuccessfulExitStatus.
2012-08-13 15:58:01 +04:00
#include "macro.h"
tree-wide: sort includes Sort the includes accoding to the new coding style.
2015-11-17 00:09:36 +03:00
#include "set.h"
exit-status: add missing files src/exit-status.h src/exit-status.c
2010-08-20 05:26:37 +04:00
shared/exit-status: turn status level into a bitmask, add "test" The "test" doesn't really test much automatically, but it is still useful to look at the mappings.
2019-07-28 11:13:21 +03:00
const ExitStatusMapping exit_status_mappings[256] = {
exit-status: list BSD exit codes too Let's optionally translate BSD exit codes to error strings too. My first approach on adding this was to turn ExitStatusLevel into a bitmask rather than a linear level, with one bit for the various feature bits. However, the exit code ranges are generally not defined independently from each other, i.e. our own ones are defined with the LSB ones in mind, and most sets are defined with the ISO C ones. Hence, instead I changed the existing hierarchy of MINIMAL, SYSTEMD, LSB with an alias of FULL == LSB, only slightly by seperating FULL and LSB into two separate levels, so that there's now: 1. MINIMAL (only EXIT_SUCCESS/EXIT_FAILURE) 2. SYSTEMD (incorporating our own exit codes) 3. LSB (like SYSTEMD but adding in LSB service exit codes) 4. FULL (like FULL but adding BSD exit codes) Note that across the codebase only FULL, SYSTEMD, and MINIMAL are used, depending on context, how much we know about the process and whether we are logging for debugging purposes or not. This means the LSB level wouldn't really have to be separate, but it appeared careless to me to fold it into FULL along with the BSD exit codes. Note that this commit doesn't change much for regular codepaths: the FULL exit status level is only used during debug logging, as a helper to the user reading the debug logs.
2018-04-23 20:26:25 +03:00
/* Exit status ranges:
*
* 0…1 │ ISO C, EXIT_SUCCESS + EXIT_FAILURE
* 2…7 │ LSB exit codes for init scripts
* 8…63 │ (Currently unmapped)
* 64…78 │ BSD defined exit codes
* 79…199 │ (Currently unmapped)
* 200…241 │ systemd's private error codes (might be extended to 254 in future development)
* 242…254 │ (Currently unmapped, but see above)
exit-status: introduce EXIT_EXCEPTION mapping to 255
2018-11-20 18:55:51 +03:00
*
* 255 │ EXIT_EXCEPTION (We use this to propagate exit-by-signal events. It's frequently used by others apps (like bash)
* │ to indicate exit reason that cannot really be expressed in a single exit status value — such as a propagated
* │ signal or such, and we follow that logic here.)
exit-status: list BSD exit codes too Let's optionally translate BSD exit codes to error strings too. My first approach on adding this was to turn ExitStatusLevel into a bitmask rather than a linear level, with one bit for the various feature bits. However, the exit code ranges are generally not defined independently from each other, i.e. our own ones are defined with the LSB ones in mind, and most sets are defined with the ISO C ones. Hence, instead I changed the existing hierarchy of MINIMAL, SYSTEMD, LSB with an alias of FULL == LSB, only slightly by seperating FULL and LSB into two separate levels, so that there's now: 1. MINIMAL (only EXIT_SUCCESS/EXIT_FAILURE) 2. SYSTEMD (incorporating our own exit codes) 3. LSB (like SYSTEMD but adding in LSB service exit codes) 4. FULL (like FULL but adding BSD exit codes) Note that across the codebase only FULL, SYSTEMD, and MINIMAL are used, depending on context, how much we know about the process and whether we are logging for debugging purposes or not. This means the LSB level wouldn't really have to be separate, but it appeared careless to me to fold it into FULL along with the BSD exit codes. Note that this commit doesn't change much for regular codepaths: the FULL exit status level is only used during debug logging, as a helper to the user reading the debug logs.
2018-04-23 20:26:25 +03:00
*/
shared/exit-status: turn status level into a bitmask, add "test" The "test" doesn't really test much automatically, but it is still useful to look at the mappings.
2019-07-28 11:13:21 +03:00
[EXIT_SUCCESS] = { "SUCCESS", EXIT_STATUS_GLIBC },
[EXIT_FAILURE] = { "FAILURE", EXIT_STATUS_GLIBC },
[EXIT_CHDIR] = { "CHDIR", EXIT_STATUS_SYSTEMD },
[EXIT_NICE] = { "NICE", EXIT_STATUS_SYSTEMD },
[EXIT_FDS] = { "FDS", EXIT_STATUS_SYSTEMD },
[EXIT_EXEC] = { "EXEC", EXIT_STATUS_SYSTEMD },
[EXIT_MEMORY] = { "MEMORY", EXIT_STATUS_SYSTEMD },
[EXIT_LIMITS] = { "LIMITS", EXIT_STATUS_SYSTEMD },
[EXIT_OOM_ADJUST] = { "OOM_ADJUST", EXIT_STATUS_SYSTEMD },
[EXIT_SIGNAL_MASK] = { "SIGNAL_MASK", EXIT_STATUS_SYSTEMD },
[EXIT_STDIN] = { "STDIN", EXIT_STATUS_SYSTEMD },
[EXIT_STDOUT] = { "STDOUT", EXIT_STATUS_SYSTEMD },
[EXIT_CHROOT] = { "CHROOT", EXIT_STATUS_SYSTEMD },
[EXIT_IOPRIO] = { "IOPRIO", EXIT_STATUS_SYSTEMD },
[EXIT_TIMERSLACK] = { "TIMERSLACK", EXIT_STATUS_SYSTEMD },
[EXIT_SECUREBITS] = { "SECUREBITS", EXIT_STATUS_SYSTEMD },
[EXIT_SETSCHEDULER] = { "SETSCHEDULER", EXIT_STATUS_SYSTEMD },
[EXIT_CPUAFFINITY] = { "CPUAFFINITY", EXIT_STATUS_SYSTEMD },
[EXIT_GROUP] = { "GROUP", EXIT_STATUS_SYSTEMD },
[EXIT_USER] = { "USER", EXIT_STATUS_SYSTEMD },
[EXIT_CAPABILITIES] = { "CAPABILITIES", EXIT_STATUS_SYSTEMD },
[EXIT_CGROUP] = { "CGROUP", EXIT_STATUS_SYSTEMD },
[EXIT_SETSID] = { "SETSID", EXIT_STATUS_SYSTEMD },
[EXIT_CONFIRM] = { "CONFIRM", EXIT_STATUS_SYSTEMD },
[EXIT_STDERR] = { "STDERR", EXIT_STATUS_SYSTEMD },
[EXIT_PAM] = { "PAM", EXIT_STATUS_SYSTEMD },
[EXIT_NETWORK] = { "NETWORK", EXIT_STATUS_SYSTEMD },
[EXIT_NAMESPACE] = { "NAMESPACE", EXIT_STATUS_SYSTEMD },
[EXIT_NO_NEW_PRIVILEGES] = { "NO_NEW_PRIVILEGES", EXIT_STATUS_SYSTEMD },
[EXIT_SECCOMP] = { "SECCOMP", EXIT_STATUS_SYSTEMD },
[EXIT_SELINUX_CONTEXT] = { "SELINUX_CONTEXT", EXIT_STATUS_SYSTEMD },
[EXIT_PERSONALITY] = { "PERSONALITY", EXIT_STATUS_SYSTEMD },
[EXIT_APPARMOR_PROFILE] = { "APPARMOR", EXIT_STATUS_SYSTEMD },
[EXIT_ADDRESS_FAMILIES] = { "ADDRESS_FAMILIES", EXIT_STATUS_SYSTEMD },
[EXIT_RUNTIME_DIRECTORY] = { "RUNTIME_DIRECTORY", EXIT_STATUS_SYSTEMD },
[EXIT_CHOWN] = { "CHOWN", EXIT_STATUS_SYSTEMD },
[EXIT_SMACK_PROCESS_LABEL] = { "SMACK_PROCESS_LABEL", EXIT_STATUS_SYSTEMD },
[EXIT_KEYRING] = { "KEYRING", EXIT_STATUS_SYSTEMD },
[EXIT_STATE_DIRECTORY] = { "STATE_DIRECTORY", EXIT_STATUS_SYSTEMD },
[EXIT_CACHE_DIRECTORY] = { "CACHE_DIRECTORY", EXIT_STATUS_SYSTEMD },
[EXIT_LOGS_DIRECTORY] = { "LOGS_DIRECTORY", EXIT_STATUS_SYSTEMD },
[EXIT_CONFIGURATION_DIRECTORY] = { "CONFIGURATION_DIRECTORY", EXIT_STATUS_SYSTEMD },
[EXIT_NUMA_POLICY] = { "NUMA_POLICY", EXIT_STATUS_SYSTEMD },
[EXIT_EXCEPTION] = { "EXCEPTION", EXIT_STATUS_SYSTEMD },
[EXIT_INVALIDARGUMENT] = { "INVALIDARGUMENT", EXIT_STATUS_LSB },
[EXIT_NOTIMPLEMENTED] = { "NOTIMPLEMENTED", EXIT_STATUS_LSB },
[EXIT_NOPERMISSION] = { "NOPERMISSION", EXIT_STATUS_LSB },
[EXIT_NOTINSTALLED] = { "NOTINSTALLED", EXIT_STATUS_LSB },
[EXIT_NOTCONFIGURED] = { "NOTCONFIGURED", EXIT_STATUS_LSB },
[EXIT_NOTRUNNING] = { "NOTRUNNING", EXIT_STATUS_LSB },
[EX_USAGE] = { "USAGE", EXIT_STATUS_BSD },
[EX_DATAERR] = { "DATAERR", EXIT_STATUS_BSD },
[EX_NOINPUT] = { "NOINPUT", EXIT_STATUS_BSD },
[EX_NOUSER] = { "NOUSER", EXIT_STATUS_BSD },
[EX_NOHOST] = { "NOHOST", EXIT_STATUS_BSD },
[EX_UNAVAILABLE] = { "UNAVAILABLE", EXIT_STATUS_BSD },
[EX_SOFTWARE] = { "SOFTWARE", EXIT_STATUS_BSD },
[EX_OSERR] = { "OSERR", EXIT_STATUS_BSD },
[EX_OSFILE] = { "OSFILE", EXIT_STATUS_BSD },
[EX_CANTCREAT] = { "CANTCREAT", EXIT_STATUS_BSD },
[EX_IOERR] = { "IOERR", EXIT_STATUS_BSD },
[EX_TEMPFAIL] = { "TEMPFAIL", EXIT_STATUS_BSD },
[EX_PROTOCOL] = { "PROTOCOL", EXIT_STATUS_BSD },
[EX_NOPERM] = { "NOPERM", EXIT_STATUS_BSD },
[EX_CONFIG] = { "CONFIG", EXIT_STATUS_BSD },
};
const char* exit_status_to_string(int code, ExitStatusClass class) {
if (code < 0 || (size_t) code >= ELEMENTSOF(exit_status_mappings))
return NULL;
return FLAGS_SET(exit_status_mappings[code].class, class) ? exit_status_mappings[code].name : NULL;
}
exit-status: list BSD exit codes too Let's optionally translate BSD exit codes to error strings too. My first approach on adding this was to turn ExitStatusLevel into a bitmask rather than a linear level, with one bit for the various feature bits. However, the exit code ranges are generally not defined independently from each other, i.e. our own ones are defined with the LSB ones in mind, and most sets are defined with the ISO C ones. Hence, instead I changed the existing hierarchy of MINIMAL, SYSTEMD, LSB with an alias of FULL == LSB, only slightly by seperating FULL and LSB into two separate levels, so that there's now: 1. MINIMAL (only EXIT_SUCCESS/EXIT_FAILURE) 2. SYSTEMD (incorporating our own exit codes) 3. LSB (like SYSTEMD but adding in LSB service exit codes) 4. FULL (like FULL but adding BSD exit codes) Note that across the codebase only FULL, SYSTEMD, and MINIMAL are used, depending on context, how much we know about the process and whether we are logging for debugging purposes or not. This means the LSB level wouldn't really have to be separate, but it appeared careless to me to fold it into FULL along with the BSD exit codes. Note that this commit doesn't change much for regular codepaths: the FULL exit status level is only used during debug logging, as a helper to the user reading the debug logs.
2018-04-23 20:26:25 +03:00
shared/exit-status: turn status level into a bitmask, add "test" The "test" doesn't really test much automatically, but it is still useful to look at the mappings.
2019-07-28 11:13:21 +03:00
const char* exit_status_class(int code) {
if (code < 0 || (size_t) code >= ELEMENTSOF(exit_status_mappings))
return NULL;
switch (exit_status_mappings[code].class) {
case EXIT_STATUS_GLIBC:
return "glibc";
case EXIT_STATUS_SYSTEMD:
return "systemd";
case EXIT_STATUS_LSB:
return "LSB";
case EXIT_STATUS_BSD:
return "BSD";
default: return NULL;
exit-status: list BSD exit codes too Let's optionally translate BSD exit codes to error strings too. My first approach on adding this was to turn ExitStatusLevel into a bitmask rather than a linear level, with one bit for the various feature bits. However, the exit code ranges are generally not defined independently from each other, i.e. our own ones are defined with the LSB ones in mind, and most sets are defined with the ISO C ones. Hence, instead I changed the existing hierarchy of MINIMAL, SYSTEMD, LSB with an alias of FULL == LSB, only slightly by seperating FULL and LSB into two separate levels, so that there's now: 1. MINIMAL (only EXIT_SUCCESS/EXIT_FAILURE) 2. SYSTEMD (incorporating our own exit codes) 3. LSB (like SYSTEMD but adding in LSB service exit codes) 4. FULL (like FULL but adding BSD exit codes) Note that across the codebase only FULL, SYSTEMD, and MINIMAL are used, depending on context, how much we know about the process and whether we are logging for debugging purposes or not. This means the LSB level wouldn't really have to be separate, but it appeared careless to me to fold it into FULL along with the BSD exit codes. Note that this commit doesn't change much for regular codepaths: the FULL exit status level is only used during debug logging, as a helper to the user reading the debug logs.
2018-04-23 20:26:25 +03:00
}
exit-status: add missing files src/exit-status.h src/exit-status.c
2010-08-20 05:26:37 +04:00
}
systemctl: highlight failed processes in systemctl status
2011-01-20 20:22:03 +03:00
core: when determining whether a process exit status is clean, consider whether it is a command or a daemon SIGTERM should be considered a clean exit code for daemons (i.e. long-running processes, as a daemon without SIGTERM handler may be shut down without issues via SIGTERM still) while it should not be considered a clean exit code for commands (i.e. short-running processes). Let's add two different clean checking modes for this, and use the right one at the appropriate places. Fixes: #4275
2016-10-10 23:07:30 +03:00
bool is_clean_exit(int code, int status, ExitClean clean, ExitStatusSet *success_status) {
systemctl: highlight failed processes in systemctl status
2011-01-20 20:22:03 +03:00
if (code == CLD_EXITED)
service: add options RestartPreventExitStatus and SuccessExitStatus In some cases, like wrong configuration, restarting after error does not help, so administrator can specify statuses by RestartPreventExitStatus which will not cause restart of a service. Sometimes you have non-standart exit status, so this can be specified by SuccessfulExitStatus.
2012-08-13 15:58:01 +04:00
return status == 0 ||
(success_status &&
basic: trivial indentation fix
2018-03-13 10:32:37 +03:00
set_contains(success_status->status, INT_TO_PTR(status)));
systemctl: highlight failed processes in systemctl status
2011-01-20 20:22:03 +03:00
core: when determining whether a process exit status is clean, consider whether it is a command or a daemon SIGTERM should be considered a clean exit code for daemons (i.e. long-running processes, as a daemon without SIGTERM handler may be shut down without issues via SIGTERM still) while it should not be considered a clean exit code for commands (i.e. short-running processes). Let's add two different clean checking modes for this, and use the right one at the appropriate places. Fixes: #4275
2016-10-10 23:07:30 +03:00
/* If a daemon does not implement handlers for some of the signals that's not considered an unclean shutdown */
systemctl: highlight failed processes in systemctl status
2011-01-20 20:22:03 +03:00
if (code == CLD_KILLED)
core: when determining whether a process exit status is clean, consider whether it is a command or a daemon SIGTERM should be considered a clean exit code for daemons (i.e. long-running processes, as a daemon without SIGTERM handler may be shut down without issues via SIGTERM still) while it should not be considered a clean exit code for commands (i.e. short-running processes). Let's add two different clean checking modes for this, and use the right one at the appropriate places. Fixes: #4275
2016-10-10 23:07:30 +03:00
return
(clean == EXIT_CLEAN_DAEMON && IN_SET(status, SIGHUP, SIGINT, SIGTERM, SIGPIPE)) ||
service: add options RestartPreventExitStatus and SuccessExitStatus In some cases, like wrong configuration, restarting after error does not help, so administrator can specify statuses by RestartPreventExitStatus which will not cause restart of a service. Sometimes you have non-standart exit status, so this can be specified by SuccessfulExitStatus.
2012-08-13 15:58:01 +04:00
(success_status &&
exit-code: minor coding style updates
2016-06-02 18:41:48 +03:00
set_contains(success_status->signal, INT_TO_PTR(status)));
systemctl: highlight failed processes in systemctl status
2011-01-20 20:22:03 +03:00
return false;
}
core: introduce new RestartForceExitStatus= service setting This does the inverse of RestartPreventExitStatus=: it forces a restart of a service when a certain exit status is returned by a service process.
2014-07-03 14:47:40 +04:00
void exit_status_set_free(ExitStatusSet *x) {
assert(x);
exit-code: minor coding style updates
2016-06-02 18:41:48 +03:00
x->status = set_free(x->status);
x->signal = set_free(x->signal);
core: introduce new RestartForceExitStatus= service setting This does the inverse of RestartPreventExitStatus=: it forces a restart of a service when a certain exit status is returned by a service process.
2014-07-03 14:47:40 +04:00
}
core: introduce exit_status_set_is_empty() to make things a bit easier to read
2014-07-03 17:50:31 +04:00
bool exit_status_set_is_empty(ExitStatusSet *x) {
if (!x)
return true;
return set_isempty(x->status) && set_isempty(x->signal);
}
exit-status: introduce common exit_status_set_test() call for testing exit status set membership
2015-04-28 19:24:20 +03:00
bool exit_status_set_test(ExitStatusSet *x, int code, int status) {
if (exit_status_set_is_empty(x))
return false;
if (code == CLD_EXITED && set_contains(x->status, INT_TO_PTR(status)))
return true;
if (IN_SET(code, CLD_KILLED, CLD_DUMPED) && set_contains(x->signal, INT_TO_PTR(status)))
return true;
return false;
}
Copy Permalink