iovec[n++] = IOVEC_MAKE_STRING(header);
va_start(ap, format);
+ DISABLE_WARNING_FORMAT_NONLITERAL;
r = log_format_iovec(iovec, iovec_len, &n, true, error, format, ap);
+ REENABLE_WARNING;
m = n;
if (r < 0)
fallback = true;
errno = ERRNO_VALUE(error);
va_copy(aq, ap);
+ DISABLE_WARNING_FORMAT_NONLITERAL;
(void) vsnprintf(buf, sizeof buf, format, aq);
+ REENABLE_WARNING;
va_end(aq);
if (startswith(buf, "MESSAGE=")) {
level,
error,
file, line, func,
- "MESSAGE_ID=" SD_MESSAGE_INVALID_CONFIGURATION_STR,
- "CONFIG_FILE=%s", config_file,
- "CONFIG_LINE=%u", config_line,
+ LOG_MESSAGE_ID(SD_MESSAGE_INVALID_CONFIGURATION_STR),
+ LOG_ITEM("CONFIG_FILE=%s", config_file),
+ LOG_ITEM("CONFIG_LINE=%u", config_line),
LOG_MESSAGE("%s:%u: %s", config_file, config_line, buffer),
unit_fmt, unit,
NULL);
level,
error,
file, line, func,
- "MESSAGE_ID=" SD_MESSAGE_INVALID_CONFIGURATION_STR,
- "CONFIG_FILE=%s", config_file,
+ LOG_MESSAGE_ID(SD_MESSAGE_INVALID_CONFIGURATION_STR),
+ LOG_ITEM("CONFIG_FILE=%s", config_file),
LOG_MESSAGE("%s: %s", config_file, buffer),
unit_fmt, unit,
NULL);
level,
error,
file, line, func,
- "MESSAGE_ID=" SD_MESSAGE_INVALID_CONFIGURATION_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_INVALID_CONFIGURATION_STR),
LOG_MESSAGE("%s: %s", unit, buffer),
unit_fmt, unit,
NULL);
level,
error,
file, line, func,
- "MESSAGE_ID=" SD_MESSAGE_INVALID_CONFIGURATION_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_INVALID_CONFIGURATION_STR),
LOG_MESSAGE("%s", buffer),
NULL);
}
const char *file,
int line,
const char *func,
- const char *format, ...) _printf_(6,0) _sentinel_;
+ const char *format, ...) _sentinel_;
int log_oom_internal(
int level,
/* Do a fake formatting of the message string to let the scanner verify the arguments against the format
* message. The variable will never be set to true, but we don't tell the compiler that :) */
extern bool _log_message_dummy;
-# define LOG_MESSAGE(fmt, ...) "MESSAGE=%.0d" fmt, (_log_message_dummy && printf(fmt, ##__VA_ARGS__)), ##__VA_ARGS__
+# define LOG_ITEM(fmt, ...) "%.0d" fmt, (_log_message_dummy && printf(fmt, ##__VA_ARGS__)), ##__VA_ARGS__
+# define LOG_MESSAGE(fmt, ...) LOG_ITEM("MESSAGE=" fmt, ##__VA_ARGS__)
#else
+# define LOG_ITEM(fmt, ...) fmt, ##__VA_ARGS__
# define LOG_MESSAGE(fmt, ...) "MESSAGE=" fmt, ##__VA_ARGS__
#endif
+#define LOG_MESSAGE_ID(id) LOG_ITEM("MESSAGE_ID=" id)
+
void log_received_signal(int level, const struct signalfd_siginfo *si);
/* If turned on, any requests for a log target involving "syslog" will be implicitly upgraded to the equivalent journal target */
if (pid < 0)
log_struct_errno(
LOG_EMERG, errno,
- "MESSAGE_ID=" SD_MESSAGE_VALGRIND_HELPER_FORK_STR,
- LOG_MESSAGE( "Failed to fork off valgrind helper: %m"));
+ LOG_MESSAGE_ID(SD_MESSAGE_VALGRIND_HELPER_FORK_STR),
+ LOG_MESSAGE("Failed to fork off valgrind helper: %m"));
else if (pid == 0)
exit(EXIT_SUCCESS);
else {
if (FLAGS_SET(flags, VALID_USER_WARN) && !valid_user_group_name(u, 0))
log_struct(LOG_NOTICE,
LOG_MESSAGE("Accepting user/group name '%s', which does not match strict user/group name rules.", u),
- "USER_GROUP_NAME=%s", u,
- "MESSAGE_ID=" SD_MESSAGE_UNSAFE_USER_NAME_STR);
+ LOG_ITEM("USER_GROUP_NAME=%s", u),
+ LOG_MESSAGE_ID(SD_MESSAGE_UNSAFE_USER_NAME_STR));
/* Note that we make no restrictions on the length in relaxed mode! */
} else {
return 0;
log_struct(LOG_EMERG,
LOG_MESSAGE("%s " BATTERY_LOW_MESSAGE, glyph(GLYPH_LOW_BATTERY)),
- "MESSAGE_ID=" SD_MESSAGE_BATTERY_LOW_WARNING_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_BATTERY_LOW_WARNING_STR));
fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
if (fd < 0)
if (r > 0) {
log_struct(LOG_EMERG,
LOG_MESSAGE("Battery level critically low, powering off."),
- "MESSAGE_ID=" SD_MESSAGE_BATTERY_LOW_POWEROFF_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_BATTERY_LOW_POWEROFF_STR));
return r;
}
if (n > 0)
log_unit_struct(u, LOG_NOTICE,
- "MESSAGE_ID=" SD_MESSAGE_UNIT_OOMD_KILL_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_UNIT_OOMD_KILL_STR),
LOG_UNIT_INVOCATION_ID(u),
LOG_UNIT_MESSAGE(u, "systemd-oomd killed %"PRIu64" process(es) in this unit.", n),
- "N_PROCESSES=%" PRIu64, n);
+ LOG_ITEM("N_PROCESSES=%" PRIu64, n));
else
log_unit_struct(u, LOG_NOTICE,
- "MESSAGE_ID=" SD_MESSAGE_UNIT_OOMD_KILL_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_UNIT_OOMD_KILL_STR),
LOG_UNIT_INVOCATION_ID(u),
LOG_UNIT_MESSAGE(u, "systemd-oomd killed some process(es) in this unit."));
return 0;
log_unit_struct(u, LOG_NOTICE,
- "MESSAGE_ID=" SD_MESSAGE_UNIT_OUT_OF_MEMORY_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_UNIT_OUT_OF_MEMORY_STR),
LOG_UNIT_INVOCATION_ID(u),
LOG_UNIT_MESSAGE(u, "A process of this unit has been killed by the OOM killer."));
"timestamp on "EPOCH_CLOCK_FILE;
if (advance)
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_TIME_BUMP_STR,
- "REALTIME_USEC=" USEC_FMT, epoch_usec,
- "DIRECTION=forwards",
+ LOG_MESSAGE_ID(SD_MESSAGE_TIME_BUMP_STR),
+ LOG_ITEM("REALTIME_USEC=" USEC_FMT, epoch_usec),
+ LOG_ITEM("DIRECTION=forwards"),
LOG_MESSAGE("System time advanced to %s: %s",
from,
FORMAT_TIMESTAMP(epoch_usec)));
else
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_TIME_BUMP_STR,
- "REALTIME_USEC=" USEC_FMT, epoch_usec,
- "DIRECTION=backwards",
+ LOG_MESSAGE_ID(SD_MESSAGE_TIME_BUMP_STR),
+ LOG_ITEM("REALTIME_USEC=" USEC_FMT, epoch_usec),
+ LOG_ITEM("DIRECTION=backwards"),
LOG_MESSAGE("System time was further ahead than %s after %s, clock reset to %s",
FORMAT_TIMESPAN(CLOCK_VALID_RANGE_USEC_MAX, USEC_PER_DAY),
from,
if (detect_container() > 0) {
log_struct(LOG_EMERG,
LOG_MESSAGE("Exiting PID 1..."),
- "MESSAGE_ID=" SD_MESSAGE_CRASH_EXIT_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CRASH_EXIT_STR));
_exit(EXIT_EXCEPTION);
}
(void) reboot(RB_POWER_OFF);
log_struct_errno(LOG_EMERG, errno,
LOG_MESSAGE("Failed to power off: %m"),
- "MESSAGE_ID=" SD_MESSAGE_CRASH_FAILED_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CRASH_FAILED_STR));
} else if (arg_crash_action == CRASH_REBOOT) {
log_notice("Rebooting in 10s...");
(void) sleep(10);
(void) reboot(RB_AUTOBOOT);
log_struct_errno(LOG_EMERG, errno,
LOG_MESSAGE("Failed to reboot: %m"),
- "MESSAGE_ID=" SD_MESSAGE_CRASH_FAILED_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CRASH_FAILED_STR));
}
log_struct(LOG_EMERG,
LOG_MESSAGE("Freezing execution."),
- "MESSAGE_ID=" SD_MESSAGE_CRASH_FREEZE_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CRASH_FREEZE_STR));
sync();
freeze();
}
else if (!arg_dump_core)
log_struct(LOG_EMERG,
LOG_MESSAGE("Caught <%s>, not dumping core.", signal_to_string(sig)),
- "MESSAGE_ID=" SD_MESSAGE_CRASH_NO_COREDUMP_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CRASH_NO_COREDUMP_STR));
else {
/* We want to wait for the core process, hence let's enable SIGCHLD */
(void) sigaction(SIGCHLD, &sigaction_nop_nocldstop, NULL);
if (pid < 0)
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);
+ LOG_MESSAGE_ID(SD_MESSAGE_CRASH_NO_FORK_STR));
else if (pid == 0) {
/* Enable default signal handler for core dump */
if (siginfo->si_pid == 0)
log_struct(LOG_EMERG,
LOG_MESSAGE("Caught <%s>, from unknown sender process.", signal_to_string(sig)),
- "MESSAGE_ID=" SD_MESSAGE_CRASH_UNKNOWN_SIGNAL_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CRASH_UNKNOWN_SIGNAL_STR));
else if (siginfo->si_pid == 1)
log_struct(LOG_EMERG,
LOG_MESSAGE("Caught <%s>, from our own process.", signal_to_string(sig)),
- "MESSAGE_ID=" SD_MESSAGE_CRASH_SYSTEMD_SIGNAL_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CRASH_SYSTEMD_SIGNAL_STR));
else
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);
+ LOG_MESSAGE_ID(SD_MESSAGE_CRASH_PROCESS_SIGNAL_STR));
}
/* Order things nicely. */
if (r < 0)
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);
+ LOG_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) :
sigchld_code_to_string(status.si_code),
status.si_status,
strna(s)),
- "MESSAGE_ID=" SD_MESSAGE_CRASH_COREDUMP_FAILED_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CRASH_COREDUMP_FAILED_STR));
} else
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);
+ LOG_MESSAGE_ID(SD_MESSAGE_CRASH_COREDUMP_PID_STR));
}
}
if (pid < 0)
log_struct_errno(LOG_EMERG, errno,
LOG_MESSAGE("Failed to fork off crash shell: %m"),
- "MESSAGE_ID=" SD_MESSAGE_CRASH_SHELL_FORK_FAILED_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CRASH_SHELL_FORK_FAILED_STR));
else if (pid == 0) {
(void) setsid();
(void) terminal_vhangup("/dev/console");
log_struct_errno(LOG_EMERG, errno,
LOG_MESSAGE("execle() failed: %m"),
- "MESSAGE_ID=" SD_MESSAGE_CRASH_EXECLE_FAILED_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CRASH_EXECLE_FAILED_STR));
_exit(EXIT_EXCEPTION);
} else {
log_info("Spawned crash shell as PID "PID_FMT".", pid);
if (r < 0)
return log_struct_errno(
LOG_WARNING, r,
- "MESSAGE_ID=" SD_MESSAGE_DEVICE_PATH_NOT_SUITABLE_STR,
- "DEVICE=%s", path,
+ LOG_MESSAGE_ID(SD_MESSAGE_DEVICE_PATH_NOT_SUITABLE_STR),
+ LOG_ITEM("DEVICE=%s", path),
LOG_MESSAGE("Failed to generate valid unit name from device path '%s', ignoring device: %m",
path));
_cleanup_free_ char *cmdline = quote_command_line(argv, SHELL_ESCAPE_EMPTY);
log_exec_struct(context, params, LOG_DEBUG,
- "EXECUTABLE=%s", executable,
+ LOG_ITEM("EXECUTABLE=%s", executable),
LOG_EXEC_MESSAGE(params, "%s: %s", msg, strnull(cmdline)),
LOG_EXEC_INVOCATION_ID(params));
}
if (r < 0) {
*exit_status = EXIT_EXEC;
log_exec_struct_errno(context, params, LOG_NOTICE, r,
- "MESSAGE_ID=" SD_MESSAGE_SPAWN_FAILED_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_SPAWN_FAILED_STR),
LOG_EXEC_MESSAGE(params,
"Unable to locate executable '%s': %m",
command->path),
- "EXECUTABLE=%s", command->path);
+ LOG_ITEM("EXECUTABLE=%s", command->path));
/* If the error will be ignored by manager, tune down the log level here. Missing executable
* is very much expected in this case. */
return r != -ENOMEM && FLAGS_SET(command->flags, EXEC_COMMAND_IGNORE_FAILURE) ? 1 : r;
_cleanup_free_ char *cmdline = quote_command_line(argv, SHELL_ESCAPE_EMPTY);
log_unit_struct(unit, LOG_DEBUG,
- "EXECUTABLE=%s", executable,
+ LOG_ITEM("EXECUTABLE=%s", executable),
LOG_UNIT_MESSAGE(unit, "%s: %s", msg, strnull(cmdline)),
LOG_UNIT_INVOCATION_ID(unit));
}
#define LOG_EXEC_ID_FIELD(ep) \
((ep)->runtime_scope == RUNTIME_SCOPE_USER ? "USER_UNIT=" : "UNIT=")
-#define LOG_EXEC_ID_FIELD_FORMAT(ep) \
- ((ep)->runtime_scope == RUNTIME_SCOPE_USER ? "USER_UNIT=%s" : "UNIT=%s")
#define LOG_EXEC_INVOCATION_ID_FIELD(ep) \
((ep)->runtime_scope == RUNTIME_SCOPE_USER ? "USER_INVOCATION_ID=" : "INVOCATION_ID=")
-#define LOG_EXEC_INVOCATION_ID_FIELD_FORMAT(ep) \
- ((ep)->runtime_scope == RUNTIME_SCOPE_USER ? "USER_INVOCATION_ID=%s" : "INVOCATION_ID=%s")
#define log_exec_full_errno_zerook(ec, ep, level, error, ...) \
({ \
/* Like LOG_MESSAGE(), but with the unit name prefixed. */
#define LOG_EXEC_MESSAGE(ep, fmt, ...) LOG_MESSAGE("%s: " fmt, (ep)->unit_id, ##__VA_ARGS__)
-#define LOG_EXEC_ID(ep) LOG_EXEC_ID_FIELD_FORMAT(ep), (ep)->unit_id
-#define LOG_EXEC_INVOCATION_ID(ep) LOG_EXEC_INVOCATION_ID_FIELD_FORMAT(ep), (ep)->invocation_id_string
+#define LOG_EXEC_ID(ep) LOG_ITEM("%s%s", LOG_EXEC_ID_FIELD(ep), (ep)->unit_id)
+#define LOG_EXEC_INVOCATION_ID(ep) LOG_ITEM("%s%s", LOG_EXEC_INVOCATION_ID_FIELD(ep), (ep)->invocation_id_string)
#define log_exec_struct_errno(ec, ep, level, error, ...) \
({ \
exit_status_to_string(exit_status, EXIT_STATUS_LIBC | EXIT_STATUS_SYSTEMD));
log_exec_struct_errno(&context, ¶ms, LOG_ERR, r,
- "MESSAGE_ID=" SD_MESSAGE_SPAWN_FAILED_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_SPAWN_FAILED_STR),
LOG_EXEC_MESSAGE(¶ms, "Failed at step %s spawning %s: %m",
status, command.path),
- "EXECUTABLE=%s", command.path);
+ LOG_ITEM("EXECUTABLE=%s", command.path));
} else
/* r == 0: 'skip' is chosen in the confirm spawn prompt
* r > 0: expected/ignored failure, do not log at error level */
DISABLE_WARNING_FORMAT_NONLITERAL;
log_unit_struct(u, LOG_INFO,
msg_fmt, ident,
- "JOB_ID=%" PRIu32, job_id,
- "JOB_TYPE=%s", job_type_to_string(t),
+ LOG_ITEM("JOB_ID=%" PRIu32, job_id),
+ LOG_ITEM("JOB_TYPE=%s", job_type_to_string(t)),
LOG_UNIT_INVOCATION_ID(u),
mid);
REENABLE_WARNING;
job_done_messages[result].log_level,
LOG_MESSAGE("%s was skipped because no trigger condition checks were met.",
ident),
- "JOB_ID=%" PRIu32, job_id,
- "JOB_TYPE=%s", job_type_to_string(t),
- "JOB_RESULT=%s", job_result_to_string(result),
+ LOG_ITEM("JOB_ID=%" PRIu32, job_id),
+ LOG_ITEM("JOB_TYPE=%s", job_type_to_string(t)),
+ LOG_ITEM("JOB_RESULT=%s", job_result_to_string(result)),
LOG_UNIT_INVOCATION_ID(u),
mid);
else
condition_type_to_string(c->type),
c->negate ? "!" : "",
c->parameter),
- "JOB_ID=%" PRIu32, job_id,
- "JOB_TYPE=%s", job_type_to_string(t),
- "JOB_RESULT=%s", job_result_to_string(result),
+ LOG_ITEM("JOB_ID=%" PRIu32, job_id),
+ LOG_ITEM("JOB_TYPE=%s", job_type_to_string(t)),
+ LOG_ITEM("JOB_RESULT=%s", job_result_to_string(result)),
LOG_UNIT_INVOCATION_ID(u),
mid);
} else {
DISABLE_WARNING_FORMAT_NONLITERAL;
log_unit_struct(u, job_done_messages[result].log_level,
msg_fmt, ident,
- "JOB_ID=%" PRIu32, job_id,
- "JOB_TYPE=%s", job_type_to_string(t),
- "JOB_RESULT=%s", job_result_to_string(result),
+ LOG_ITEM("JOB_ID=%" PRIu32, job_id),
+ LOG_ITEM("JOB_TYPE=%s", job_type_to_string(t)),
+ LOG_ITEM("JOB_RESULT=%s", job_result_to_string(result)),
LOG_UNIT_INVOCATION_ID(u),
mid);
REENABLE_WARNING;
* And JOB_FAILURE is already handled by the unit itself (unit_notify). */
if (IN_SET(result, JOB_TIMEOUT, JOB_DEPENDENCY)) {
log_unit_struct(u, LOG_NOTICE,
- "JOB_TYPE=%s", job_type_to_string(t),
- "JOB_RESULT=%s", job_result_to_string(result),
+ LOG_ITEM("JOB_TYPE=%s", job_type_to_string(t)),
+ LOG_ITEM("JOB_RESULT=%s", job_result_to_string(result)),
LOG_UNIT_MESSAGE(u, "Job %s/%s failed with result '%s'.",
u->id,
job_type_to_string(t),
if (strstr(lvalue, "User") && streq(k, NOBODY_USER_NAME))
log_struct(LOG_NOTICE,
- "MESSAGE=%s:%u: Special user %s configured, this is not safe!", filename, line, k,
- "UNIT=%s", unit,
- "MESSAGE_ID=" SD_MESSAGE_NOBODY_USER_UNSUITABLE_STR,
- "OFFENDING_USER=%s", k,
- "CONFIG_FILE=%s", filename,
- "CONFIG_LINE=%u", line);
+ LOG_MESSAGE("%s:%u: Special user %s configured, this is not safe!", filename, line, k),
+ LOG_MESSAGE_ID(SD_MESSAGE_NOBODY_USER_UNSUITABLE_STR),
+ LOG_ITEM("UNIT=%s", unit),
+ LOG_ITEM("OFFENDING_USER=%s", k),
+ LOG_ITEM("CONFIG_FILE=%s", filename),
+ LOG_ITEM("CONFIG_LINE=%u", line));
return free_and_replace(*user, k);
}
*ret_error_message = "Failed to run main loop";
return log_struct_errno(LOG_EMERG, objective,
LOG_MESSAGE("Failed to run main loop: %m"),
- "MESSAGE_ID=" SD_MESSAGE_CORE_MAINLOOP_FAILED_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CORE_MAINLOOP_FAILED_STR));
}
/* Ensure shutdown timestamp is taken even when bypassing the job engine */
*ret_error_message = "Failed to drop capability bounding set of usermode helpers";
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);
+ LOG_MESSAGE_ID(SD_MESSAGE_CORE_CAPABILITY_BOUNDING_USER_STR));
}
r = capability_bounding_set_drop(arg_capability_bounding_set, true);
*ret_error_message = "Failed to drop capability bounding set";
return log_struct_errno(LOG_EMERG, r,
LOG_MESSAGE("Failed to drop capability bounding set: %m"),
- "MESSAGE_ID=" SD_MESSAGE_CORE_CAPABILITY_BOUNDING_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CORE_CAPABILITY_BOUNDING_STR));
}
}
*ret_error_message = "Failed to disable new privileges";
return log_struct_errno(LOG_EMERG, errno,
LOG_MESSAGE("Failed to disable new privileges: %m"),
- "MESSAGE_ID=" SD_MESSAGE_CORE_DISABLE_PRIVILEGES_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CORE_DISABLE_PRIVILEGES_STR));
}
}
*ret_error_message = "$XDG_RUNTIME_DIR is not set";
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);
+ LOG_MESSAGE_ID(SD_MESSAGE_CORE_NO_XDGDIR_PATH_STR));
}
if (!skip_setup) {
*ret_error_message = "Failed to start default target";
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);
+ LOG_MESSAGE_ID(SD_MESSAGE_CORE_START_TARGET_FAILED_STR));
}
} else if (r < 0) {
*ret_error_message = "Failed to isolate default target";
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);
+ LOG_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),
*ret_error_message = "Failed to allocate fd set";
return log_struct_errno(LOG_EMERG, r,
LOG_MESSAGE("Failed to allocate fd set: %m"),
- "MESSAGE_ID=" SD_MESSAGE_CORE_FD_SET_FAILED_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CORE_FD_SET_FAILED_STR));
}
/* The serialization fd should have O_CLOEXEC turned on already, let's verify that we didn't pick it up here */
if (r < 0) {
log_struct_errno(LOG_EMERG, r,
LOG_MESSAGE("Failed to fix up PID 1 environment: %m"),
- "MESSAGE_ID=" SD_MESSAGE_CORE_PID1_ENVIRONMENT_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CORE_PID1_ENVIRONMENT_STR));
error_message = "Failed to fix up PID1 environment";
goto finish;
}
if (r < 0) {
log_struct_errno(LOG_EMERG, r,
LOG_MESSAGE("Failed to allocate manager object: %m"),
- "MESSAGE_ID=" SD_MESSAGE_CORE_MANAGER_ALLOCATE_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_CORE_MANAGER_ALLOCATE_STR));
error_message = "Failed to allocate manager object";
goto finish;
}
/* Prepare log fields we can use for structured logging */
if (MANAGER_IS_SYSTEM(m)) {
m->unit_log_field = "UNIT=";
- m->unit_log_format_string = "UNIT=%s";
-
m->invocation_log_field = "INVOCATION_ID=";
- m->invocation_log_format_string = "INVOCATION_ID=%s";
} else {
m->unit_log_field = "USER_UNIT=";
- m->unit_log_format_string = "USER_UNIT=%s";
-
m->invocation_log_field = "USER_INVOCATION_ID=";
- m->invocation_log_format_string = "USER_INVOCATION_ID=%s";
}
/* Reboot immediately if the user hits C-A-D more often than 7x per 2s */
Unit *u;
log_struct(LOG_DEBUG,
- "MESSAGE_ID=" SD_MESSAGE_TIME_CHANGE_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_TIME_CHANGE_STR),
LOG_MESSAGE("Time has been changed"));
/* Restart the watch */
log_struct(LOG_NOTICE,
LOG_MESSAGE("System is tainted: %s", taint),
- "TAINT=%s", taint,
- "MESSAGE_ID=" SD_MESSAGE_TAINTED_STR);
+ LOG_ITEM("TAINT=%s", taint),
+ LOG_MESSAGE_ID(SD_MESSAGE_TAINTED_STR));
}
static void manager_notify_finished(Manager *m) {
m->timestamps[MANAGER_TIMESTAMP_SHUTDOWN_START].monotonic);
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_STARTUP_FINISHED_STR,
- "USERSPACE_USEC="USEC_FMT, userspace_usec,
+ LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED_STR),
+ LOG_ITEM("USERSPACE_USEC="USEC_FMT, userspace_usec),
LOG_MESSAGE("Soft-reboot finished in %s, counter is now at %u.",
FORMAT_TIMESPAN(total_usec, USEC_PER_MSEC),
m->soft_reboots_count));
initrd_usec = m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic - m->timestamps[MANAGER_TIMESTAMP_INITRD].monotonic;
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_STARTUP_FINISHED_STR,
- "KERNEL_USEC="USEC_FMT, kernel_usec,
- "INITRD_USEC="USEC_FMT, initrd_usec,
- "USERSPACE_USEC="USEC_FMT, userspace_usec,
+ LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED_STR),
+ LOG_ITEM("KERNEL_USEC="USEC_FMT, kernel_usec),
+ LOG_ITEM("INITRD_USEC="USEC_FMT, initrd_usec),
+ LOG_ITEM("USERSPACE_USEC="USEC_FMT, userspace_usec),
LOG_MESSAGE("Startup finished in %s%s (kernel) + %s (initrd) + %s (userspace) = %s.",
buf,
FORMAT_TIMESPAN(kernel_usec, USEC_PER_MSEC),
initrd_usec = 0;
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_STARTUP_FINISHED_STR,
- "KERNEL_USEC="USEC_FMT, kernel_usec,
- "USERSPACE_USEC="USEC_FMT, userspace_usec,
+ LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED_STR),
+ LOG_ITEM("KERNEL_USEC="USEC_FMT, kernel_usec),
+ LOG_ITEM("USERSPACE_USEC="USEC_FMT, userspace_usec),
LOG_MESSAGE("Startup finished in %s%s (kernel) + %s (userspace) = %s.",
buf,
FORMAT_TIMESPAN(kernel_usec, USEC_PER_MSEC),
total_usec = userspace_usec = m->timestamps[MANAGER_TIMESTAMP_FINISH].monotonic - m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic;
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_USER_STARTUP_FINISHED_STR,
- "USERSPACE_USEC="USEC_FMT, userspace_usec,
+ LOG_MESSAGE_ID(SD_MESSAGE_USER_STARTUP_FINISHED_STR),
+ LOG_ITEM("USERSPACE_USEC="USEC_FMT, userspace_usec),
LOG_MESSAGE("Startup finished in %s.",
FORMAT_TIMESPAN(total_usec, USEC_PER_MSEC)));
}
EmergencyAction cad_burst_action;
const char *unit_log_field;
- const char *unit_log_format_string;
-
const char *invocation_log_field;
- const char *invocation_log_format_string;
int first_boot; /* tri-state */
if (r < 0)
return log_struct_errno(
LOG_WARNING, r,
- "MESSAGE_ID=" SD_MESSAGE_MOUNT_POINT_PATH_NOT_SUITABLE_STR,
- "MOUNT_POINT=%s", where,
+ LOG_MESSAGE_ID(SD_MESSAGE_MOUNT_POINT_PATH_NOT_SUITABLE_STR),
+ LOG_ITEM("MOUNT_POINT=%s", where),
LOG_MESSAGE("Failed to generate valid unit name from mount point path '%s', ignoring mount point: %m",
where));
if (!initialized)
return log_struct_errno(LOG_EMERG, SYNTHETIC_ERRNO(EIO),
LOG_MESSAGE("Failed to load SELinux policy :%m"),
- "MESSAGE_ID=" SD_MESSAGE_SELINUX_FAILED_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_SELINUX_FAILED_STR));
log_warning("Failed to load new SELinux policy. Continuing with old policy.");
} else
s->n_restarts++;
log_unit_struct(UNIT(s), LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_UNIT_RESTART_SCHEDULED_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_UNIT_RESTART_SCHEDULED_STR),
LOG_UNIT_INVOCATION_ID(UNIT(s)),
LOG_UNIT_MESSAGE(UNIT(s),
"Scheduled restart job%s, restart counter is at %u.",
shortcut ? " immediately on client request" : "", s->n_restarts),
- "N_RESTARTS=%u", s->n_restarts);
+ LOG_ITEM("N_RESTARTS=%u", s->n_restarts));
service_set_state(s, SERVICE_AUTO_RESTART_QUEUED);
if (strv_contains(tags, "RESTART_RESET=1") && IN_SET(s->state, SERVICE_RUNNING, SERVICE_STOP)) {
log_unit_struct(u, LOG_NOTICE,
LOG_UNIT_MESSAGE(u, "Got RESTART_RESET=1, resetting restart counter from %u.", s->n_restarts),
- "N_RESTARTS=0",
+ LOG_ITEM("N_RESTARTS=0"),
LOG_UNIT_INVOCATION_ID(u));
s->n_restarts = 0;
default:
return log_struct_errno(LOG_EMERG, r,
LOG_MESSAGE("Failed to write Smack onlycap list: %m"),
- "MESSAGE_ID=" SD_MESSAGE_SMACK_FAILED_WRITE_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_SMACK_FAILED_WRITE_STR));
}
*loaded_policy = true;
"Found %s on %s/%s",
unit_id == array ? "ordering cycle" : "dependency",
*unit_id, *job_type),
- "%s", strna(unit_ids));
+ LOG_ITEM("%s", strna(unit_ids)));
if (delete) {
const char *status;
"Job %s/%s deleted to break ordering cycle starting with %s/%s",
delete->unit->id, job_type_to_string(delete->type),
j->unit->id, job_type_to_string(j->type)),
- "%s", strna(unit_ids));
+ LOG_ITEM("%s", strna(unit_ids)));
if (log_get_show_color())
status = ANSI_HIGHLIGHT_RED " SKIP " ANSI_NORMAL;
log_struct(LOG_ERR,
LOG_UNIT_MESSAGE(j->unit, "Unable to break cycle starting with %s/%s",
j->unit->id, job_type_to_string(j->type)),
- "%s", strna(unit_ids));
+ LOG_ITEM("%s", strna(unit_ids)));
return sd_bus_error_setf(e, BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC,
"Transaction order is cyclic. See system logs for details.");
}
log_unit_struct(u, LOG_NOTICE,
- "MESSAGE_ID=" SD_MESSAGE_OVERMOUNTING_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING_STR),
LOG_UNIT_INVOCATION_ID(u),
LOG_UNIT_MESSAGE(u, "Directory %s to mount over is not empty, mounting anyway.", where),
- "WHERE=%s", where);
+ LOG_ITEM("WHERE=%s", where));
}
int unit_log_noncanonical_mount_path(Unit *u, const char *where) {
/* No need to mention "." or "..", they would already have been rejected by unit_name_from_path() */
log_unit_struct(u, LOG_ERR,
- "MESSAGE_ID=" SD_MESSAGE_NON_CANONICAL_MOUNT_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_NON_CANONICAL_MOUNT_STR),
LOG_UNIT_INVOCATION_ID(u),
LOG_UNIT_MESSAGE(u, "Mount path %s is not canonical (contains a symlink).", where),
- "WHERE=%s", where);
+ LOG_ITEM("WHERE=%s", where));
return -ELOOP;
}
* a lot of devices. */
log_unit_struct(u,
MANAGER_IS_USER(u->manager) ? LOG_DEBUG : LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_UNIT_SUCCESS_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_UNIT_SUCCESS_STR),
LOG_UNIT_INVOCATION_ID(u),
LOG_UNIT_MESSAGE(u, "Deactivated successfully."));
}
assert(result);
log_unit_struct(u, LOG_WARNING,
- "MESSAGE_ID=" SD_MESSAGE_UNIT_FAILURE_RESULT_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_UNIT_FAILURE_RESULT_STR),
LOG_UNIT_INVOCATION_ID(u),
LOG_UNIT_MESSAGE(u, "Failed with result '%s'.", result),
- "UNIT_RESULT=%s", result);
+ LOG_ITEM("UNIT_RESULT=%s", result));
}
void unit_log_skip(Unit *u, const char *result) {
assert(result);
log_unit_struct(u, LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_UNIT_SKIPPED_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_UNIT_SKIPPED_STR),
LOG_UNIT_INVOCATION_ID(u),
LOG_UNIT_MESSAGE(u, "Skipped due to '%s'.", result),
- "UNIT_RESULT=%s", result);
+ LOG_ITEM("UNIT_RESULT=%s", result));
}
void unit_log_process_exit(
level = LOG_WARNING;
log_unit_struct(u, level,
- "MESSAGE_ID=" SD_MESSAGE_UNIT_PROCESS_EXIT_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_UNIT_PROCESS_EXIT_STR),
LOG_UNIT_MESSAGE(u, "%s exited, code=%s, status=%i/%s%s",
kind,
sigchld_code_to_string(code), status,
? exit_status_to_string(status, EXIT_STATUS_FULL)
: signal_to_string(status)),
success ? " (success)" : ""),
- "EXIT_CODE=%s", sigchld_code_to_string(code),
- "EXIT_STATUS=%i", status,
- "COMMAND=%s", strna(command),
+ LOG_ITEM("EXIT_CODE=%s", sigchld_code_to_string(code)),
+ LOG_ITEM("EXIT_STATUS=%i", status),
+ LOG_ITEM("COMMAND=%s", strna(command)),
LOG_UNIT_INVOCATION_ID(u));
}
/* Like LOG_MESSAGE(), but with the unit name prefixed. */
#define LOG_UNIT_MESSAGE(unit, fmt, ...) LOG_MESSAGE("%s: " fmt, (unit)->id, ##__VA_ARGS__)
-#define LOG_UNIT_ID(unit) (unit)->manager->unit_log_format_string, (unit)->id
-#define LOG_UNIT_INVOCATION_ID(unit) (unit)->manager->invocation_log_format_string, (unit)->invocation_id_string
+#define LOG_UNIT_ID(unit) LOG_ITEM("%s%s", (unit)->manager->unit_log_field, (unit)->id)
+#define LOG_UNIT_INVOCATION_ID(unit) LOG_ITEM("%s%s", (unit)->manager->invocation_log_field, (unit)->invocation_id_string)
const char* collect_mode_to_string(CollectMode m) _const_;
CollectMode collect_mode_from_string(const char *s) _pure_;
if (truncated)
log_struct(LOG_INFO,
LOG_MESSAGE("Core file was truncated to %"PRIu64" bytes.", max_size),
- "SIZE_LIMIT=%"PRIu64, max_size,
- "MESSAGE_ID=" SD_MESSAGE_TRUNCATED_CORE_STR);
+ LOG_ITEM("SIZE_LIMIT=%"PRIu64, max_size),
+ LOG_MESSAGE_ID(SD_MESSAGE_TRUNCATED_CORE_STR));
r = fix_permissions(fd, tmp, fn, context, allow_user);
if (r < 0)
return log_error_errno(r, "Could not extend PCR: %m");
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_TPM_PCR_EXTEND_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_TPM_PCR_EXTEND_STR),
LOG_MESSAGE("Successfully extended PCR index %u with '%s' and volume key (banks %s).", arg_tpm2_measure_pcr, s, joined),
- "MEASURING=%s", s,
- "PCR=%u", arg_tpm2_measure_pcr,
- "BANKS=%s", joined);
+ LOG_ITEM("MEASURING=%s", s),
+ LOG_ITEM("PCR=%u", arg_tpm2_measure_pcr),
+ LOG_ITEM("BANKS=%s", joined));
return 0;
#else
LOG_MESSAGE("Memory trimming took %s, returned %s to OS.",
FORMAT_TIMESPAN(period, 0),
FORMAT_BYTES(l)),
- "MESSAGE_ID=" SD_MESSAGE_MEMORY_TRIM_STR,
- "TRIMMED_BYTES=%zu", l,
- "TRIMMED_USEC=" USEC_FMT, period);
+ LOG_MESSAGE_ID(SD_MESSAGE_MEMORY_TRIM_STR),
+ LOG_ITEM("TRIMMED_BYTES=%zu", l),
+ LOG_ITEM("TRIMMED_USEC=" USEC_FMT, period));
#else
log_struct(LOG_DEBUG,
LOG_MESSAGE("Memory trimming took %s.",
FORMAT_TIMESPAN(period, 0)),
- "MESSAGE_ID=" SD_MESSAGE_MEMORY_TRIM_STR,
- "TRIMMED_USEC=" USEC_FMT, period);
+ LOG_MESSAGE_ID(SD_MESSAGE_MEMORY_TRIM_STR),
+ LOG_ITEM("TRIMMED_USEC=" USEC_FMT, period));
#endif
return 0;
level,
error,
file, line, func,
- "MESSAGE_ID=" SD_MESSAGE_INVALID_CONFIGURATION_STR,
- "CONFIG_FILE=%s", source,
- "CONFIG_LINE=%u", source_line,
- "CONFIG_COLUMN=%u", source_column,
+ LOG_MESSAGE_ID(SD_MESSAGE_INVALID_CONFIGURATION_STR),
+ LOG_ITEM("CONFIG_FILE=%s", source),
+ LOG_ITEM("CONFIG_LINE=%u", source_line),
+ LOG_ITEM("CONFIG_COLUMN=%u", source_column),
LOG_MESSAGE("%s:%u:%u: %s", source, source_line, source_column, buffer),
NULL);
else if (source_line > 0 && source_column > 0)
level,
error,
file, line, func,
- "MESSAGE_ID=" SD_MESSAGE_INVALID_CONFIGURATION_STR,
- "CONFIG_LINE=%u", source_line,
- "CONFIG_COLUMN=%u", source_column,
+ LOG_MESSAGE_ID(SD_MESSAGE_INVALID_CONFIGURATION_STR),
+ LOG_ITEM("CONFIG_LINE=%u", source_line),
+ LOG_ITEM("CONFIG_COLUMN=%u", source_column),
LOG_MESSAGE("(string):%u:%u: %s", source_line, source_column, buffer),
NULL);
else
level,
error,
file, line, func,
- "MESSAGE_ID=" SD_MESSAGE_INVALID_CONFIGURATION_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_INVALID_CONFIGURATION_STR),
LOG_MESSAGE("%s", buffer),
NULL);
}
log_struct(LOG_INFO,
LOG_MESSAGE("Secure Attention Key sequence pressed on seat %s", seat),
- "MESSAGE_ID=" SD_MESSAGE_SECURE_ATTENTION_KEY_PRESS_STR,
- "SEAT_ID=%s", seat);
+ LOG_MESSAGE_ID(SD_MESSAGE_SECURE_ATTENTION_KEY_PRESS_STR),
+ LOG_ITEM("SEAT_ID=%s", seat));
r = sd_bus_emit_signal(
m->bus,
log_struct(LOG_INFO,
LOG_MESSAGE("Power key pressed long."),
- "MESSAGE_ID=" SD_MESSAGE_POWER_KEY_LONG_PRESS_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_POWER_KEY_LONG_PRESS_STR));
manager_handle_action(m, INHIBIT_HANDLE_POWER_KEY, m->handle_power_key_long_press, m->power_key_ignore_inhibited, /* is_edge= */ true, b->seat);
return 0;
log_struct(LOG_INFO,
LOG_MESSAGE("Reboot key pressed long."),
- "MESSAGE_ID=" SD_MESSAGE_REBOOT_KEY_LONG_PRESS_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_REBOOT_KEY_LONG_PRESS_STR));
manager_handle_action(m, INHIBIT_HANDLE_REBOOT_KEY, m->handle_reboot_key_long_press, m->reboot_key_ignore_inhibited, /* is_edge= */ true, b->seat);
return 0;
log_struct(LOG_INFO,
LOG_MESSAGE("Suspend key pressed long."),
- "MESSAGE_ID=" SD_MESSAGE_SUSPEND_KEY_LONG_PRESS_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_SUSPEND_KEY_LONG_PRESS_STR));
manager_handle_action(m, INHIBIT_HANDLE_SUSPEND_KEY, m->handle_suspend_key_long_press, m->suspend_key_ignore_inhibited, /* is_edge= */ true, b->seat);
return 0;
log_struct(LOG_INFO,
LOG_MESSAGE("Hibernate key pressed long."),
- "MESSAGE_ID=" SD_MESSAGE_HIBERNATE_KEY_LONG_PRESS_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_HIBERNATE_KEY_LONG_PRESS_STR));
manager_handle_action(m, INHIBIT_HANDLE_HIBERNATE_KEY, m->handle_hibernate_key_long_press, m->hibernate_key_ignore_inhibited, /* is_edge= */ true, b->seat);
return 0;
} else {
log_struct(LOG_INFO,
LOG_MESSAGE("Power key pressed short."),
- "MESSAGE_ID=" SD_MESSAGE_POWER_KEY_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_POWER_KEY_STR));
manager_handle_action(b->manager, INHIBIT_HANDLE_POWER_KEY, b->manager->handle_power_key, b->manager->power_key_ignore_inhibited, /* is_edge= */ true, b->seat);
}
break;
} else {
log_struct(LOG_INFO,
LOG_MESSAGE("Reboot key pressed short."),
- "MESSAGE_ID=" SD_MESSAGE_REBOOT_KEY_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_REBOOT_KEY_STR));
manager_handle_action(b->manager, INHIBIT_HANDLE_REBOOT_KEY, b->manager->handle_reboot_key, b->manager->reboot_key_ignore_inhibited, /* is_edge= */ true, b->seat);
}
break;
} else {
log_struct(LOG_INFO,
LOG_MESSAGE("Suspend key pressed short."),
- "MESSAGE_ID=" SD_MESSAGE_SUSPEND_KEY_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_SUSPEND_KEY_STR));
manager_handle_action(b->manager, INHIBIT_HANDLE_SUSPEND_KEY, b->manager->handle_suspend_key, b->manager->suspend_key_ignore_inhibited, /* is_edge= */ true, b->seat);
}
break;
} else {
log_struct(LOG_INFO,
LOG_MESSAGE("Hibernate key pressed short."),
- "MESSAGE_ID=" SD_MESSAGE_HIBERNATE_KEY_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_HIBERNATE_KEY_STR));
manager_handle_action(b->manager, INHIBIT_HANDLE_HIBERNATE_KEY, b->manager->handle_hibernate_key, b->manager->hibernate_key_ignore_inhibited, /* is_edge= */ true, b->seat);
}
break;
*/
log_struct(LOG_INFO,
LOG_MESSAGE("Power key pressed short."),
- "MESSAGE_ID=" SD_MESSAGE_POWER_KEY_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_POWER_KEY_STR));
b->manager->power_key_long_press_event_source = sd_event_source_unref(b->manager->power_key_long_press_event_source);
if (b->manager->reboot_key_long_press_event_source) {
log_struct(LOG_INFO,
LOG_MESSAGE("Reboot key pressed short."),
- "MESSAGE_ID=" SD_MESSAGE_REBOOT_KEY_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_REBOOT_KEY_STR));
b->manager->reboot_key_long_press_event_source = sd_event_source_unref(b->manager->reboot_key_long_press_event_source);
if (b->manager->suspend_key_long_press_event_source) {
log_struct(LOG_INFO,
LOG_MESSAGE("Suspend key pressed short."),
- "MESSAGE_ID=" SD_MESSAGE_SUSPEND_KEY_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_SUSPEND_KEY_STR));
b->manager->suspend_key_long_press_event_source = sd_event_source_unref(b->manager->suspend_key_long_press_event_source);
if (b->manager->hibernate_key_long_press_event_source) {
log_struct(LOG_INFO,
LOG_MESSAGE("Hibernate key pressed short."),
- "MESSAGE_ID=" SD_MESSAGE_HIBERNATE_KEY_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_HIBERNATE_KEY_STR));
b->manager->hibernate_key_long_press_event_source = sd_event_source_unref(b->manager->hibernate_key_long_press_event_source);
if (ev.code == SW_LID) {
log_struct(LOG_INFO,
LOG_MESSAGE("Lid closed."),
- "MESSAGE_ID=" SD_MESSAGE_LID_CLOSED_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_LID_CLOSED_STR));
b->lid_closed = true;
button_lid_switch_handle_action(b->manager, /* is_edge= */ true, b->seat);
} else if (ev.code == SW_DOCK) {
log_struct(LOG_INFO,
LOG_MESSAGE("System docked."),
- "MESSAGE_ID=" SD_MESSAGE_SYSTEM_DOCKED_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_SYSTEM_DOCKED_STR));
b->docked = true;
}
if (ev.code == SW_LID) {
log_struct(LOG_INFO,
LOG_MESSAGE("Lid opened."),
- "MESSAGE_ID=" SD_MESSAGE_LID_OPENED_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_LID_OPENED_STR));
b->lid_closed = false;
b->check_event_source = sd_event_source_unref(b->check_event_source);
} else if (ev.code == SW_DOCK) {
log_struct(LOG_INFO,
LOG_MESSAGE("System undocked."),
- "MESSAGE_ID=" SD_MESSAGE_SYSTEM_UNDOCKED_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_SYSTEM_UNDOCKED_STR));
b->docked = false;
}
const char *log_verb = a->log_verb ? strjoina("SHUTDOWN=", a->log_verb) : NULL;
return log_struct(LOG_NOTICE,
- "MESSAGE_ID=%s", a->message_id ?: SD_MESSAGE_SHUTDOWN_STR,
+ LOG_ITEM("MESSAGE_ID=%s", a->message_id ?: SD_MESSAGE_SHUTDOWN_STR),
LOG_MESSAGE("%s%s%s%s.",
message,
m->wall_message ? " (" : "",
log_struct(LOG_INFO,
LOG_MESSAGE("System shutdown has been cancelled"),
- "ACTION=%s", handle_action_to_string(a->handle),
- "MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_CANCELED_STR,
+ LOG_ITEM("ACTION=%s", handle_action_to_string(a->handle)),
+ LOG_MESSAGE_ID(SD_MESSAGE_SHUTDOWN_CANCELED_STR),
username ? "OPERATOR=%s" : NULL, username);
(void) wall("System shutdown has been cancelled",
return r;
log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_SESSION_START_STR,
- "SESSION_ID=%s", s->id,
- "USER_ID=%s", s->user->user_record->user_name,
- "LEADER="PID_FMT, s->leader.pid,
- "CLASS=%s", session_class_to_string(s->class),
- "TYPE=%s", session_type_to_string(s->type),
+ LOG_MESSAGE_ID(SD_MESSAGE_SESSION_START_STR),
+ LOG_ITEM("SESSION_ID=%s", s->id),
+ LOG_ITEM("USER_ID=%s", s->user->user_record->user_name),
+ LOG_ITEM("LEADER="PID_FMT, s->leader.pid),
+ LOG_ITEM("CLASS=%s", session_class_to_string(s->class)),
+ LOG_ITEM("TYPE=%s", session_type_to_string(s->type)),
LOG_MESSAGE("New session '%s' of user '%s' with class '%s' and type '%s'.",
s->id,
s->user->user_record->user_name,
* Therefore session stop and session removal may be two distinct events.
* Session stop is quite significant on its own, let's log it. */
log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
- "SESSION_ID=%s", s->id,
- "USER_ID=%s", s->user->user_record->user_name,
- "LEADER="PID_FMT, s->leader.pid,
+ LOG_ITEM("SESSION_ID=%s", s->id),
+ LOG_ITEM("USER_ID=%s", s->user->user_record->user_name),
+ LOG_ITEM("LEADER="PID_FMT, s->leader.pid),
LOG_MESSAGE("Session %s logged out. Waiting for processes to exit.", s->id));
}
if (s->started)
log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_SESSION_STOP_STR,
- "SESSION_ID=%s", s->id,
- "USER_ID=%s", s->user->user_record->user_name,
- "LEADER="PID_FMT, s->leader.pid,
+ LOG_MESSAGE_ID(SD_MESSAGE_SESSION_STOP_STR),
+ LOG_ITEM("SESSION_ID=%s", s->id),
+ LOG_ITEM("USER_ID=%s", s->user->user_record->user_name),
+ LOG_ITEM("LEADER="PID_FMT, s->leader.pid),
LOG_MESSAGE("Removed session %s.", s->id));
s->timer_event_source = sd_event_source_unref(s->timer_event_source);
log_struct(level,
LOG_MESSAGE("%s", l),
- "ACTION=%s", handle_action_to_string(m->scheduled_shutdown_action),
- "MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_SCHEDULED_STR,
+ LOG_ITEM("ACTION=%s", handle_action_to_string(m->scheduled_shutdown_action)),
+ LOG_MESSAGE_ID(SD_MESSAGE_SHUTDOWN_SCHEDULED_STR),
username ? "OPERATOR=%s" : NULL, username);
if (m->enable_wall_messages)
return r;
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_MACHINE_START_STR,
- "NAME=%s", m->name,
- "LEADER="PID_FMT, m->leader.pid,
+ LOG_MESSAGE_ID(SD_MESSAGE_MACHINE_START_STR),
+ LOG_ITEM("NAME=%s", m->name),
+ LOG_ITEM("LEADER="PID_FMT, m->leader.pid),
LOG_MESSAGE("New machine %s.", m->name));
if (!dual_timestamp_is_set(&m->timestamp))
if (m->started) {
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_MACHINE_STOP_STR,
- "NAME=%s", m->name,
- "LEADER="PID_FMT, m->leader.pid,
+ LOG_MESSAGE_ID(SD_MESSAGE_MACHINE_STOP_STR),
+ LOG_ITEM("NAME=%s", m->name),
+ LOG_ITEM("LEADER="PID_FMT, m->leader.pid),
LOG_MESSAGE("Machine %s terminated.", m->name));
m->stopping = true; /* The machine is supposed to be going away. Don't try to kill it. */
prefixlen,
IPV4_ADDRESS_FMT_VAL(router[0]),
IPV4_ADDRESS_FMT_VAL(server)),
- "ADDRESS="IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(address),
- "PREFIXLEN=%u", prefixlen,
- "GATEWAY="IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(router[0]));
+ LOG_ITEM("ADDRESS="IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(address)),
+ LOG_ITEM("PREFIXLEN=%u", prefixlen),
+ LOG_ITEM("GATEWAY="IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(router[0])));
else
log_struct(LOG_INFO,
LOG_LINK_INTERFACE(link),
IPV4_ADDRESS_FMT_VAL(address),
prefixlen,
IPV4_ADDRESS_FMT_VAL(server)),
- "ADDRESS="IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(address),
- "PREFIXLEN=%u", prefixlen);
+ LOG_ITEM("ADDRESS="IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(address)),
+ LOG_ITEM("PREFIXLEN=%u", prefixlen));
}
r = address_new(&addr);
if (!strneq(value, we->newvalue, sizeof(we->newvalue)))
log_struct(LOG_WARNING,
- "MESSAGE_ID=" SD_MESSAGE_SYSCTL_CHANGED_STR,
- "OBJECT_PID=" PID_FMT, we->pid,
- "OBJECT_COMM=%s", we->comm,
- "SYSCTL=%s", path,
- "OLDVALUE=%s", we->current,
- "NEWVALUE=%s", we->newvalue,
- "OURVALUE=%s", value,
+ LOG_MESSAGE_ID(SD_MESSAGE_SYSCTL_CHANGED_STR),
+ LOG_ITEM("OBJECT_PID=" PID_FMT, we->pid),
+ LOG_ITEM("OBJECT_COMM=%s", we->comm),
+ LOG_ITEM("SYSCTL=%s", path),
+ LOG_ITEM("OLDVALUE=%s", we->current),
+ LOG_ITEM("NEWVALUE=%s", we->newvalue),
+ LOG_ITEM("OURVALUE=%s", value),
LOG_MESSAGE("Foreign process '%s[" PID_FMT "]' changed sysctl '%s' from '%s' to '%s', conflicting with our setting to '%s'.",
we->comm, we->pid, path, we->current, we->newvalue, value));
return log_error_errno(r, "Could not extend PCR: %m");
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_TPM_PCR_EXTEND_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_TPM_PCR_EXTEND_STR),
LOG_MESSAGE("Extended PCR index %u with '%s' (banks %s).", pcr, safe, joined_banks),
- "MEASURING=%s", safe,
- "PCR=%u", pcr,
- "BANKS=%s", joined_banks);
+ LOG_ITEM("MEASURING=%s", safe),
+ LOG_ITEM("PCR=%u", pcr),
+ LOG_ITEM("BANKS=%s", joined_banks));
return 0;
}
isempty(profile) ? "" : "' using profile '",
strempty(profile)),
message_id,
- "PORTABLE_ROOT=%s", strna(root_base_name));
+ LOG_ITEM("PORTABLE_ROOT=%s", strna(root_base_name)));
}
int portable_attach(
return;
log_struct(LOG_NOTICE,
- "MESSAGE_ID=" SD_MESSAGE_DNSSEC_DOWNGRADE_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_DNSSEC_DOWNGRADE_STR),
LOG_MESSAGE("Server %s does not support DNSSEC, downgrading to non-DNSSEC mode.",
strna(dns_server_string_full(server))),
- "DNS_SERVER=%s", strna(dns_server_string_full(server)),
- "DNS_SERVER_FEATURE_LEVEL=%s", dns_server_feature_level_to_string(server->possible_feature_level));
+ LOG_ITEM("DNS_SERVER=%s", strna(dns_server_string_full(server))),
+ LOG_ITEM("DNS_SERVER_FEATURE_LEVEL=%s", dns_server_feature_level_to_string(server->possible_feature_level)));
server->warned_downgrade = true;
}
dns_resource_key_to_string(dns_transaction_key(t), key_str, sizeof key_str);
log_struct(LOG_NOTICE,
- "MESSAGE_ID=" SD_MESSAGE_DNSSEC_FAILURE_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_DNSSEC_FAILURE_STR),
LOG_MESSAGE("DNSSEC validation failed for question %s: %s",
key_str, dnssec_result_to_string(t->answer_dnssec_result)),
- "DNS_TRANSACTION=%" PRIu16, t->id,
- "DNS_QUESTION=%s", key_str,
- "DNSSEC_RESULT=%s", dnssec_result_to_string(t->answer_dnssec_result),
- "DNS_SERVER=%s", strna(dns_server_string_full(t->server)),
- "DNS_SERVER_FEATURE_LEVEL=%s", dns_server_feature_level_to_string(t->server->possible_feature_level));
+ LOG_ITEM("DNS_TRANSACTION=%" PRIu16, t->id),
+ LOG_ITEM("DNS_QUESTION=%s", key_str),
+ LOG_ITEM("DNSSEC_RESULT=%s", dnssec_result_to_string(t->answer_dnssec_result)),
+ LOG_ITEM("DNS_SERVER=%s", strna(dns_server_string_full(t->server))),
+ LOG_ITEM("DNS_SERVER_FEATURE_LEVEL=%s", dns_server_feature_level_to_string(t->server->possible_feature_level)));
}
/* Note that this call might invalidate the query. Callers
/* We found the key! Warn the user */
log_struct(LOG_WARNING,
- "MESSAGE_ID=" SD_MESSAGE_DNSSEC_TRUST_ANCHOR_REVOKED_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_DNSSEC_TRUST_ANCHOR_REVOKED_STR),
LOG_MESSAGE("DNSSEC trust anchor %s has been revoked.\n"
"Please update the trust anchor, or upgrade your operating system.",
strna(dns_resource_record_to_string(rr))),
- "TRUST_ANCHOR=%s", dns_resource_record_to_string(rr));
+ LOG_ITEM("TRUST_ANCHOR=%s", dns_resource_record_to_string(rr)));
if (dns_answer_size(new_answer) <= 0) {
assert_se(hashmap_remove(d->positive_by_key, rr->key) == old_answer);
error:
log_struct_errno(LOG_EMERG, r,
LOG_MESSAGE("Critical error while doing system shutdown: %m"),
- "MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_ERROR_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_SHUTDOWN_ERROR_STR));
freeze();
}
(void) lock_all_homes();
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_SLEEP_START_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_SLEEP_START_STR),
LOG_MESSAGE("Performing sleep operation '%s'...", sleep_operation_to_string(operation)),
- "SLEEP=%s", sleep_operation_to_string(arg_operation));
+ LOG_ITEM("SLEEP=%s", sleep_operation_to_string(arg_operation)));
r = write_state(state_fd, sleep_config->states[operation]);
if (r < 0)
log_struct_errno(LOG_ERR, r,
- "MESSAGE_ID=" SD_MESSAGE_SLEEP_STOP_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_SLEEP_STOP_STR),
LOG_MESSAGE("Failed to put system to sleep. System resumed again: %m"),
- "SLEEP=%s", sleep_operation_to_string(arg_operation));
+ LOG_ITEM("SLEEP=%s", sleep_operation_to_string(arg_operation)));
else
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_SLEEP_STOP_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_SLEEP_STOP_STR),
LOG_MESSAGE("System returned from sleep operation '%s'.", sleep_operation_to_string(arg_operation)),
- "SLEEP=%s", sleep_operation_to_string(arg_operation));
+ LOG_ITEM("SLEEP=%s", sleep_operation_to_string(arg_operation)));
arguments[1] = "post";
(void) execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL, NULL, (char **) arguments, NULL, EXEC_DIR_PARALLEL | EXEC_DIR_IGNORE_ERRORS);
fpath,
glyph(GLYPH_WARNING_SIGN),
glyph(GLYPH_WARNING_SIGN)),
- "MESSAGE_ID=" SD_MESSAGE_SYSV_GENERATOR_DEPRECATED_STR,
- "SYSVSCRIPT=%s", fpath,
- "UNIT=%s", name);
+ LOG_MESSAGE_ID(SD_MESSAGE_SYSV_GENERATOR_DEPRECATED_STR),
+ LOG_ITEM("SYSVSCRIPT=%s", fpath),
+ LOG_ITEM("UNIT=%s", name));
service = new(SysvStub, 1);
if (!service)
"MESSAGE=Waldo PID="PID_FMT" (no errno)", getpid_cached(),
"SERVICE=piepapo");
- /* The same as above, just using LOG_MESSAGE(), which is generally recommended */
+ /* The same as above, just using LOG_MESSAGE() and LOG_ITEM(), which is generally recommended */
log_struct(LOG_INFO,
LOG_MESSAGE("Waldo PID="PID_FMT" (no errno)", getpid_cached()),
- "SERVICE=piepapo");
+ LOG_ITEM("SERVICE=piepapo"));
log_struct_errno(LOG_INFO, EILSEQ,
LOG_MESSAGE("Waldo PID="PID_FMT": %m (normal)", getpid_cached()),
- "SERVICE=piepapo");
+ LOG_ITEM("SERVICE=piepapo"));
log_struct_errno(LOG_INFO, SYNTHETIC_ERRNO(EILSEQ),
LOG_MESSAGE("Waldo PID="PID_FMT": %m (synthetic)", getpid_cached()),
- "SERVICE=piepapo");
+ LOG_ITEM("SERVICE=piepapo"));
log_struct(LOG_INFO,
LOG_MESSAGE("Foobar PID="PID_FMT, getpid_cached()),
- "FORMAT_STR_TEST=1=%i A=%c 2=%hi 3=%li 4=%lli 1=%p foo=%s 2.5=%g 3.5=%g 4.5=%Lg",
- (int) 1, 'A', (short) 2, (long int) 3, (long long int) 4, (void*) 1, "foo", (float) 2.5f, (double) 3.5, (long double) 4.5,
- "SUFFIX=GOT IT");
+ LOG_ITEM("FORMAT_STR_TEST=1=%i A=%c 2=%hi 3=%li 4=%lli 1=%p foo=%s 2.5=%g 3.5=%g 4.5=%Lg",
+ (int) 1, 'A', (short) 2, (long int) 3, (long long int) 4, (void*) 1, "foo", (float) 2.5f, (double) 3.5, (long double) 4.5),
+ LOG_ITEM("SUFFIX=GOT IT"));
}
static void test_long_lines(void) {
#include <stddef.h>
#include <sys/stat.h>
+#include "sd-messages.h"
+
#include "errno-util.h"
#include "id128-util.h"
#include "log.h"
}
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_TIMEZONE_CHANGE_STR,
- "TIMEZONE=%s", c->zone,
- "TIMEZONE_SHORTNAME=%s", tzname[daylight],
- "DAYLIGHT=%i", daylight,
+ LOG_MESSAGE_ID(SD_MESSAGE_TIMEZONE_CHANGE_STR),
+ LOG_ITEM("TIMEZONE=%s", c->zone),
+ LOG_ITEM("TIMEZONE_SHORTNAME=%s", tzname[daylight]),
+ LOG_ITEM("DAYLIGHT=%i", daylight),
LOG_MESSAGE("Changed time zone to '%s' (%s).", c->zone, tzname[daylight]));
(void) sd_bus_emit_properties_changed(sd_bus_message_get_bus(m),
}
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_TIME_CHANGE_STR,
- "REALTIME="USEC_FMT, timespec_load(&ts),
+ LOG_MESSAGE_ID(SD_MESSAGE_TIME_CHANGE_STR),
+ LOG_ITEM("REALTIME="USEC_FMT, timespec_load(&ts)),
LOG_MESSAGE("Changed local time to %s", strnull(FORMAT_TIMESTAMP(timespec_load(&ts)))));
return sd_bus_reply_method_return(m, NULL);
log_struct(LOG_INFO,
LOG_MESSAGE("Initial clock synchronization to %s.",
FORMAT_TIMESTAMP_STYLE(dts.realtime, TIMESTAMP_US)),
- "MESSAGE_ID=" SD_MESSAGE_TIME_SYNC_STR,
- "MONOTONIC_USEC=" USEC_FMT, dts.monotonic,
- "REALTIME_USEC=" USEC_FMT, dts.realtime,
- "BOOTTIME_USEC=" USEC_FMT, dts.boottime);
+ LOG_MESSAGE_ID(SD_MESSAGE_TIME_SYNC_STR),
+ LOG_ITEM("MONOTONIC_USEC=" USEC_FMT, dts.monotonic),
+ LOG_ITEM("REALTIME_USEC=" USEC_FMT, dts.realtime),
+ LOG_ITEM("BOOTTIME_USEC=" USEC_FMT, dts.boottime));
}
r = manager_arm_timer(m, m->poll_interval_usec);
}
log_struct(LOG_INFO,
- "MESSAGE_ID=" SD_MESSAGE_TIME_BUMP_STR,
- "REALTIME_USEC=" USEC_FMT, epoch + 1,
- "DIRECTION=forwards",
+ LOG_MESSAGE_ID(SD_MESSAGE_TIME_BUMP_STR),
+ LOG_ITEM("REALTIME_USEC=" USEC_FMT, epoch + 1),
+ LOG_ITEM("DIRECTION=forwards"),
LOG_MESSAGE("System clock time advanced to %s: %s",
epoch > TIME_EPOCH * USEC_PER_SEC ? "recorded timestamp" : "built-in epoch",
FORMAT_TIMESTAMP(epoch + 1)));
return log_error_errno(r, "Failed to request TPM2 clearing via PPI, unable to write to /sys/class/tpm/tpm0/ppi/request: %m");
log_struct(LOG_NOTICE,
- "MESSAGE_ID=" SD_MESSAGE_TPM2_CLEAR_REQUESTED_STR,
+ LOG_MESSAGE_ID(SD_MESSAGE_TPM2_CLEAR_REQUESTED_STR),
LOG_MESSAGE("Requested TPM2 clearing via PPI. Firmware will verify with user and clear TPM on reboot."));
return 0;
}
if (r == -EDEADLK) {
log_struct_errno(LOG_INFO, r,
LOG_MESSAGE("Insufficient permissions to access TPM, not generating SRK."),
- "MESSAGE_ID=" SD_MESSAGE_SRK_ENROLLMENT_NEEDS_AUTHORIZATION_STR);
+ LOG_MESSAGE_ID(SD_MESSAGE_SRK_ENROLLMENT_NEEDS_AUTHORIZATION_STR));
return 76; /* Special return value which means "Insufficient permissions to access TPM,
* cannot generate SRK". This isn't really an error when called at boot. */;
}
if (runtime_key.pkey) {
if (memcmp_nn(tpm2_key.fingerprint, tpm2_key.fingerprint_size,
- runtime_key.fingerprint, runtime_key.fingerprint_size) != 0)
+ runtime_key.fingerprint, runtime_key.fingerprint_size) != 0)
return log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE),
"Saved runtime SRK differs from TPM SRK, refusing.");
log_struct(LOG_NOTICE,
LOG_MESSAGE("systemd-udev-settle.service is deprecated. Please fix %s not to pull it in.", t),
- "OFFENDING_UNITS=%s", t,
- "MESSAGE_ID=" SD_MESSAGE_SYSTEMD_UDEV_SETTLE_DEPRECATED_STR);
+ LOG_ITEM("OFFENDING_UNITS=%s", t),
+ LOG_MESSAGE_ID(SD_MESSAGE_SYSTEMD_UDEV_SETTLE_DEPRECATED_STR));
}
return 0;
projects / thirdparty / systemd.git / commitdiff
