#include <sys/reboot.h>
+#include "sd-messages.h"
+
#include "crash-handler.h"
#include "exit-status.h"
#include "macro.h"
/* If we are running in a container, let's prefer exiting, after all we can propagate an exit code to
* the container manager, and thus inform it that something went wrong. */
if (detect_container() > 0) {
- log_emergency("Exiting PID 1...");
+ log_struct(LOG_EMERG,
+ LOG_MESSAGE("Exiting PID 1..."),
+ "MESSAGE_ID=" SD_MESSAGE_CRASH_EXIT_STR);
_exit(EXIT_EXCEPTION);
}
log_notice("Rebooting now...");
(void) reboot(RB_AUTOBOOT);
- log_emergency_errno(errno, "Failed to reboot: %m");
+ log_struct_errno(LOG_EMERG, errno,
+ LOG_MESSAGE("Failed to reboot: %m"),
+ "MESSAGE_ID=" SD_MESSAGE_CRASH_FAILED_STR);
}
- log_emergency("Freezing execution.");
+ log_struct(LOG_EMERG,
+ LOG_MESSAGE("Freezing execution."),
+ "MESSAGE_ID=" SD_MESSAGE_CRASH_FREEZE_STR);
sync();
freeze();
}
/* Pass this on immediately, if this is not PID 1 */
propagate_signal(sig, siginfo);
else if (!arg_dump_core)
- log_emergency("Caught <%s>, not dumping core.", signal_to_string(sig));
+ log_struct(LOG_EMERG,
+ LOG_MESSAGE("Caught <%s>, not dumping core.", signal_to_string(sig)),
+ "MESSAGE_ID=" SD_MESSAGE_CRASH_NO_COREDUMP_STR);
else {
sa = (struct sigaction) {
.sa_handler = nop_signal_handler,
pid = raw_clone(SIGCHLD);
if (pid < 0)
- log_emergency_errno(errno, "Caught <%s>, cannot fork for core dump: %m", signal_to_string(sig));
+ log_struct_errno(LOG_EMERG, errno,
+ LOG_MESSAGE("Caught <%s>, cannot fork for core dump: %m", signal_to_string(sig)),
+ "MESSAGE_ID=" SD_MESSAGE_CRASH_NO_FORK_STR);
else if (pid == 0) {
/* Enable default signal handler for core dump */
if (siginfo) {
if (siginfo->si_pid == 0)
- log_emergency("Caught <%s> from unknown sender process.", signal_to_string(sig));
+ log_struct(LOG_EMERG,
+ LOG_MESSAGE("Caught <%s>, from unknown sender process.", signal_to_string(sig)),
+ "MESSAGE_ID=" SD_MESSAGE_CRASH_UNKNOWN_SIGNAL_STR);
else if (siginfo->si_pid == 1)
- log_emergency("Caught <%s> from our own process.", signal_to_string(sig));
+ log_struct(LOG_EMERG,
+ LOG_MESSAGE("Caught <%s>, from our own process.", signal_to_string(sig)),
+ "MESSAGE_ID=" SD_MESSAGE_CRASH_SYSTEMD_SIGNAL_STR);
else
- log_emergency("Caught <%s> from PID "PID_FMT".", signal_to_string(sig), siginfo->si_pid);
+ log_struct(LOG_EMERG,
+ LOG_MESSAGE("Caught <%s> from PID "PID_FMT".", signal_to_string(sig), siginfo->si_pid),
+ "MESSAGE_ID=" SD_MESSAGE_CRASH_PROCESS_SIGNAL_STR);
}
/* Order things nicely. */
r = wait_for_terminate(pid, &status);
if (r < 0)
- log_emergency_errno(r, "Caught <%s>, waitpid() failed: %m", signal_to_string(sig));
+ log_struct_errno(LOG_EMERG, r,
+ LOG_MESSAGE("Caught <%s>, waitpid() failed: %m", signal_to_string(sig)),
+ "MESSAGE_ID=" SD_MESSAGE_CRASH_WAITPID_FAILED_STR);
else if (status.si_code != CLD_DUMPED) {
const char *s = status.si_code == CLD_EXITED
? exit_status_to_string(status.si_status, EXIT_STATUS_LIBC)
: signal_to_string(status.si_status);
- log_emergency("Caught <%s>, core dump failed (child "PID_FMT", code=%s, status=%i/%s).",
- signal_to_string(sig),
- pid,
- sigchld_code_to_string(status.si_code),
- status.si_status, strna(s));
+ log_struct(LOG_EMERG,
+ LOG_MESSAGE("Caught <%s>, core dump failed (child "PID_FMT", code=%s, status=%i/%s).",
+ signal_to_string(sig),
+ pid,
+ sigchld_code_to_string(status.si_code),
+ status.si_status, strna(s)),
+ "MESSAGE_ID=" SD_MESSAGE_CRASH_COREDUMP_FAILED_STR);
} else
- log_emergency("Caught <%s>, dumped core as pid "PID_FMT".",
- signal_to_string(sig), pid);
+ log_struct(LOG_EMERG,
+ LOG_MESSAGE("Caught <%s>, dumped core as pid "PID_FMT".",
+ signal_to_string(sig), pid),
+ "MESSAGE_ID=" SD_MESSAGE_CRASH_COREDUMP_PID_STR);
}
}
pid = raw_clone(SIGCHLD);
if (pid < 0)
- log_emergency_errno(errno, "Failed to fork off crash shell: %m");
+ log_struct_errno(LOG_EMERG, errno,
+ LOG_MESSAGE("Failed to fork off crash shell: %m"),
+ "MESSAGE_ID=" SD_MESSAGE_CRASH_SHELL_FORK_FAILED_STR);
else if (pid == 0) {
(void) setsid();
(void) make_console_stdio();
(void) rlimit_nofile_safe();
(void) execle("/bin/sh", "/bin/sh", NULL, environ);
- log_emergency_errno(errno, "execle() failed: %m");
+ log_struct_errno(LOG_EMERG, errno,
+ LOG_MESSAGE("execle() failed: %m"),
+ "MESSAGE_ID=" SD_MESSAGE_CRASH_EXECLE_FAILED_STR);
_exit(EXIT_EXCEPTION);
} else {
log_info("Spawned crash shell as PID "PID_FMT".", pid);
int objective = manager_loop(m);
if (objective < 0) {
*ret_error_message = "Failed to run main loop";
- return log_emergency_errno(objective, "Failed to run main loop: %m");
+ return log_struct_errno(LOG_EMERG, objective,
+ LOG_MESSAGE("Failed to run main loop: %m"),
+ "MESSAGE_ID=" SD_MESSAGE_CORE_MAINLOOP_FAILED_STR);
}
switch (objective) {
r = xdg_user_runtime_dir(&p, "/systemd");
if (r < 0) {
*ret_error_message = "$XDG_RUNTIME_DIR is not set";
- return log_emergency_errno(r, "Failed to determine $XDG_RUNTIME_DIR path: %m");
+ return log_struct_errno(LOG_EMERG, r,
+ LOG_MESSAGE("Failed to determine $XDG_RUNTIME_DIR path: %m"),
+ "MESSAGE_ID=" SD_MESSAGE_CORE_NO_XDGDIR_PATH_STR);
}
(void) mkdir_p_label(p, 0755);
r = capability_bounding_set_drop_usermode(arg_capability_bounding_set);
if (r < 0) {
*ret_error_message = "Failed to drop capability bounding set of usermode helpers";
- return log_emergency_errno(r, "Failed to drop capability bounding set of usermode helpers: %m");
+ return log_struct_errno(LOG_EMERG, r,
+ LOG_MESSAGE("Failed to drop capability bounding set of usermode helpers: %m"),
+ "MESSAGE_ID=" SD_MESSAGE_CORE_CAPABILITY_BOUNDING_USER_STR);
}
r = capability_bounding_set_drop(arg_capability_bounding_set, true);
if (r < 0) {
*ret_error_message = "Failed to drop capability bounding set";
- return log_emergency_errno(r, "Failed to drop capability bounding set: %m");
+ return log_struct_errno(LOG_EMERG, r,
+ LOG_MESSAGE("Failed to drop capability bounding set: %m"),
+ "MESSAGE_ID=" SD_MESSAGE_CORE_CAPABILITY_BOUNDING_STR);
}
}
if (arg_no_new_privs) {
if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) < 0) {
*ret_error_message = "Failed to disable new privileges";
- return log_emergency_errno(errno, "Failed to disable new privileges: %m");
+ return log_struct_errno(LOG_EMERG, errno,
+ LOG_MESSAGE("Failed to disable new privileges: %m"),
+ "MESSAGE_ID=" SD_MESSAGE_CORE_DISABLE_PRIVILEGES_STR);
}
}
}
r = manager_add_job(m, JOB_START, target, JOB_REPLACE, NULL, &error, &job);
if (r < 0) {
*ret_error_message = "Failed to start default target";
- return log_emergency_errno(r, "Failed to start default target: %s", bus_error_message(&error, r));
+ return log_struct_errno(LOG_EMERG, r,
+ LOG_MESSAGE("Failed to start default target: %s", bus_error_message(&error, r)),
+ "MESSAGE_ID=" SD_MESSAGE_CORE_START_TARGET_FAILED_STR);
}
} else if (r < 0) {
*ret_error_message = "Failed to isolate default target";
- return log_emergency_errno(r, "Failed to isolate default target: %s", bus_error_message(&error, r));
+ return log_struct_errno(LOG_EMERG, r,
+ LOG_MESSAGE("Failed to isolate default target: %s", bus_error_message(&error, r)),
+ "MESSAGE_ID=" SD_MESSAGE_CORE_ISOLATE_TARGET_FAILED_STR);
} else
log_info("Queued %s job for default target %s.",
job_type_to_string(job->type),
r = fdset_new_fill(/* filter_cloexec= */ 0, ret_fds);
if (r < 0) {
*ret_error_message = "Failed to allocate fd set";
- return log_emergency_errno(r, "Failed to allocate fd set: %m");
+ return log_struct_errno(LOG_EMERG, r,
+ LOG_MESSAGE("Failed to allocate fd set: %m"),
+ "MESSAGE_ID=" SD_MESSAGE_CORE_FD_SET_FAILED_STR);
}
(void) fdset_cloexec(*ret_fds, true);
r = fixup_environment();
if (r < 0) {
- log_emergency_errno(r, "Failed to fix up PID 1 environment: %m");
+ log_struct_errno(LOG_EMERG, r,
+ LOG_MESSAGE("Failed to fix up PID 1 environment: %m"),
+ "MESSAGE_ID=" SD_MESSAGE_CORE_PID1_ENVIRONMENT_STR);
error_message = "Failed to fix up PID1 environment";
goto finish;
}
arg_action == ACTION_TEST ? MANAGER_TEST_FULL : 0,
&m);
if (r < 0) {
- log_emergency_errno(r, "Failed to allocate manager object: %m");
+ log_struct_errno(LOG_EMERG, r,
+ LOG_MESSAGE("Failed to allocate manager object: %m"),
+ "MESSAGE_ID=" SD_MESSAGE_CORE_MANAGER_ALLOCATE_STR);
error_message = "Failed to allocate manager object";
goto finish;
}
#define SD_MESSAGE_FACTORY_RESET SD_ID128_MAKE(c1,4a,af,76,ec,28,4a,5f,a1,f1,05,f8,8d,fb,06,1c)
#define SD_MESSAGE_FACTORY_RESET_STR SD_ID128_MAKE_STR(c1,4a,af,76,ec,28,4a,5f,a1,f1,05,f8,8d,fb,06,1c)
+#define SD_MESSAGE_CRASH_EXIT SD_ID128_MAKE(d9,ec,5e,95,e4,b6,46,aa,ae,a2,fd,05,21,4e,db,da)
+#define SD_MESSAGE_CRASH_EXIT_STR SD_ID128_MAKE_STR(d9,ec,5e,95,e4,b6,46,aa,ae,a2,fd,05,21,4e,db,da)
+#define SD_MESSAGE_CRASH_FAILED SD_ID128_MAKE(3e,d0,16,3e,86,8a,44,17,ab,8b,9e,21,04,07,a9,6c)
+#define SD_MESSAGE_CRASH_FAILED_STR SD_ID128_MAKE_STR(3e,d0,16,3e,86,8a,44,17,ab,8b,9e,21,04,07,a9,6c)
+#define SD_MESSAGE_CRASH_FREEZE SD_ID128_MAKE(64,5c,73,55,37,63,4a,e0,a3,2b,15,a7,c6,cb,a7,d4)
+#define SD_MESSAGE_CRASH_FREEZE_STR SD_ID128_MAKE_STR(64,5c,73,55,37,63,4a,e0,a3,2b,15,a7,c6,cb,a7,d4)
+
+#define SD_MESSAGE_CRASH_NO_COREDUMP SD_ID128_MAKE(5a,dd,b3,a0,6a,73,4d,33,96,b7,94,bf,98,fb,2d,01)
+#define SD_MESSAGE_CRASH_NO_COREDUMP_STR SD_ID128_MAKE_STR(5a,dd,b3,a0,6a,73,4d,33,96,b7,94,bf,98,fb,2d,01)
+#define SD_MESSAGE_CRASH_NO_FORK SD_ID128_MAKE(5c,9e,98,de,4a,b9,4c,6a,9d,04,d0,ad,79,3b,d9,03)
+#define SD_MESSAGE_CRASH_NO_FORK_STR SD_ID128_MAKE_STR(5c,9e,98,de,4a,b9,4c,6a,9d,04,d0,ad,79,3b,d9,03)
+#define SD_MESSAGE_CRASH_UNKNOWN_SIGNAL SD_ID128_MAKE(5e,6f,1f,5e,4d,b6,4a,0e,ae,e3,36,82,49,d2,0b,94)
+#define SD_MESSAGE_CRASH_UNKNOWN_SIGNAL_STR SD_ID128_MAKE_STR(5e,6f,1f,5e,4d,b6,4a,0e,ae,e3,36,82,49,d2,0b,94)
+#define SD_MESSAGE_CRASH_SYSTEMD_SIGNAL SD_ID128_MAKE(83,f8,4b,35,ee,26,4f,74,a3,89,6a,97,17,af,34,cb)
+#define SD_MESSAGE_CRASH_SYSTEMD_SIGNAL_STR SD_ID128_MAKE_STR(83,f8,4b,35,ee,26,4f,74,a3,89,6a,97,17,af,34,cb)
+#define SD_MESSAGE_CRASH_PROCESS_SIGNAL SD_ID128_MAKE(3a,73,a9,8b,af,5b,4b,19,99,29,e3,22,6c,0b,e7,83)
+#define SD_MESSAGE_CRASH_PROCESS_SIGNAL_STR SD_ID128_MAKE_STR(3a,73,a9,8b,af,5b,4b,19,99,29,e3,22,6c,0b,e7,83)
+#define SD_MESSAGE_CRASH_WAITPID_FAILED SD_ID128_MAKE(2e,d1,8d,4f,78,ca,47,f0,a9,bc,25,27,1c,26,ad,b4)
+#define SD_MESSAGE_CRASH_WAITPID_FAILED_STR SD_ID128_MAKE_STR(2e,d1,8d,4f,78,ca,47,f0,a9,bc,25,27,1c,26,ad,b4)
+#define SD_MESSAGE_CRASH_COREDUMP_FAILED SD_ID128_MAKE(56,b1,cd,96,f2,42,46,c5,b6,07,66,6f,da,95,23,56)
+#define SD_MESSAGE_CRASH_COREDUMP_FAILED_STR SD_ID128_MAKE_STR(56,b1,cd,96,f2,42,46,c5,b6,07,66,6f,da,95,23,56)
+#define SD_MESSAGE_CRASH_COREDUMP_PID SD_ID128_MAKE(4a,c7,56,6d,4d,75,48,f4,98,1f,62,9a,28,f0,f8,29)
+#define SD_MESSAGE_CRASH_COREDUMP_PID_STR SD_ID128_MAKE_STR(4a,c7,56,6d,4d,75,48,f4,98,1f,62,9a,28,f0,f8,29)
+#define SD_MESSAGE_CRASH_SHELL_FORK_FAILED SD_ID128_MAKE(38,e8,b1,e0,39,ad,46,92,91,b1,8b,44,c5,53,a5,b7)
+#define SD_MESSAGE_CRASH_SHELL_FORK_FAILED_STR SD_ID128_MAKE_STR(38,e8,b1,e0,39,ad,46,92,91,b1,8b,44,c5,53,a5,b7)
+#define SD_MESSAGE_CRASH_EXECLE_FAILED SD_ID128_MAKE(87,27,29,b4,7d,be,47,3e,b7,68,cc,ec,d4,77,be,da)
+#define SD_MESSAGE_CRASH_EXECLE_FAILED_STR SD_ID128_MAKE_STR(87,27,29,b4,7d,be,47,3e,b7,68,cc,ec,d4,77,be,da)
+
+#define SD_MESSAGE_SELINUX_FAILED SD_ID128_MAKE(65,8a,67,ad,c1,c9,40,b3,b3,31,6e,7e,86,28,83,4a)
+#define SD_MESSAGE_SELINUX_FAILED_STR SD_ID128_MAKE_STR(65,8a,67,ad,c1,c9,40,b3,b3,31,6e,7e,86,28,83,4a)
+
+#define SD_MESSAGE_BATTERY_LOW_WARNING SD_ID128_MAKE(e6,f4,56,bd,92,00,4d,95,80,16,0b,22,07,55,51,86)
+#define SD_MESSAGE_BATTERY_LOW_WARNING_STR SD_ID128_MAKE_STR(e6,f4,56,bd,92,00,4d,95,80,16,0b,22,07,55,51,86)
+#define SD_MESSAGE_BATTERY_LOW_POWEROFF SD_ID128_MAKE(26,74,37,d3,3f,dd,41,09,9a,d7,62,21,cc,24,a3,35)
+#define SD_MESSAGE_BATTERY_LOW_POWEROFF_STR SD_ID128_MAKE_STR(26,74,37,d3,3f,dd,41,09,9a,d7,62,21,cc,24,a3,35)
+
+#define SD_MESSAGE_CORE_MAINLOOP_FAILED SD_ID128_MAKE(79,e0,5b,67,bc,45,45,d1,92,2f,e4,71,07,ee,60,c5)
+#define SD_MESSAGE_CORE_MAINLOOP_FAILED_STR SD_ID128_MAKE_STR(79,e0,5b,67,bc,45,45,d1,92,2f,e4,71,07,ee,60,c5)
+#define SD_MESSAGE_CORE_NO_XDGDIR_PATH SD_ID128_MAKE(db,b1,36,b1,0e,f4,45,7b,a4,7a,79,5d,62,f1,08,c9)
+#define SD_MESSAGE_CORE_NO_XDGDIR_PATH_STR SD_ID128_MAKE_STR(db,b1,36,b1,0e,f4,45,7b,a4,7a,79,5d,62,f1,08,c9)
+#define SD_MESSAGE_CORE_CAPABILITY_BOUNDING_USER SD_ID128_MAKE(ed,15,8c,2d,f8,88,4f,a5,84,ee,ad,2d,90,2c,10,32)
+#define SD_MESSAGE_CORE_CAPABILITY_BOUNDING_USER_STR SD_ID128_MAKE_STR(ed,15,8c,2d,f8,88,4f,a5,84,ee,ad,2d,90,2c,10,32)
+#define SD_MESSAGE_CORE_CAPABILITY_BOUNDING SD_ID128_MAKE(42,69,5b,50,0d,f0,48,29,8b,ee,37,15,9c,aa,9f,2e)
+#define SD_MESSAGE_CORE_CAPABILITY_BOUNDING_STR SD_ID128_MAKE_STR(42,69,5b,50,0d,f0,48,29,8b,ee,37,15,9c,aa,9f,2e)
+#define SD_MESSAGE_CORE_DISABLE_PRIVILEGES SD_ID128_MAKE(bf,c2,43,07,24,ab,44,49,97,35,b4,f9,4c,ca,92,95)
+#define SD_MESSAGE_CORE_DISABLE_PRIVILEGES_STR SD_ID128_MAKE_STR(bf,c2,43,07,24,ab,44,49,97,35,b4,f9,4c,ca,92,95)
+#define SD_MESSAGE_CORE_START_TARGET_FAILED SD_ID128_MAKE(59,28,8a,f5,23,be,43,a2,8d,49,4e,41,e2,6e,45,10)
+#define SD_MESSAGE_CORE_START_TARGET_FAILED_STR SD_ID128_MAKE_STR(59,28,8a,f5,23,be,43,a2,8d,49,4e,41,e2,6e,45,10)
+#define SD_MESSAGE_CORE_ISOLATE_TARGET_FAILED SD_ID128_MAKE(68,9b,4f,cc,97,b4,48,6e,a5,da,92,db,69,c9,e3,14)
+#define SD_MESSAGE_CORE_ISOLATE_TARGET_FAILED_STR SD_ID128_MAKE_STR(68,9b,4f,cc,97,b4,48,6e,a5,da,92,db,69,c9,e3,14)
+#define SD_MESSAGE_CORE_FD_SET_FAILED SD_ID128_MAKE(5e,d8,36,f1,76,6f,4a,8a,9f,c5,da,45,aa,e2,3b,29)
+#define SD_MESSAGE_CORE_FD_SET_FAILED_STR SD_ID128_MAKE_STR(5e,d8,36,f1,76,6f,4a,8a,9f,c5,da,45,aa,e2,3b,29)
+#define SD_MESSAGE_CORE_PID1_ENVIRONMENT SD_ID128_MAKE(6a,40,fb,fb,d2,ba,4b,8d,b0,2f,b4,0c,9c,d0,90,d7)
+#define SD_MESSAGE_CORE_PID1_ENVIRONMENT_STR SD_ID128_MAKE_STR(6a,40,fb,fb,d2,ba,4b,8d,b0,2f,b4,0c,9c,d0,90,d7)
+#define SD_MESSAGE_CORE_MANAGER_ALLOCATE SD_ID128_MAKE(0e,54,47,09,84,ac,41,96,89,74,3d,95,7a,11,9e,2e)
+#define SD_MESSAGE_CORE_MANAGER_ALLOCATE_STR SD_ID128_MAKE_STR(0e,54,47,09,84,ac,41,96,89,74,3d,95,7a,11,9e,2e)
+
+#define SD_MESSAGE_SMACK_FAILED_WRITE SD_ID128_MAKE(d6,7f,a9,f8,47,aa,4b,04,8a,2a,e3,35,35,33,1a,db)
+#define SD_MESSAGE_SMACK_FAILED_WRITE_STR SD_ID128_MAKE_STR(d6,7f,a9,f8,47,aa,4b,04,8a,2a,e3,35,35,33,1a,db)
+
+#define SD_MESSAGE_SHUTDOWN_ERROR SD_ID128_MAKE(af,55,a6,f7,5b,54,44,31,b7,26,49,f3,6f,f6,d6,2c)
+#define SD_MESSAGE_SHUTDOWN_ERROR_STR SD_ID128_MAKE_STR(af,55,a6,f7,5b,54,44,31,b7,26,49,f3,6f,f6,d6,2c)
+
+#define SD_MESSAGE_VALGRIND_HELPER_FORK SD_ID128_MAKE(d1,8e,03,39,ef,b2,4a,06,8d,9c,10,60,22,10,48,c2)
+#define SD_MESSAGE_VALGRIND_HELPER_FORK_STR SD_ID128_MAKE_STR(d1,8e,03,39,ef,b2,4a,06,8d,9c,10,60,22,10,48,c2)
+
/* The messages below are actually about jobs, not really about units, the macros are misleadingly named.
* Moreover SD_MESSAGE_UNIT_FAILED is not actually about a failing unit but about a failed start job. A job
* either finishes with SD_MESSAGE_UNIT_STARTED or with SD_MESSAGE_UNIT_FAILED hence. */
projects / thirdparty / systemd.git / commitdiff
