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"
38 #define SNDBUF_SIZE (8*1024*1024)
40 static LogTarget log_target = LOG_TARGET_CONSOLE;
41 static int log_max_level = LOG_INFO;
42 static int log_facility = LOG_DAEMON;
44 static int console_fd = STDERR_FILENO;
45 static int syslog_fd = -1;
46 static int kmsg_fd = -1;
47 static int journal_fd = -1;
49 static bool syslog_is_stream = false;
51 static bool show_color = false;
52 static bool show_location = false;
54 static bool upgrade_syslog_to_journal = false;
56 /* Akin to glibc's __abort_msg; which is private and we hence cannot
58 static char *log_abort_msg = NULL;
60 void log_close_console(void) {
67 safe_close(console_fd);
73 static int log_open_console(void) {
79 console_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
83 console_fd = STDERR_FILENO;
88 void log_close_kmsg(void) {
89 kmsg_fd = safe_close(kmsg_fd);
92 static int log_open_kmsg(void) {
97 kmsg_fd = open("/dev/kmsg", O_WRONLY|O_NOCTTY|O_CLOEXEC);
104 void log_close_syslog(void) {
105 syslog_fd = safe_close(syslog_fd);
108 static int create_log_socket(int type) {
112 fd = socket(AF_UNIX, type|SOCK_CLOEXEC, 0);
116 fd_inc_sndbuf(fd, SNDBUF_SIZE);
118 /* We need a blocking fd here since we'd otherwise lose
119 messages way too early. However, let's not hang forever in the
120 unlikely case of a deadlock. */
122 timeval_store(&tv, 10 * USEC_PER_MSEC);
124 timeval_store(&tv, 10 * USEC_PER_SEC);
125 setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
130 static int log_open_syslog(void) {
132 union sockaddr_union sa = {
133 .un.sun_family = AF_UNIX,
134 .un.sun_path = "/dev/log",
140 syslog_fd = create_log_socket(SOCK_DGRAM);
146 if (connect(syslog_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)) < 0) {
147 safe_close(syslog_fd);
149 /* Some legacy syslog systems still use stream
150 * sockets. They really shouldn't. But what can we
152 syslog_fd = create_log_socket(SOCK_STREAM);
158 if (connect(syslog_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)) < 0) {
163 syslog_is_stream = true;
165 syslog_is_stream = false;
174 void log_close_journal(void) {
175 journal_fd = safe_close(journal_fd);
178 static int log_open_journal(void) {
179 union sockaddr_union sa = {
180 .un.sun_family = AF_UNIX,
181 .un.sun_path = "/run/systemd/journal/socket",
188 journal_fd = create_log_socket(SOCK_DGRAM);
189 if (journal_fd < 0) {
194 if (connect(journal_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)) < 0) {
209 /* If we don't use the console we close it here, to not get
210 * killed by SAK. If we don't use syslog we close it here so
211 * that we are not confused by somebody deleting the socket in
212 * the fs. If we don't use /dev/kmsg we still keep it open,
213 * because there is no reason to close it. */
215 if (log_target == LOG_TARGET_NULL) {
222 if ((log_target != LOG_TARGET_AUTO && log_target != LOG_TARGET_SAFE) ||
224 isatty(STDERR_FILENO) <= 0) {
226 if (log_target == LOG_TARGET_AUTO ||
227 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
228 log_target == LOG_TARGET_JOURNAL) {
229 r = log_open_journal();
237 if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
238 log_target == LOG_TARGET_SYSLOG) {
239 r = log_open_syslog();
247 if (log_target == LOG_TARGET_AUTO ||
248 log_target == LOG_TARGET_SAFE ||
249 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
250 log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
251 log_target == LOG_TARGET_KMSG) {
265 return log_open_console();
268 void log_set_target(LogTarget target) {
270 assert(target < _LOG_TARGET_MAX);
272 if (upgrade_syslog_to_journal) {
273 if (target == LOG_TARGET_SYSLOG)
274 target = LOG_TARGET_JOURNAL;
275 else if (target == LOG_TARGET_SYSLOG_OR_KMSG)
276 target = LOG_TARGET_JOURNAL_OR_KMSG;
282 void log_close(void) {
289 void log_forget_fds(void) {
290 console_fd = kmsg_fd = syslog_fd = journal_fd = -1;
293 void log_set_max_level(int level) {
294 assert((level & LOG_PRIMASK) == level);
296 log_max_level = level;
299 void log_set_facility(int facility) {
300 log_facility = facility;
303 static int write_to_console(
308 const char *object_name,
310 const char *buffer) {
313 struct iovec iovec[5] = {};
320 highlight = LOG_PRI(level) <= LOG_ERR && show_color;
323 snprintf(location, sizeof(location), "(%s:%u) ", file, line);
324 char_array_0(location);
325 IOVEC_SET_STRING(iovec[n++], location);
329 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_RED_ON);
330 IOVEC_SET_STRING(iovec[n++], buffer);
332 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_OFF);
333 IOVEC_SET_STRING(iovec[n++], "\n");
335 if (writev(console_fd, iovec, n) < 0) {
337 if (errno == EIO && getpid() == 1) {
339 /* If somebody tried to kick us from our
340 * console tty (via vhangup() or suchlike),
341 * try to reconnect */
349 if (writev(console_fd, iovec, n) < 0)
358 static int write_to_syslog(
363 const char *object_name,
365 const char *buffer) {
367 char header_priority[16], header_time[64], header_pid[16];
368 struct iovec iovec[5] = {};
369 struct msghdr msghdr = {
371 .msg_iovlen = ELEMENTSOF(iovec),
379 snprintf(header_priority, sizeof(header_priority), "<%i>", level);
380 char_array_0(header_priority);
382 t = (time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC);
387 if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
390 snprintf(header_pid, sizeof(header_pid), "["PID_FMT"]: ", getpid());
391 char_array_0(header_pid);
393 IOVEC_SET_STRING(iovec[0], header_priority);
394 IOVEC_SET_STRING(iovec[1], header_time);
395 IOVEC_SET_STRING(iovec[2], program_invocation_short_name);
396 IOVEC_SET_STRING(iovec[3], header_pid);
397 IOVEC_SET_STRING(iovec[4], buffer);
399 /* When using syslog via SOCK_STREAM separate the messages by NUL chars */
400 if (syslog_is_stream)
406 n = sendmsg(syslog_fd, &msghdr, MSG_NOSIGNAL);
410 if (!syslog_is_stream ||
411 (size_t) n >= IOVEC_TOTAL_SIZE(iovec, ELEMENTSOF(iovec)))
414 IOVEC_INCREMENT(iovec, ELEMENTSOF(iovec), n);
420 static int write_to_kmsg(
425 const char *object_name,
427 const char *buffer) {
429 char header_priority[16], header_pid[16];
430 struct iovec iovec[5] = {};
435 snprintf(header_priority, sizeof(header_priority), "<%i>", level);
436 char_array_0(header_priority);
438 snprintf(header_pid, sizeof(header_pid), "["PID_FMT"]: ", getpid());
439 char_array_0(header_pid);
441 IOVEC_SET_STRING(iovec[0], header_priority);
442 IOVEC_SET_STRING(iovec[1], program_invocation_short_name);
443 IOVEC_SET_STRING(iovec[2], header_pid);
444 IOVEC_SET_STRING(iovec[3], buffer);
445 IOVEC_SET_STRING(iovec[4], "\n");
447 if (writev(kmsg_fd, iovec, ELEMENTSOF(iovec)) < 0)
453 static int log_do_header(char *header, size_t size,
455 const char *file, int line, const char *func,
456 const char *object_name, const char *object) {
457 snprintf(header, size,
459 "SYSLOG_FACILITY=%i\n"
464 "SYSLOG_IDENTIFIER=%s\n",
467 file ? "CODE_FILE=" : "",
468 file ? LINE_MAX : 0, file, /* %.0s means no output */
470 line ? "CODE_LINE=" : "",
471 line ? 1 : 0, line, /* %.0d means no output too, special case for 0 */
473 func ? "CODE_FUNCTION=" : "",
474 func ? LINE_MAX : 0, func,
476 object ? object_name : "",
477 object ? LINE_MAX : 0, object, /* %.0s means no output */
479 program_invocation_short_name);
480 header[size - 1] = '\0';
484 static int write_to_journal(
489 const char *object_name,
491 const char *buffer) {
493 char header[LINE_MAX];
494 struct iovec iovec[4] = {};
495 struct msghdr mh = {};
500 log_do_header(header, sizeof(header), level,
501 file, line, func, object_name, object);
503 IOVEC_SET_STRING(iovec[0], header);
504 IOVEC_SET_STRING(iovec[1], "MESSAGE=");
505 IOVEC_SET_STRING(iovec[2], buffer);
506 IOVEC_SET_STRING(iovec[3], "\n");
509 mh.msg_iovlen = ELEMENTSOF(iovec);
511 if (sendmsg(journal_fd, &mh, MSG_NOSIGNAL) < 0)
517 static int log_dispatch(
522 const char *object_name,
528 if (log_target == LOG_TARGET_NULL)
531 /* Patch in LOG_DAEMON facility if necessary */
532 if ((level & LOG_FACMASK) == 0)
533 level = log_facility | LOG_PRI(level);
539 buffer += strspn(buffer, NEWLINE);
544 if ((e = strpbrk(buffer, NEWLINE)))
547 if (log_target == LOG_TARGET_AUTO ||
548 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
549 log_target == LOG_TARGET_JOURNAL) {
551 k = write_to_journal(level, file, line, func,
552 object_name, object, buffer);
561 if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
562 log_target == LOG_TARGET_SYSLOG) {
564 k = write_to_syslog(level, file, line, func,
565 object_name, object, buffer);
575 (log_target == LOG_TARGET_AUTO ||
576 log_target == LOG_TARGET_SAFE ||
577 log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
578 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
579 log_target == LOG_TARGET_KMSG)) {
581 k = write_to_kmsg(level, file, line, func,
582 object_name, object, buffer);
591 k = write_to_console(level, file, line, func,
592 object_name, object, buffer);
603 int log_dump_internal(
612 /* This modifies the buffer... */
614 if (_likely_(LOG_PRI(level) > log_max_level))
617 return log_dispatch(level, file, line, func, NULL, NULL, buffer);
629 char buffer[LINE_MAX];
631 if (_likely_(LOG_PRI(level) > log_max_level))
634 vsnprintf(buffer, sizeof(buffer), format, ap);
635 char_array_0(buffer);
637 return log_dispatch(level, file, line, func, NULL, NULL, buffer);
645 const char *format, ...) {
650 va_start(ap, format);
651 r = log_metav(level, file, line, func, format, ap);
657 int log_metav_object(
662 const char *object_name,
668 char buffer[LINE_MAX];
670 if (_likely_(LOG_PRI(level) > log_max_level))
673 vsnprintf(buffer, sizeof(buffer), format, ap);
674 char_array_0(buffer);
676 return log_dispatch(level, file, line, func,
677 object_name, object, buffer);
685 const char *object_name,
687 const char *format, ...) {
692 va_start(ap, format);
693 r = log_metav_object(level, file, line, func,
694 object_name, object, format, ap);
700 static void log_assert(int level, const char *text, const char *file, int line, const char *func, const char *format) {
701 static char buffer[LINE_MAX];
703 if (_likely_(LOG_PRI(level) > log_max_level))
706 DISABLE_WARNING_FORMAT_NONLITERAL;
707 snprintf(buffer, sizeof(buffer), format, text, file, line, func);
710 char_array_0(buffer);
711 log_abort_msg = buffer;
713 log_dispatch(level, file, line, func, NULL, NULL, buffer);
716 noreturn void log_assert_failed(const char *text, const char *file, int line, const char *func) {
717 log_assert(LOG_CRIT, text, file, line, func, "Assertion '%s' failed at %s:%u, function %s(). Aborting.");
721 noreturn void log_assert_failed_unreachable(const char *text, const char *file, int line, const char *func) {
722 log_assert(LOG_CRIT, text, file, line, func, "Code should not be reached '%s' at %s:%u, function %s(). Aborting.");
726 void log_assert_failed_return(const char *text, const char *file, int line, const char *func) {
728 log_assert(LOG_DEBUG, text, file, line, func, "Assertion '%s' failed at %s:%u, function %s(). Ignoring.");
731 int log_oom_internal(const char *file, int line, const char *func) {
732 log_meta(LOG_ERR, file, line, func, "Out of memory.");
736 int log_struct_internal(
741 const char *format, ...) {
747 if (_likely_(LOG_PRI(level) > log_max_level))
750 if (log_target == LOG_TARGET_NULL)
753 if ((level & LOG_FACMASK) == 0)
754 level = log_facility | LOG_PRI(level);
756 if ((log_target == LOG_TARGET_AUTO ||
757 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
758 log_target == LOG_TARGET_JOURNAL) &&
761 char header[LINE_MAX];
762 struct iovec iovec[17] = {};
767 static const char nl = '\n';
769 /* If the journal is available do structured logging */
770 log_do_header(header, sizeof(header), level,
771 file, line, func, NULL, NULL);
772 IOVEC_SET_STRING(iovec[n++], header);
774 va_start(ap, format);
775 while (format && n + 1 < ELEMENTSOF(iovec)) {
779 /* We need to copy the va_list structure,
780 * since vasprintf() leaves it afterwards at
781 * an undefined location */
784 if (vasprintf(&buf, format, aq) < 0) {
791 /* Now, jump enough ahead, so that we point to
792 * the next format string */
793 VA_FORMAT_ADVANCE(format, ap);
795 IOVEC_SET_STRING(iovec[n++], buf);
797 iovec[n].iov_base = (char*) &nl;
798 iovec[n].iov_len = 1;
801 format = va_arg(ap, char *);
806 if (sendmsg(journal_fd, &mh, MSG_NOSIGNAL) < 0)
813 for (i = 1; i < n; i += 2)
814 free(iovec[i].iov_base);
820 /* Fallback if journal logging is not available */
822 va_start(ap, format);
827 vsnprintf(buf, sizeof(buf), format, aq);
831 if (startswith(buf, "MESSAGE=")) {
836 VA_FORMAT_ADVANCE(format, ap);
838 format = va_arg(ap, char *);
843 r = log_dispatch(level, file, line, func,
844 NULL, NULL, buf + 8);
852 int log_set_target_from_string(const char *e) {
855 t = log_target_from_string(e);
863 int log_set_max_level_from_string(const char *e) {
866 t = log_level_from_string(e);
870 log_set_max_level(t);
874 static int parse_proc_cmdline_item(const char *key, const char *value) {
877 * The systemd.log_xyz= settings are parsed by all tools, and
880 * However, "quiet" is only parsed by PID 1!
883 if (streq(key, "debug") && !value)
884 log_set_max_level(LOG_DEBUG);
886 else if (streq(key, "systemd.log_target") && value) {
888 if (log_set_target_from_string(value) < 0)
889 log_warning("Failed to parse log target '%s'. Ignoring.", value);
891 } else if (streq(key, "systemd.log_level") && value) {
893 if (log_set_max_level_from_string(value) < 0)
894 log_warning("Failed to parse log level '%s'. Ignoring.", value);
896 } else if (streq(key, "systemd.log_color") && value) {
898 if (log_show_color_from_string(value) < 0)
899 log_warning("Failed to parse log color setting '%s'. Ignoring.", value);
901 } else if (streq(key, "systemd.log_location") && value) {
903 if (log_show_location_from_string(value) < 0)
904 log_warning("Failed to parse log location setting '%s'. Ignoring.", value);
910 void log_parse_environment(void) {
913 parse_proc_cmdline(parse_proc_cmdline_item);
915 e = secure_getenv("SYSTEMD_LOG_TARGET");
916 if (e && log_set_target_from_string(e) < 0)
917 log_warning("Failed to parse log target '%s'. Ignoring.", e);
919 e = secure_getenv("SYSTEMD_LOG_LEVEL");
920 if (e && log_set_max_level_from_string(e) < 0)
921 log_warning("Failed to parse log level '%s'. Ignoring.", e);
923 e = secure_getenv("SYSTEMD_LOG_COLOR");
924 if (e && log_show_color_from_string(e) < 0)
925 log_warning("Failed to parse bool '%s'. Ignoring.", e);
927 e = secure_getenv("SYSTEMD_LOG_LOCATION");
928 if (e && log_show_location_from_string(e) < 0)
929 log_warning("Failed to parse bool '%s'. Ignoring.", e);
932 LogTarget log_get_target(void) {
936 int log_get_max_level(void) {
937 return log_max_level;
940 void log_show_color(bool b) {
944 bool log_get_show_color(void) {
948 void log_show_location(bool b) {
952 bool log_get_show_location(void) {
953 return show_location;
956 int log_show_color_from_string(const char *e) {
959 t = parse_boolean(e);
967 int log_show_location_from_string(const char *e) {
970 t = parse_boolean(e);
974 log_show_location(t);
978 bool log_on_console(void) {
979 if (log_target == LOG_TARGET_CONSOLE)
982 return syslog_fd < 0 && kmsg_fd < 0 && journal_fd < 0;
985 static const char *const log_target_table[_LOG_TARGET_MAX] = {
986 [LOG_TARGET_CONSOLE] = "console",
987 [LOG_TARGET_KMSG] = "kmsg",
988 [LOG_TARGET_JOURNAL] = "journal",
989 [LOG_TARGET_JOURNAL_OR_KMSG] = "journal-or-kmsg",
990 [LOG_TARGET_SYSLOG] = "syslog",
991 [LOG_TARGET_SYSLOG_OR_KMSG] = "syslog-or-kmsg",
992 [LOG_TARGET_AUTO] = "auto",
993 [LOG_TARGET_SAFE] = "safe",
994 [LOG_TARGET_NULL] = "null"
997 DEFINE_STRING_TABLE_LOOKUP(log_target, LogTarget);
999 void log_received_signal(int level, const struct signalfd_siginfo *si) {
1000 if (si->ssi_pid > 0) {
1001 _cleanup_free_ char *p = NULL;
1003 get_process_comm(si->ssi_pid, &p);
1006 "Received SIG%s from PID "PID_FMT" (%s).",
1007 signal_to_string(si->ssi_signo),
1008 si->ssi_pid, strna(p));
1012 signal_to_string(si->ssi_signo));
1016 void log_set_upgrade_syslog_to_journal(bool b) {
1017 upgrade_syslog_to_journal = b;