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 /* Akin to glibc's __abort_msg; which is private and we hence cannot
56 static char *log_abort_msg = NULL;
58 void log_close_console(void) {
65 close_nointr_nofail(console_fd);
71 static int log_open_console(void) {
77 console_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
81 console_fd = STDERR_FILENO;
86 void log_close_kmsg(void) {
91 close_nointr_nofail(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) {
112 close_nointr_nofail(syslog_fd);
116 static int create_log_socket(int type) {
120 fd = socket(AF_UNIX, type|SOCK_CLOEXEC, 0);
124 fd_inc_sndbuf(fd, SNDBUF_SIZE);
126 /* We need a blocking fd here since we'd otherwise lose
127 messages way too early. However, let's not hang forever in the
128 unlikely case of a deadlock. */
129 timeval_store(&tv, 1*USEC_PER_MINUTE);
130 setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
135 static int log_open_syslog(void) {
137 union sockaddr_union sa = {
138 .un.sun_family = AF_UNIX,
139 .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 close_nointr_nofail(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) {
184 close_nointr_nofail(journal_fd);
188 static int log_open_journal(void) {
189 union sockaddr_union sa = {
190 .un.sun_family = AF_UNIX,
191 .un.sun_path = "/run/systemd/journal/socket",
198 journal_fd = create_log_socket(SOCK_DGRAM);
199 if (journal_fd < 0) {
204 if (connect(journal_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)) < 0) {
219 /* If we don't use the console we close it here, to not get
220 * killed by SAK. If we don't use syslog we close it here so
221 * that we are not confused by somebody deleting the socket in
222 * the fs. If we don't use /dev/kmsg we still keep it open,
223 * because there is no reason to close it. */
225 if (log_target == LOG_TARGET_NULL) {
232 if ((log_target != LOG_TARGET_AUTO && log_target != LOG_TARGET_SAFE) ||
234 isatty(STDERR_FILENO) <= 0) {
236 if (log_target == LOG_TARGET_AUTO ||
237 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
238 log_target == LOG_TARGET_JOURNAL) {
239 r = log_open_journal();
247 if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
248 log_target == LOG_TARGET_SYSLOG) {
249 r = log_open_syslog();
257 if (log_target == LOG_TARGET_AUTO ||
258 log_target == LOG_TARGET_SAFE ||
259 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
260 log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
261 log_target == LOG_TARGET_KMSG) {
275 return log_open_console();
278 void log_set_target(LogTarget target) {
280 assert(target < _LOG_TARGET_MAX);
285 void log_close(void) {
292 void log_forget_fds(void) {
293 console_fd = kmsg_fd = syslog_fd = journal_fd = -1;
296 void log_set_max_level(int level) {
297 assert((level & LOG_PRIMASK) == level);
299 log_max_level = level;
302 void log_set_facility(int facility) {
303 log_facility = facility;
306 static int write_to_console(
311 const char *object_name,
313 const char *buffer) {
316 struct iovec iovec[5] = {};
323 highlight = LOG_PRI(level) <= LOG_ERR && show_color;
326 snprintf(location, sizeof(location), "(%s:%u) ", file, line);
327 char_array_0(location);
328 IOVEC_SET_STRING(iovec[n++], location);
332 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_RED_ON);
333 IOVEC_SET_STRING(iovec[n++], buffer);
335 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_OFF);
336 IOVEC_SET_STRING(iovec[n++], "\n");
338 if (writev(console_fd, iovec, n) < 0)
344 static int write_to_syslog(
349 const char *object_name,
351 const char *buffer) {
353 char header_priority[16], header_time[64], header_pid[16];
354 struct iovec iovec[5] = {};
355 struct msghdr msghdr = {
357 .msg_iovlen = ELEMENTSOF(iovec),
365 snprintf(header_priority, sizeof(header_priority), "<%i>", level);
366 char_array_0(header_priority);
368 t = (time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC);
373 if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
376 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) getpid());
377 char_array_0(header_pid);
379 IOVEC_SET_STRING(iovec[0], header_priority);
380 IOVEC_SET_STRING(iovec[1], header_time);
381 IOVEC_SET_STRING(iovec[2], program_invocation_short_name);
382 IOVEC_SET_STRING(iovec[3], header_pid);
383 IOVEC_SET_STRING(iovec[4], buffer);
385 /* When using syslog via SOCK_STREAM separate the messages by NUL chars */
386 if (syslog_is_stream)
392 n = sendmsg(syslog_fd, &msghdr, MSG_NOSIGNAL);
396 if (!syslog_is_stream ||
397 (size_t) n >= IOVEC_TOTAL_SIZE(iovec, ELEMENTSOF(iovec)))
400 IOVEC_INCREMENT(iovec, ELEMENTSOF(iovec), n);
406 static int write_to_kmsg(
411 const char *object_name,
413 const char *buffer) {
415 char header_priority[16], header_pid[16];
416 struct iovec iovec[5] = {};
421 snprintf(header_priority, sizeof(header_priority), "<%i>", level);
422 char_array_0(header_priority);
424 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) getpid());
425 char_array_0(header_pid);
427 IOVEC_SET_STRING(iovec[0], header_priority);
428 IOVEC_SET_STRING(iovec[1], program_invocation_short_name);
429 IOVEC_SET_STRING(iovec[2], header_pid);
430 IOVEC_SET_STRING(iovec[3], buffer);
431 IOVEC_SET_STRING(iovec[4], "\n");
433 if (writev(kmsg_fd, iovec, ELEMENTSOF(iovec)) < 0)
439 static int log_do_header(char *header, size_t size,
441 const char *file, int line, const char *func,
442 const char *object_name, const char *object) {
443 snprintf(header, size,
445 "SYSLOG_FACILITY=%i\n"
450 "SYSLOG_IDENTIFIER=%s\n",
453 file ? "CODE_FILE=" : "",
454 file ? LINE_MAX : 0, file, /* %.0s means no output */
456 line ? "CODE_LINE=" : "",
457 line ? 1 : 0, line, /* %.0d means no output too, special case for 0 */
459 func ? "CODE_FUNCTION=" : "",
460 func ? LINE_MAX : 0, func,
462 object ? object_name : "",
463 object ? LINE_MAX : 0, object, /* %.0s means no output */
465 program_invocation_short_name);
466 header[size - 1] = '\0';
470 static int write_to_journal(
475 const char *object_name,
477 const char *buffer) {
479 char header[LINE_MAX];
480 struct iovec iovec[4] = {};
481 struct msghdr mh = {};
486 log_do_header(header, sizeof(header), level,
487 file, line, func, object_name, object);
489 IOVEC_SET_STRING(iovec[0], header);
490 IOVEC_SET_STRING(iovec[1], "MESSAGE=");
491 IOVEC_SET_STRING(iovec[2], buffer);
492 IOVEC_SET_STRING(iovec[3], "\n");
495 mh.msg_iovlen = ELEMENTSOF(iovec);
497 if (sendmsg(journal_fd, &mh, MSG_NOSIGNAL) < 0)
503 static int log_dispatch(
508 const char *object_name,
514 if (log_target == LOG_TARGET_NULL)
517 /* Patch in LOG_DAEMON facility if necessary */
518 if ((level & LOG_FACMASK) == 0)
519 level = log_facility | LOG_PRI(level);
525 buffer += strspn(buffer, NEWLINE);
530 if ((e = strpbrk(buffer, NEWLINE)))
533 if (log_target == LOG_TARGET_AUTO ||
534 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
535 log_target == LOG_TARGET_JOURNAL) {
537 k = write_to_journal(level, file, line, func,
538 object_name, object, buffer);
547 if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
548 log_target == LOG_TARGET_SYSLOG) {
550 k = write_to_syslog(level, file, line, func,
551 object_name, object, buffer);
561 (log_target == LOG_TARGET_AUTO ||
562 log_target == LOG_TARGET_SAFE ||
563 log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
564 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
565 log_target == LOG_TARGET_KMSG)) {
567 k = write_to_kmsg(level, file, line, func,
568 object_name, object, buffer);
577 k = write_to_console(level, file, line, func,
578 object_name, object, buffer);
589 int log_dump_internal(
598 /* This modifies the buffer... */
600 if (_likely_(LOG_PRI(level) > log_max_level))
603 return log_dispatch(level, file, line, func, NULL, NULL, buffer);
615 char buffer[LINE_MAX];
617 if (_likely_(LOG_PRI(level) > log_max_level))
620 vsnprintf(buffer, sizeof(buffer), format, ap);
621 char_array_0(buffer);
623 return log_dispatch(level, file, line, func, NULL, NULL, buffer);
631 const char *format, ...) {
636 va_start(ap, format);
637 r = log_metav(level, file, line, func, format, ap);
643 int log_metav_object(
648 const char *object_name,
654 char buffer[LINE_MAX];
656 if (_likely_(LOG_PRI(level) > log_max_level))
659 vsnprintf(buffer, sizeof(buffer), format, ap);
660 char_array_0(buffer);
662 return log_dispatch(level, file, line, func,
663 object_name, object, buffer);
671 const char *object_name,
673 const char *format, ...) {
678 va_start(ap, format);
679 r = log_metav_object(level, file, line, func,
680 object_name, object, format, ap);
686 #pragma GCC diagnostic push
687 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
688 static void log_assert(int level, const char *text, const char *file, int line, const char *func, const char *format) {
689 static char buffer[LINE_MAX];
691 if (_likely_(LOG_PRI(level) > log_max_level))
694 snprintf(buffer, sizeof(buffer), format, text, file, line, func);
696 char_array_0(buffer);
697 log_abort_msg = buffer;
699 log_dispatch(level, file, line, func, NULL, NULL, buffer);
701 #pragma GCC diagnostic pop
703 noreturn void log_assert_failed(const char *text, const char *file, int line, const char *func) {
704 log_assert(LOG_CRIT, text, file, line, func, "Assertion '%s' failed at %s:%u, function %s(). Aborting.");
708 noreturn void log_assert_failed_unreachable(const char *text, const char *file, int line, const char *func) {
709 log_assert(LOG_CRIT, text, file, line, func, "Code should not be reached '%s' at %s:%u, function %s(). Aborting.");
713 void log_assert_failed_return(const char *text, const char *file, int line, const char *func) {
715 log_assert(LOG_DEBUG, text, file, line, func, "Assertion '%s' failed at %s:%u, function %s(). Ignoring.");
718 int log_oom_internal(const char *file, int line, const char *func) {
719 log_meta(LOG_ERR, file, line, func, "Out of memory.");
723 int log_struct_internal(
728 const char *format, ...) {
734 if (_likely_(LOG_PRI(level) > log_max_level))
737 if (log_target == LOG_TARGET_NULL)
740 if ((level & LOG_FACMASK) == 0)
741 level = log_facility | LOG_PRI(level);
743 if ((log_target == LOG_TARGET_AUTO ||
744 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
745 log_target == LOG_TARGET_JOURNAL) &&
748 char header[LINE_MAX];
749 struct iovec iovec[17] = {};
754 static const char nl = '\n';
756 /* If the journal is available do structured logging */
757 log_do_header(header, sizeof(header), level,
758 file, line, func, NULL, NULL);
759 IOVEC_SET_STRING(iovec[n++], header);
761 va_start(ap, format);
762 while (format && n + 1 < ELEMENTSOF(iovec)) {
766 /* We need to copy the va_list structure,
767 * since vasprintf() leaves it afterwards at
768 * an undefined location */
771 if (vasprintf(&buf, format, aq) < 0) {
778 /* Now, jump enough ahead, so that we point to
779 * the next format string */
780 VA_FORMAT_ADVANCE(format, ap);
782 IOVEC_SET_STRING(iovec[n++], buf);
784 iovec[n].iov_base = (char*) &nl;
785 iovec[n].iov_len = 1;
788 format = va_arg(ap, char *);
793 if (sendmsg(journal_fd, &mh, MSG_NOSIGNAL) < 0)
800 for (i = 1; i < n; i += 2)
801 free(iovec[i].iov_base);
807 /* Fallback if journal logging is not available */
809 va_start(ap, format);
814 vsnprintf(buf, sizeof(buf), format, aq);
818 if (startswith(buf, "MESSAGE=")) {
823 VA_FORMAT_ADVANCE(format, ap);
825 format = va_arg(ap, char *);
830 r = log_dispatch(level, file, line, func,
831 NULL, NULL, buf + 8);
839 int log_set_target_from_string(const char *e) {
842 t = log_target_from_string(e);
850 int log_set_max_level_from_string(const char *e) {
853 t = log_level_from_string(e);
857 log_set_max_level(t);
861 void log_parse_environment(void) {
864 e = secure_getenv("SYSTEMD_LOG_TARGET");
865 if (e && log_set_target_from_string(e) < 0)
866 log_warning("Failed to parse log target %s. Ignoring.", e);
868 e = secure_getenv("SYSTEMD_LOG_LEVEL");
869 if (e && log_set_max_level_from_string(e) < 0)
870 log_warning("Failed to parse log level %s. Ignoring.", e);
872 e = secure_getenv("SYSTEMD_LOG_COLOR");
873 if (e && log_show_color_from_string(e) < 0)
874 log_warning("Failed to parse bool %s. Ignoring.", e);
876 e = secure_getenv("SYSTEMD_LOG_LOCATION");
877 if (e && log_show_location_from_string(e) < 0)
878 log_warning("Failed to parse bool %s. Ignoring.", e);
881 LogTarget log_get_target(void) {
885 int log_get_max_level(void) {
886 return log_max_level;
889 void log_show_color(bool b) {
893 void log_show_location(bool b) {
897 int log_show_color_from_string(const char *e) {
900 t = parse_boolean(e);
908 int log_show_location_from_string(const char *e) {
911 t = parse_boolean(e);
915 log_show_location(t);
919 bool log_on_console(void) {
920 if (log_target == LOG_TARGET_CONSOLE)
923 return syslog_fd < 0 && kmsg_fd < 0 && journal_fd < 0;
926 static const char *const log_target_table[] = {
927 [LOG_TARGET_CONSOLE] = "console",
928 [LOG_TARGET_KMSG] = "kmsg",
929 [LOG_TARGET_JOURNAL] = "journal",
930 [LOG_TARGET_JOURNAL_OR_KMSG] = "journal-or-kmsg",
931 [LOG_TARGET_SYSLOG] = "syslog",
932 [LOG_TARGET_SYSLOG_OR_KMSG] = "syslog-or-kmsg",
933 [LOG_TARGET_AUTO] = "auto",
934 [LOG_TARGET_SAFE] = "safe",
935 [LOG_TARGET_NULL] = "null"
938 DEFINE_STRING_TABLE_LOOKUP(log_target, LogTarget);