1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
27 #include <sys/socket.h>
36 #include "socket-util.h"
37 #include "formats-util.h"
38 #include "process-util.h"
39 #include "terminal-util.h"
41 #define SNDBUF_SIZE (8*1024*1024)
43 static LogTarget log_target = LOG_TARGET_CONSOLE;
44 static int log_max_level = LOG_INFO;
45 static int log_facility = LOG_DAEMON;
47 static int console_fd = STDERR_FILENO;
48 static int syslog_fd = -1;
49 static int kmsg_fd = -1;
50 static int journal_fd = -1;
52 static bool syslog_is_stream = false;
54 static bool show_color = false;
55 static bool show_location = false;
57 static bool upgrade_syslog_to_journal = false;
59 /* Akin to glibc's __abort_msg; which is private and we hence cannot
61 static char *log_abort_msg = NULL;
63 void log_close_console(void) {
70 safe_close(console_fd);
76 static int log_open_console(void) {
82 console_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
86 console_fd = STDERR_FILENO;
91 void log_close_kmsg(void) {
92 kmsg_fd = safe_close(kmsg_fd);
95 static int log_open_kmsg(void) {
100 kmsg_fd = open("/dev/kmsg", O_WRONLY|O_NOCTTY|O_CLOEXEC);
107 void log_close_syslog(void) {
108 syslog_fd = safe_close(syslog_fd);
111 static int create_log_socket(int type) {
115 fd = socket(AF_UNIX, type|SOCK_CLOEXEC, 0);
119 fd_inc_sndbuf(fd, SNDBUF_SIZE);
121 /* We need a blocking fd here since we'd otherwise lose
122 messages way too early. However, let's not hang forever in the
123 unlikely case of a deadlock. */
125 timeval_store(&tv, 10 * USEC_PER_MSEC);
127 timeval_store(&tv, 10 * USEC_PER_SEC);
128 (void) setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
133 static int log_open_syslog(void) {
135 static const union sockaddr_union sa = {
136 .un.sun_family = AF_UNIX,
137 .un.sun_path = "/dev/log",
145 syslog_fd = create_log_socket(SOCK_DGRAM);
151 if (connect(syslog_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)) < 0) {
152 safe_close(syslog_fd);
154 /* Some legacy syslog systems still use stream
155 * sockets. They really shouldn't. But what can we
157 syslog_fd = create_log_socket(SOCK_STREAM);
163 if (connect(syslog_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)) < 0) {
168 syslog_is_stream = true;
170 syslog_is_stream = false;
179 void log_close_journal(void) {
180 journal_fd = safe_close(journal_fd);
183 static int log_open_journal(void) {
185 static const union sockaddr_union sa = {
186 .un.sun_family = AF_UNIX,
187 .un.sun_path = "/run/systemd/journal/socket",
195 journal_fd = create_log_socket(SOCK_DGRAM);
196 if (journal_fd < 0) {
201 if (connect(journal_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)) < 0) {
216 /* If we don't use the console we close it here, to not get
217 * killed by SAK. If we don't use syslog we close it here so
218 * that we are not confused by somebody deleting the socket in
219 * the fs. If we don't use /dev/kmsg we still keep it open,
220 * because there is no reason to close it. */
222 if (log_target == LOG_TARGET_NULL) {
229 if ((log_target != LOG_TARGET_AUTO && log_target != LOG_TARGET_SAFE) ||
231 isatty(STDERR_FILENO) <= 0) {
233 if (log_target == LOG_TARGET_AUTO ||
234 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
235 log_target == LOG_TARGET_JOURNAL) {
236 r = log_open_journal();
244 if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
245 log_target == LOG_TARGET_SYSLOG) {
246 r = log_open_syslog();
254 if (log_target == LOG_TARGET_AUTO ||
255 log_target == LOG_TARGET_SAFE ||
256 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
257 log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
258 log_target == LOG_TARGET_KMSG) {
272 return log_open_console();
275 void log_set_target(LogTarget target) {
277 assert(target < _LOG_TARGET_MAX);
279 if (upgrade_syslog_to_journal) {
280 if (target == LOG_TARGET_SYSLOG)
281 target = LOG_TARGET_JOURNAL;
282 else if (target == LOG_TARGET_SYSLOG_OR_KMSG)
283 target = LOG_TARGET_JOURNAL_OR_KMSG;
289 void log_close(void) {
296 void log_forget_fds(void) {
297 console_fd = kmsg_fd = syslog_fd = journal_fd = -1;
300 void log_set_max_level(int level) {
301 assert((level & LOG_PRIMASK) == level);
303 log_max_level = level;
306 void log_set_facility(int facility) {
307 log_facility = facility;
310 static int write_to_console(
316 const char *object_field,
318 const char *buffer) {
320 char location[64], prefix[1 + DECIMAL_STR_MAX(int) + 2];
321 struct iovec iovec[6] = {};
328 if (log_target == LOG_TARGET_CONSOLE_PREFIXED) {
329 sprintf(prefix, "<%i>", level);
330 IOVEC_SET_STRING(iovec[n++], prefix);
333 highlight = LOG_PRI(level) <= LOG_ERR && show_color;
336 snprintf(location, sizeof(location), "(%s:%i) ", file, line);
337 IOVEC_SET_STRING(iovec[n++], location);
341 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_RED_ON);
342 IOVEC_SET_STRING(iovec[n++], buffer);
344 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_OFF);
345 IOVEC_SET_STRING(iovec[n++], "\n");
347 if (writev(console_fd, iovec, n) < 0) {
349 if (errno == EIO && getpid() == 1) {
351 /* If somebody tried to kick us from our
352 * console tty (via vhangup() or suchlike),
353 * try to reconnect */
361 if (writev(console_fd, iovec, n) < 0)
370 static int write_to_syslog(
376 const char *object_field,
378 const char *buffer) {
380 char header_priority[2 + DECIMAL_STR_MAX(int) + 1],
382 header_pid[4 + DECIMAL_STR_MAX(pid_t) + 1];
383 struct iovec iovec[5] = {};
384 struct msghdr msghdr = {
386 .msg_iovlen = ELEMENTSOF(iovec),
394 xsprintf(header_priority, "<%i>", level);
396 t = (time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC);
401 if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
404 xsprintf(header_pid, "["PID_FMT"]: ", getpid());
406 IOVEC_SET_STRING(iovec[0], header_priority);
407 IOVEC_SET_STRING(iovec[1], header_time);
408 IOVEC_SET_STRING(iovec[2], program_invocation_short_name);
409 IOVEC_SET_STRING(iovec[3], header_pid);
410 IOVEC_SET_STRING(iovec[4], buffer);
412 /* When using syslog via SOCK_STREAM separate the messages by NUL chars */
413 if (syslog_is_stream)
419 n = sendmsg(syslog_fd, &msghdr, MSG_NOSIGNAL);
423 if (!syslog_is_stream ||
424 (size_t) n >= IOVEC_TOTAL_SIZE(iovec, ELEMENTSOF(iovec)))
427 IOVEC_INCREMENT(iovec, ELEMENTSOF(iovec), n);
433 static int write_to_kmsg(
439 const char *object_field,
441 const char *buffer) {
443 char header_priority[2 + DECIMAL_STR_MAX(int) + 1],
444 header_pid[4 + DECIMAL_STR_MAX(pid_t) + 1];
445 struct iovec iovec[5] = {};
450 xsprintf(header_priority, "<%i>", level);
451 xsprintf(header_pid, "["PID_FMT"]: ", getpid());
453 IOVEC_SET_STRING(iovec[0], header_priority);
454 IOVEC_SET_STRING(iovec[1], program_invocation_short_name);
455 IOVEC_SET_STRING(iovec[2], header_pid);
456 IOVEC_SET_STRING(iovec[3], buffer);
457 IOVEC_SET_STRING(iovec[4], "\n");
459 if (writev(kmsg_fd, iovec, ELEMENTSOF(iovec)) < 0)
465 static int log_do_header(
470 const char *file, int line, const char *func,
471 const char *object_field, const char *object) {
473 snprintf(header, size,
475 "SYSLOG_FACILITY=%i\n"
481 "SYSLOG_IDENTIFIER=%s\n",
484 isempty(file) ? "" : "CODE_FILE=",
485 isempty(file) ? "" : file,
486 isempty(file) ? "" : "\n",
487 line ? "CODE_LINE=" : "",
488 line ? 1 : 0, line, /* %.0d means no output too, special case for 0 */
490 isempty(func) ? "" : "CODE_FUNCTION=",
491 isempty(func) ? "" : func,
492 isempty(func) ? "" : "\n",
493 error ? "ERRNO=" : "",
494 error ? 1 : 0, error,
496 isempty(object) ? "" : object_field,
497 isempty(object) ? "" : object,
498 isempty(object) ? "" : "\n",
499 program_invocation_short_name);
504 static int write_to_journal(
510 const char *object_field,
512 const char *buffer) {
514 char header[LINE_MAX];
515 struct iovec iovec[4] = {};
516 struct msghdr mh = {};
521 log_do_header(header, sizeof(header), level, error, file, line, func, object_field, object);
523 IOVEC_SET_STRING(iovec[0], header);
524 IOVEC_SET_STRING(iovec[1], "MESSAGE=");
525 IOVEC_SET_STRING(iovec[2], buffer);
526 IOVEC_SET_STRING(iovec[3], "\n");
529 mh.msg_iovlen = ELEMENTSOF(iovec);
531 if (sendmsg(journal_fd, &mh, MSG_NOSIGNAL) < 0)
537 static int log_dispatch(
543 const char *object_field,
549 if (log_target == LOG_TARGET_NULL)
552 /* Patch in LOG_DAEMON facility if necessary */
553 if ((level & LOG_FACMASK) == 0)
554 level = log_facility | LOG_PRI(level);
563 buffer += strspn(buffer, NEWLINE);
568 if ((e = strpbrk(buffer, NEWLINE)))
571 if (log_target == LOG_TARGET_AUTO ||
572 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
573 log_target == LOG_TARGET_JOURNAL) {
575 k = write_to_journal(level, error, file, line, func, object_field, object, buffer);
583 if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
584 log_target == LOG_TARGET_SYSLOG) {
586 k = write_to_syslog(level, error, file, line, func, object_field, object, buffer);
595 (log_target == LOG_TARGET_AUTO ||
596 log_target == LOG_TARGET_SAFE ||
597 log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
598 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
599 log_target == LOG_TARGET_KMSG)) {
601 k = write_to_kmsg(level, error, file, line, func, object_field, object, buffer);
609 (void) write_to_console(level, error, file, line, func, object_field, object, buffer);
617 int log_dump_internal(
627 /* This modifies the buffer... */
632 if (_likely_(LOG_PRI(level) > log_max_level))
635 return log_dispatch(level, error, file, line, func, NULL, NULL, buffer);
648 char buffer[LINE_MAX];
653 if (_likely_(LOG_PRI(level) > log_max_level))
656 /* Make sure that %m maps to the specified error */
660 vsnprintf(buffer, sizeof(buffer), format, ap);
662 return log_dispatch(level, error, file, line, func, NULL, NULL, buffer);
671 const char *format, ...) {
676 va_start(ap, format);
677 r = log_internalv(level, error, file, line, func, format, ap);
683 int log_object_internalv(
689 const char *object_field,
695 char buffer[LINE_MAX];
700 if (_likely_(LOG_PRI(level) > log_max_level))
703 /* Make sure that %m maps to the specified error */
707 vsnprintf(buffer, sizeof(buffer), format, ap);
709 return log_dispatch(level, error, file, line, func, object_field, object, buffer);
712 int log_object_internal(
718 const char *object_field,
720 const char *format, ...) {
725 va_start(ap, format);
726 r = log_object_internalv(level, error, file, line, func, object_field, object, format, ap);
732 static void log_assert(
738 const char *format) {
740 static char buffer[LINE_MAX];
742 if (_likely_(LOG_PRI(level) > log_max_level))
745 DISABLE_WARNING_FORMAT_NONLITERAL;
746 snprintf(buffer, sizeof(buffer), format, text, file, line, func);
749 log_abort_msg = buffer;
751 log_dispatch(level, 0, file, line, func, NULL, NULL, buffer);
754 noreturn void log_assert_failed(const char *text, const char *file, int line, const char *func) {
755 log_assert(LOG_CRIT, text, file, line, func, "Assertion '%s' failed at %s:%u, function %s(). Aborting.");
759 noreturn void log_assert_failed_unreachable(const char *text, const char *file, int line, const char *func) {
760 log_assert(LOG_CRIT, text, file, line, func, "Code should not be reached '%s' at %s:%u, function %s(). Aborting.");
764 void log_assert_failed_return(const char *text, const char *file, int line, const char *func) {
766 log_assert(LOG_DEBUG, text, file, line, func, "Assertion '%s' failed at %s:%u, function %s(). Ignoring.");
769 int log_oom_internal(const char *file, int line, const char *func) {
770 log_internal(LOG_ERR, ENOMEM, file, line, func, "Out of memory.");
774 int log_struct_internal(
780 const char *format, ...) {
790 if (_likely_(LOG_PRI(level) > log_max_level))
793 if (log_target == LOG_TARGET_NULL)
796 if ((level & LOG_FACMASK) == 0)
797 level = log_facility | LOG_PRI(level);
799 if ((log_target == LOG_TARGET_AUTO ||
800 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
801 log_target == LOG_TARGET_JOURNAL) &&
803 char header[LINE_MAX];
804 struct iovec iovec[17] = {};
809 static const char nl = '\n';
810 bool fallback = false;
812 /* If the journal is available do structured logging */
813 log_do_header(header, sizeof(header), level, error, file, line, func, NULL, NULL);
814 IOVEC_SET_STRING(iovec[n++], header);
816 va_start(ap, format);
817 while (format && n + 1 < ELEMENTSOF(iovec)) {
821 /* We need to copy the va_list structure,
822 * since vasprintf() leaves it afterwards at
823 * an undefined location */
829 if (vasprintf(&m, format, aq) < 0) {
836 /* Now, jump enough ahead, so that we point to
837 * the next format string */
838 VA_FORMAT_ADVANCE(format, ap);
840 IOVEC_SET_STRING(iovec[n++], m);
842 iovec[n].iov_base = (char*) &nl;
843 iovec[n].iov_len = 1;
846 format = va_arg(ap, char *);
851 (void) sendmsg(journal_fd, &mh, MSG_NOSIGNAL);
855 for (i = 1; i < n; i += 2)
856 free(iovec[i].iov_base);
862 /* Fallback if journal logging is not available or didn't work. */
864 va_start(ap, format);
872 vsnprintf(buf, sizeof(buf), format, aq);
875 if (startswith(buf, "MESSAGE=")) {
880 VA_FORMAT_ADVANCE(format, ap);
882 format = va_arg(ap, char *);
889 return log_dispatch(level, error, file, line, func, NULL, NULL, buf + 8);
892 int log_set_target_from_string(const char *e) {
895 t = log_target_from_string(e);
903 int log_set_max_level_from_string(const char *e) {
906 t = log_level_from_string(e);
910 log_set_max_level(t);
914 static int parse_proc_cmdline_item(const char *key, const char *value) {
917 * The systemd.log_xyz= settings are parsed by all tools, and
920 * However, "quiet" is only parsed by PID 1, and only turns of
921 * status output to /dev/console, but does not alter the log
925 if (streq(key, "debug") && !value)
926 log_set_max_level(LOG_DEBUG);
928 else if (streq(key, "systemd.log_target") && value) {
930 if (log_set_target_from_string(value) < 0)
931 log_warning("Failed to parse log target '%s'. Ignoring.", value);
933 } else if (streq(key, "systemd.log_level") && value) {
935 if (log_set_max_level_from_string(value) < 0)
936 log_warning("Failed to parse log level '%s'. Ignoring.", value);
938 } else if (streq(key, "systemd.log_color") && value) {
940 if (log_show_color_from_string(value) < 0)
941 log_warning("Failed to parse log color setting '%s'. Ignoring.", value);
943 } else if (streq(key, "systemd.log_location") && value) {
945 if (log_show_location_from_string(value) < 0)
946 log_warning("Failed to parse log location setting '%s'. Ignoring.", value);
952 void log_parse_environment(void) {
955 if (get_ctty_devnr(0, NULL) < 0)
956 /* Only try to read the command line in daemons.
957 We assume that anything that has a controlling
958 tty is user stuff. */
959 (void) parse_proc_cmdline(parse_proc_cmdline_item);
961 e = secure_getenv("SYSTEMD_LOG_TARGET");
962 if (e && log_set_target_from_string(e) < 0)
963 log_warning("Failed to parse log target '%s'. Ignoring.", e);
965 e = secure_getenv("SYSTEMD_LOG_LEVEL");
966 if (e && log_set_max_level_from_string(e) < 0)
967 log_warning("Failed to parse log level '%s'. Ignoring.", e);
969 e = secure_getenv("SYSTEMD_LOG_COLOR");
970 if (e && log_show_color_from_string(e) < 0)
971 log_warning("Failed to parse bool '%s'. Ignoring.", e);
973 e = secure_getenv("SYSTEMD_LOG_LOCATION");
974 if (e && log_show_location_from_string(e) < 0)
975 log_warning("Failed to parse bool '%s'. Ignoring.", e);
978 LogTarget log_get_target(void) {
982 int log_get_max_level(void) {
983 return log_max_level;
986 void log_show_color(bool b) {
990 bool log_get_show_color(void) {
994 void log_show_location(bool b) {
998 bool log_get_show_location(void) {
999 return show_location;
1002 int log_show_color_from_string(const char *e) {
1005 t = parse_boolean(e);
1013 int log_show_location_from_string(const char *e) {
1016 t = parse_boolean(e);
1020 log_show_location(t);
1024 bool log_on_console(void) {
1025 if (log_target == LOG_TARGET_CONSOLE ||
1026 log_target == LOG_TARGET_CONSOLE_PREFIXED)
1029 return syslog_fd < 0 && kmsg_fd < 0 && journal_fd < 0;
1032 static const char *const log_target_table[_LOG_TARGET_MAX] = {
1033 [LOG_TARGET_CONSOLE] = "console",
1034 [LOG_TARGET_CONSOLE_PREFIXED] = "console-prefixed",
1035 [LOG_TARGET_KMSG] = "kmsg",
1036 [LOG_TARGET_JOURNAL] = "journal",
1037 [LOG_TARGET_JOURNAL_OR_KMSG] = "journal-or-kmsg",
1038 [LOG_TARGET_SYSLOG] = "syslog",
1039 [LOG_TARGET_SYSLOG_OR_KMSG] = "syslog-or-kmsg",
1040 [LOG_TARGET_AUTO] = "auto",
1041 [LOG_TARGET_SAFE] = "safe",
1042 [LOG_TARGET_NULL] = "null"
1045 DEFINE_STRING_TABLE_LOOKUP(log_target, LogTarget);
1047 void log_received_signal(int level, const struct signalfd_siginfo *si) {
1048 if (si->ssi_pid > 0) {
1049 _cleanup_free_ char *p = NULL;
1051 get_process_comm(si->ssi_pid, &p);
1054 "Received SIG%s from PID %"PRIu32" (%s).",
1055 signal_to_string(si->ssi_signo),
1056 si->ssi_pid, strna(p));
1060 signal_to_string(si->ssi_signo));
1064 void log_set_upgrade_syslog_to_journal(bool b) {
1065 upgrade_syslog_to_journal = b;