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 /* Get the real /dev/console if we are PID=1, hence reopen */
277 return log_open_console();
280 void log_set_target(LogTarget target) {
282 assert(target < _LOG_TARGET_MAX);
287 void log_close(void) {
294 void log_forget_fds(void) {
295 console_fd = kmsg_fd = syslog_fd = journal_fd = -1;
298 void log_set_max_level(int level) {
299 assert((level & LOG_PRIMASK) == level);
301 log_max_level = level;
304 void log_set_facility(int facility) {
305 log_facility = facility;
308 static int write_to_console(
313 const char *object_name,
315 const char *buffer) {
318 struct iovec iovec[5] = {};
325 highlight = LOG_PRI(level) <= LOG_ERR && show_color;
328 snprintf(location, sizeof(location), "(%s:%u) ", file, line);
329 char_array_0(location);
330 IOVEC_SET_STRING(iovec[n++], location);
334 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_RED_ON);
335 IOVEC_SET_STRING(iovec[n++], buffer);
337 IOVEC_SET_STRING(iovec[n++], ANSI_HIGHLIGHT_OFF);
338 IOVEC_SET_STRING(iovec[n++], "\n");
340 if (writev(console_fd, iovec, n) < 0)
346 static int write_to_syslog(
351 const char *object_name,
353 const char *buffer) {
355 char header_priority[16], header_time[64], header_pid[16];
356 struct iovec iovec[5] = {};
357 struct msghdr msghdr = {
359 .msg_iovlen = ELEMENTSOF(iovec),
367 snprintf(header_priority, sizeof(header_priority), "<%i>", level);
368 char_array_0(header_priority);
370 t = (time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC);
375 if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
378 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) getpid());
379 char_array_0(header_pid);
381 IOVEC_SET_STRING(iovec[0], header_priority);
382 IOVEC_SET_STRING(iovec[1], header_time);
383 IOVEC_SET_STRING(iovec[2], program_invocation_short_name);
384 IOVEC_SET_STRING(iovec[3], header_pid);
385 IOVEC_SET_STRING(iovec[4], buffer);
387 /* When using syslog via SOCK_STREAM separate the messages by NUL chars */
388 if (syslog_is_stream)
394 n = sendmsg(syslog_fd, &msghdr, MSG_NOSIGNAL);
398 if (!syslog_is_stream ||
399 (size_t) n >= IOVEC_TOTAL_SIZE(iovec, ELEMENTSOF(iovec)))
402 IOVEC_INCREMENT(iovec, ELEMENTSOF(iovec), n);
408 static int write_to_kmsg(
413 const char *object_name,
415 const char *buffer) {
417 char header_priority[16], header_pid[16];
418 struct iovec iovec[5] = {};
423 snprintf(header_priority, sizeof(header_priority), "<%i>", level);
424 char_array_0(header_priority);
426 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) getpid());
427 char_array_0(header_pid);
429 IOVEC_SET_STRING(iovec[0], header_priority);
430 IOVEC_SET_STRING(iovec[1], program_invocation_short_name);
431 IOVEC_SET_STRING(iovec[2], header_pid);
432 IOVEC_SET_STRING(iovec[3], buffer);
433 IOVEC_SET_STRING(iovec[4], "\n");
435 if (writev(kmsg_fd, iovec, ELEMENTSOF(iovec)) < 0)
441 static int log_do_header(char *header, size_t size,
443 const char *file, int line, const char *func,
444 const char *object_name, const char *object) {
445 snprintf(header, size,
447 "SYSLOG_FACILITY=%i\n"
452 "SYSLOG_IDENTIFIER=%s\n",
455 file ? "CODE_FILE=" : "",
456 file ? LINE_MAX : 0, file, /* %.0s means no output */
458 line ? "CODE_LINE=" : "",
459 line ? 1 : 0, line, /* %.0d means no output too, special case for 0 */
461 func ? "CODE_FUNCTION=" : "",
462 func ? LINE_MAX : 0, func,
464 object ? object_name : "",
465 object ? LINE_MAX : 0, object, /* %.0s means no output */
467 program_invocation_short_name);
468 header[size - 1] = '\0';
472 static int write_to_journal(
477 const char *object_name,
479 const char *buffer) {
481 char header[LINE_MAX];
482 struct iovec iovec[4] = {};
483 struct msghdr mh = {};
488 log_do_header(header, sizeof(header), level,
489 file, line, func, object_name, object);
491 IOVEC_SET_STRING(iovec[0], header);
492 IOVEC_SET_STRING(iovec[1], "MESSAGE=");
493 IOVEC_SET_STRING(iovec[2], buffer);
494 IOVEC_SET_STRING(iovec[3], "\n");
497 mh.msg_iovlen = ELEMENTSOF(iovec);
499 if (sendmsg(journal_fd, &mh, MSG_NOSIGNAL) < 0)
505 static int log_dispatch(
510 const char *object_name,
516 if (log_target == LOG_TARGET_NULL)
519 /* Patch in LOG_DAEMON facility if necessary */
520 if ((level & LOG_FACMASK) == 0)
521 level = log_facility | LOG_PRI(level);
527 buffer += strspn(buffer, NEWLINE);
532 if ((e = strpbrk(buffer, NEWLINE)))
535 if (log_target == LOG_TARGET_AUTO ||
536 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
537 log_target == LOG_TARGET_JOURNAL) {
539 k = write_to_journal(level, file, line, func,
540 object_name, object, buffer);
549 if (log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
550 log_target == LOG_TARGET_SYSLOG) {
552 k = write_to_syslog(level, file, line, func,
553 object_name, object, buffer);
563 (log_target == LOG_TARGET_AUTO ||
564 log_target == LOG_TARGET_SAFE ||
565 log_target == LOG_TARGET_SYSLOG_OR_KMSG ||
566 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
567 log_target == LOG_TARGET_KMSG)) {
569 k = write_to_kmsg(level, file, line, func,
570 object_name, object, buffer);
579 k = write_to_console(level, file, line, func,
580 object_name, object, buffer);
591 int log_dump_internal(
600 /* This modifies the buffer... */
602 if (_likely_(LOG_PRI(level) > log_max_level))
605 return log_dispatch(level, file, line, func, NULL, NULL, buffer);
617 char buffer[LINE_MAX];
619 if (_likely_(LOG_PRI(level) > log_max_level))
622 vsnprintf(buffer, sizeof(buffer), format, ap);
623 char_array_0(buffer);
625 return log_dispatch(level, file, line, func, NULL, NULL, buffer);
633 const char *format, ...) {
638 va_start(ap, format);
639 r = log_metav(level, file, line, func, format, ap);
645 int log_metav_object(
650 const char *object_name,
656 char buffer[LINE_MAX];
658 if (_likely_(LOG_PRI(level) > log_max_level))
661 vsnprintf(buffer, sizeof(buffer), format, ap);
662 char_array_0(buffer);
664 return log_dispatch(level, file, line, func,
665 object_name, object, buffer);
673 const char *object_name,
675 const char *format, ...) {
680 va_start(ap, format);
681 r = log_metav_object(level, file, line, func,
682 object_name, object, format, ap);
688 #pragma GCC diagnostic push
689 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
690 _noreturn_ static void log_assert(const char *text, const char *file, int line, const char *func, const char *format) {
691 static char buffer[LINE_MAX];
693 snprintf(buffer, sizeof(buffer), format, text, file, line, func);
695 char_array_0(buffer);
696 log_abort_msg = buffer;
698 log_dispatch(LOG_CRIT, 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(text, file, line, func, "Assertion '%s' failed at %s:%u, function %s(). Aborting.");
707 _noreturn_ void log_assert_failed_unreachable(const char *text, const char *file, int line, const char *func) {
708 log_assert(text, file, line, func, "Code should not be reached '%s' at %s:%u, function %s(). Aborting.");
711 int log_oom_internal(const char *file, int line, const char *func) {
712 log_meta(LOG_ERR, file, line, func, "Out of memory.");
716 int log_struct_internal(
721 const char *format, ...) {
727 if (_likely_(LOG_PRI(level) > log_max_level))
730 if (log_target == LOG_TARGET_NULL)
733 if ((level & LOG_FACMASK) == 0)
734 level = log_facility | LOG_PRI(level);
736 if ((log_target == LOG_TARGET_AUTO ||
737 log_target == LOG_TARGET_JOURNAL_OR_KMSG ||
738 log_target == LOG_TARGET_JOURNAL) &&
741 char header[LINE_MAX];
742 struct iovec iovec[17] = {};
747 static const char nl = '\n';
749 /* If the journal is available do structured logging */
750 log_do_header(header, sizeof(header), level,
751 file, line, func, NULL, NULL);
752 IOVEC_SET_STRING(iovec[n++], header);
754 va_start(ap, format);
755 while (format && n + 1 < ELEMENTSOF(iovec)) {
759 /* We need to copy the va_list structure,
760 * since vasprintf() leaves it afterwards at
761 * an undefined location */
764 if (vasprintf(&buf, format, aq) < 0) {
771 /* Now, jump enough ahead, so that we point to
772 * the next format string */
773 VA_FORMAT_ADVANCE(format, ap);
775 IOVEC_SET_STRING(iovec[n++], buf);
777 iovec[n].iov_base = (char*) &nl;
778 iovec[n].iov_len = 1;
781 format = va_arg(ap, char *);
786 if (sendmsg(journal_fd, &mh, MSG_NOSIGNAL) < 0)
793 for (i = 1; i < n; i += 2)
794 free(iovec[i].iov_base);
800 /* Fallback if journal logging is not available */
802 va_start(ap, format);
807 vsnprintf(buf, sizeof(buf), format, aq);
811 if (startswith(buf, "MESSAGE=")) {
816 VA_FORMAT_ADVANCE(format, ap);
818 format = va_arg(ap, char *);
823 r = log_dispatch(level, file, line, func,
824 NULL, NULL, buf + 8);
832 int log_set_target_from_string(const char *e) {
835 t = log_target_from_string(e);
843 int log_set_max_level_from_string(const char *e) {
846 t = log_level_from_string(e);
850 log_set_max_level(t);
854 void log_parse_environment(void) {
857 e = secure_getenv("SYSTEMD_LOG_TARGET");
858 if (e && log_set_target_from_string(e) < 0)
859 log_warning("Failed to parse log target %s. Ignoring.", e);
861 e = secure_getenv("SYSTEMD_LOG_LEVEL");
862 if (e && log_set_max_level_from_string(e) < 0)
863 log_warning("Failed to parse log level %s. Ignoring.", e);
865 e = secure_getenv("SYSTEMD_LOG_COLOR");
866 if (e && log_show_color_from_string(e) < 0)
867 log_warning("Failed to parse bool %s. Ignoring.", e);
869 e = secure_getenv("SYSTEMD_LOG_LOCATION");
870 if (e && log_show_location_from_string(e) < 0)
871 log_warning("Failed to parse bool %s. Ignoring.", e);
874 LogTarget log_get_target(void) {
878 int log_get_max_level(void) {
879 return log_max_level;
882 void log_show_color(bool b) {
886 void log_show_location(bool b) {
890 int log_show_color_from_string(const char *e) {
893 t = parse_boolean(e);
901 int log_show_location_from_string(const char *e) {
904 t = parse_boolean(e);
908 log_show_location(t);
912 bool log_on_console(void) {
913 if (log_target == LOG_TARGET_CONSOLE)
916 return syslog_fd < 0 && kmsg_fd < 0 && journal_fd < 0;
919 static const char *const log_target_table[] = {
920 [LOG_TARGET_CONSOLE] = "console",
921 [LOG_TARGET_KMSG] = "kmsg",
922 [LOG_TARGET_JOURNAL] = "journal",
923 [LOG_TARGET_JOURNAL_OR_KMSG] = "journal-or-kmsg",
924 [LOG_TARGET_SYSLOG] = "syslog",
925 [LOG_TARGET_SYSLOG_OR_KMSG] = "syslog-or-kmsg",
926 [LOG_TARGET_AUTO] = "auto",
927 [LOG_TARGET_SAFE] = "safe",
928 [LOG_TARGET_NULL] = "null"
931 DEFINE_STRING_TABLE_LOOKUP(log_target, LogTarget);