1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2011 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/>.
22 #include <sys/epoll.h>
23 #include <sys/socket.h>
25 #include <sys/signalfd.h>
29 #include <sys/ioctl.h>
30 #include <linux/sockios.h>
31 #include <sys/statvfs.h>
34 #include <systemd/sd-journal.h>
35 #include <systemd/sd-messages.h>
36 #include <systemd/sd-daemon.h>
39 #include <systemd/sd-login.h>
44 #include "journal-file.h"
45 #include "socket-util.h"
46 #include "cgroup-util.h"
48 #include "journal-rate-limit.h"
49 #include "journal-internal.h"
50 #include "journal-vacuum.h"
51 #include "conf-parser.h"
58 #include <acl/libacl.h>
63 #include <selinux/selinux.h>
66 #define USER_JOURNALS_MAX 1024
67 #define STDOUT_STREAMS_MAX 4096
69 #define DEFAULT_RATE_LIMIT_INTERVAL (10*USEC_PER_SEC)
70 #define DEFAULT_RATE_LIMIT_BURST 200
72 #define RECHECK_AVAILABLE_SPACE_USEC (30*USEC_PER_SEC)
74 #define N_IOVEC_META_FIELDS 17
75 #define N_IOVEC_KERNEL_FIELDS 64
77 #define ENTRY_SIZE_MAX (1024*1024*32)
79 typedef enum StdoutStreamState {
80 STDOUT_STREAM_IDENTIFIER,
81 STDOUT_STREAM_UNIT_ID,
82 STDOUT_STREAM_PRIORITY,
83 STDOUT_STREAM_LEVEL_PREFIX,
84 STDOUT_STREAM_FORWARD_TO_SYSLOG,
85 STDOUT_STREAM_FORWARD_TO_KMSG,
86 STDOUT_STREAM_FORWARD_TO_CONSOLE,
92 StdoutStreamState state;
98 security_context_t security_context;
105 bool forward_to_syslog:1;
106 bool forward_to_kmsg:1;
107 bool forward_to_console:1;
109 char buffer[LINE_MAX+1];
112 LIST_FIELDS(StdoutStream, stdout_stream);
115 static const char* const storage_table[] = {
116 [STORAGE_AUTO] = "auto",
117 [STORAGE_VOLATILE] = "volatile",
118 [STORAGE_PERSISTENT] = "persistent",
119 [STORAGE_NONE] = "none"
122 DEFINE_STRING_TABLE_LOOKUP(storage, Storage);
123 DEFINE_CONFIG_PARSE_ENUM(config_parse_storage, storage, Storage, "Failed to parse storage setting");
125 static uint64_t available_space(Server *s) {
130 uint64_t sum = 0, avail = 0, ss_avail = 0;
136 ts = now(CLOCK_MONOTONIC);
138 if (s->cached_available_space_timestamp + RECHECK_AVAILABLE_SPACE_USEC > ts)
139 return s->cached_available_space;
141 r = sd_id128_get_machine(&machine);
145 if (s->system_journal) {
146 f = "/var/log/journal/";
147 m = &s->system_metrics;
149 f = "/run/log/journal/";
150 m = &s->runtime_metrics;
155 p = strappend(f, sd_id128_to_string(machine, ids));
165 if (fstatvfs(dirfd(d), &ss) < 0)
170 struct dirent buf, *de;
172 r = readdir_r(d, &buf, &de);
179 if (!endswith(de->d_name, ".journal") &&
180 !endswith(de->d_name, ".journal~"))
183 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
186 if (!S_ISREG(st.st_mode))
189 sum += (uint64_t) st.st_blocks * 512UL;
192 avail = sum >= m->max_use ? 0 : m->max_use - sum;
194 ss_avail = ss.f_bsize * ss.f_bavail;
196 ss_avail = ss_avail < m->keep_free ? 0 : ss_avail - m->keep_free;
198 if (ss_avail < avail)
201 s->cached_available_space = avail;
202 s->cached_available_space_timestamp = ts;
210 static void server_read_file_gid(Server *s) {
211 const char *adm = "adm";
216 if (s->file_gid_valid)
219 r = get_group_creds(&adm, &s->file_gid);
221 log_warning("Failed to resolve 'adm' group: %s", strerror(-r));
223 /* if we couldn't read the gid, then it will be 0, but that's
224 * fine and we shouldn't try to resolve the group again, so
225 * let's just pretend it worked right-away. */
226 s->file_gid_valid = true;
229 static void server_fix_perms(Server *s, JournalFile *f, uid_t uid) {
234 acl_permset_t permset;
239 server_read_file_gid(s);
241 r = fchmod_and_fchown(f->fd, 0640, 0, s->file_gid);
243 log_warning("Failed to fix access mode/rights on %s, ignoring: %s", f->path, strerror(-r));
249 acl = acl_get_fd(f->fd);
251 log_warning("Failed to read ACL on %s, ignoring: %m", f->path);
255 r = acl_find_uid(acl, uid, &entry);
258 if (acl_create_entry(&acl, &entry) < 0 ||
259 acl_set_tag_type(entry, ACL_USER) < 0 ||
260 acl_set_qualifier(entry, &uid) < 0) {
261 log_warning("Failed to patch ACL on %s, ignoring: %m", f->path);
266 if (acl_get_permset(entry, &permset) < 0 ||
267 acl_add_perm(permset, ACL_READ) < 0 ||
268 acl_calc_mask(&acl) < 0) {
269 log_warning("Failed to patch ACL on %s, ignoring: %m", f->path);
273 if (acl_set_fd(f->fd, acl) < 0)
274 log_warning("Failed to set ACL on %s, ignoring: %m", f->path);
281 static JournalFile* find_journal(Server *s, uid_t uid) {
289 /* We split up user logs only on /var, not on /run. If the
290 * runtime file is open, we write to it exclusively, in order
291 * to guarantee proper order as soon as we flush /run to
292 * /var and close the runtime file. */
294 if (s->runtime_journal)
295 return s->runtime_journal;
298 return s->system_journal;
300 r = sd_id128_get_machine(&machine);
302 return s->system_journal;
304 f = hashmap_get(s->user_journals, UINT32_TO_PTR(uid));
308 if (asprintf(&p, "/var/log/journal/" SD_ID128_FORMAT_STR "/user-%lu.journal",
309 SD_ID128_FORMAT_VAL(machine), (unsigned long) uid) < 0)
310 return s->system_journal;
312 while (hashmap_size(s->user_journals) >= USER_JOURNALS_MAX) {
313 /* Too many open? Then let's close one */
314 f = hashmap_steal_first(s->user_journals);
316 journal_file_close(f);
319 r = journal_file_open_reliably(p, O_RDWR|O_CREAT, 0640, s->compress, false, &s->system_metrics, s->mmap, s->system_journal, &f);
323 return s->system_journal;
325 server_fix_perms(s, f, uid);
327 r = hashmap_put(s->user_journals, UINT32_TO_PTR(uid), f);
329 journal_file_close(f);
330 return s->system_journal;
336 static void server_rotate(Server *s) {
342 log_info("Rotating...");
344 if (s->runtime_journal) {
345 r = journal_file_rotate(&s->runtime_journal, s->compress, false);
347 if (s->runtime_journal)
348 log_error("Failed to rotate %s: %s", s->runtime_journal->path, strerror(-r));
350 log_error("Failed to create new runtime journal: %s", strerror(-r));
352 server_fix_perms(s, s->runtime_journal, 0);
355 if (s->system_journal) {
356 r = journal_file_rotate(&s->system_journal, s->compress, true);
358 if (s->system_journal)
359 log_error("Failed to rotate %s: %s", s->system_journal->path, strerror(-r));
361 log_error("Failed to create new system journal: %s", strerror(-r));
364 server_fix_perms(s, s->system_journal, 0);
367 HASHMAP_FOREACH_KEY(f, k, s->user_journals, i) {
368 r = journal_file_rotate(&f, s->compress, false);
371 log_error("Failed to rotate %s: %s", f->path, strerror(-r));
373 log_error("Failed to create user journal: %s", strerror(-r));
375 hashmap_replace(s->user_journals, k, f);
376 server_fix_perms(s, s->system_journal, PTR_TO_UINT32(k));
381 static void server_vacuum(Server *s) {
387 log_info("Vacuuming...");
389 r = sd_id128_get_machine(&machine);
391 log_error("Failed to get machine ID: %s", strerror(-r));
395 sd_id128_to_string(machine, ids);
397 if (s->system_journal) {
398 if (asprintf(&p, "/var/log/journal/%s", ids) < 0) {
403 r = journal_directory_vacuum(p, s->system_metrics.max_use, s->system_metrics.keep_free);
404 if (r < 0 && r != -ENOENT)
405 log_error("Failed to vacuum %s: %s", p, strerror(-r));
409 if (s->runtime_journal) {
410 if (asprintf(&p, "/run/log/journal/%s", ids) < 0) {
415 r = journal_directory_vacuum(p, s->runtime_metrics.max_use, s->runtime_metrics.keep_free);
416 if (r < 0 && r != -ENOENT)
417 log_error("Failed to vacuum %s: %s", p, strerror(-r));
421 s->cached_available_space_timestamp = 0;
424 static char *shortened_cgroup_path(pid_t pid) {
426 char *process_path, *init_path, *path;
430 r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, pid, &process_path);
434 r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, 1, &init_path);
440 if (endswith(init_path, "/system"))
441 init_path[strlen(init_path) - 7] = 0;
442 else if (streq(init_path, "/"))
445 if (startswith(process_path, init_path)) {
448 p = strdup(process_path + strlen(init_path));
466 static void write_to_journal(Server *s, uid_t uid, struct iovec *iovec, unsigned n) {
468 bool vacuumed = false;
475 f = find_journal(s, uid);
479 if (journal_file_rotate_suggested(f)) {
480 log_info("Journal header limits reached or header out-of-date, rotating.");
485 f = find_journal(s, uid);
491 r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL);
496 (r != -E2BIG && /* hit limit */
497 r != -EFBIG && /* hit fs limit */
498 r != -EDQUOT && /* quota hit */
499 r != -ENOSPC && /* disk full */
500 r != -EBADMSG && /* corrupted */
501 r != -ENODATA && /* truncated */
502 r != -EHOSTDOWN && /* other machine */
503 r != -EPROTONOSUPPORT && /* unsupported feature */
504 r != -EBUSY && /* unclean shutdown */
505 r != -ESHUTDOWN /* already archived */)) {
506 log_error("Failed to write entry, ignoring: %s", strerror(-r));
510 if (r == -E2BIG || r == -EFBIG || r == EDQUOT || r == ENOSPC)
511 log_info("Allocation limit reached, rotating.");
512 else if (r == -EHOSTDOWN)
513 log_info("Journal file from other machine, rotating.");
514 else if (r == -EBUSY)
515 log_info("Unlcean shutdown, rotating.");
517 log_warning("Journal file corrupted, rotating.");
523 f = find_journal(s, uid);
527 log_info("Retrying write.");
531 static void dispatch_message_real(
533 struct iovec *iovec, unsigned n, unsigned m,
536 const char *label, size_t label_len,
537 const char *unit_id) {
539 char *pid = NULL, *uid = NULL, *gid = NULL,
540 *source_time = NULL, *boot_id = NULL, *machine_id = NULL,
541 *comm = NULL, *cmdline = NULL, *hostname = NULL,
542 *audit_session = NULL, *audit_loginuid = NULL,
543 *exe = NULL, *cgroup = NULL, *session = NULL,
544 *owner_uid = NULL, *unit = NULL, *selinux_context = NULL;
550 uid_t loginuid = 0, realuid = 0;
555 assert(n + N_IOVEC_META_FIELDS <= m);
563 realuid = ucred->uid;
565 if (asprintf(&pid, "_PID=%lu", (unsigned long) ucred->pid) >= 0)
566 IOVEC_SET_STRING(iovec[n++], pid);
568 if (asprintf(&uid, "_UID=%lu", (unsigned long) ucred->uid) >= 0)
569 IOVEC_SET_STRING(iovec[n++], uid);
571 if (asprintf(&gid, "_GID=%lu", (unsigned long) ucred->gid) >= 0)
572 IOVEC_SET_STRING(iovec[n++], gid);
574 r = get_process_comm(ucred->pid, &t);
576 comm = strappend("_COMM=", t);
580 IOVEC_SET_STRING(iovec[n++], comm);
583 r = get_process_exe(ucred->pid, &t);
585 exe = strappend("_EXE=", t);
589 IOVEC_SET_STRING(iovec[n++], exe);
592 r = get_process_cmdline(ucred->pid, LINE_MAX, false, &t);
594 cmdline = strappend("_CMDLINE=", t);
598 IOVEC_SET_STRING(iovec[n++], cmdline);
601 r = audit_session_from_pid(ucred->pid, &audit);
603 if (asprintf(&audit_session, "_AUDIT_SESSION=%lu", (unsigned long) audit) >= 0)
604 IOVEC_SET_STRING(iovec[n++], audit_session);
606 r = audit_loginuid_from_pid(ucred->pid, &loginuid);
608 if (asprintf(&audit_loginuid, "_AUDIT_LOGINUID=%lu", (unsigned long) loginuid) >= 0)
609 IOVEC_SET_STRING(iovec[n++], audit_loginuid);
611 t = shortened_cgroup_path(ucred->pid);
613 cgroup = strappend("_SYSTEMD_CGROUP=", t);
617 IOVEC_SET_STRING(iovec[n++], cgroup);
621 if (sd_pid_get_session(ucred->pid, &t) >= 0) {
622 session = strappend("_SYSTEMD_SESSION=", t);
626 IOVEC_SET_STRING(iovec[n++], session);
629 if (sd_pid_get_owner_uid(ucred->uid, &owner) >= 0)
630 if (asprintf(&owner_uid, "_SYSTEMD_OWNER_UID=%lu", (unsigned long) owner) >= 0)
631 IOVEC_SET_STRING(iovec[n++], owner_uid);
634 if (cg_pid_get_unit(ucred->pid, &t) >= 0) {
635 unit = strappend("_SYSTEMD_UNIT=", t);
638 unit = strappend("_SYSTEMD_UNIT=", unit_id);
641 IOVEC_SET_STRING(iovec[n++], unit);
645 selinux_context = malloc(sizeof("_SELINUX_CONTEXT=") + label_len);
646 if (selinux_context) {
647 memcpy(selinux_context, "_SELINUX_CONTEXT=", sizeof("_SELINUX_CONTEXT=")-1);
648 memcpy(selinux_context+sizeof("_SELINUX_CONTEXT=")-1, label, label_len);
649 selinux_context[sizeof("_SELINUX_CONTEXT=")-1+label_len] = 0;
650 IOVEC_SET_STRING(iovec[n++], selinux_context);
653 security_context_t con;
655 if (getpidcon(ucred->pid, &con) >= 0) {
656 selinux_context = strappend("_SELINUX_CONTEXT=", con);
658 IOVEC_SET_STRING(iovec[n++], selinux_context);
667 if (asprintf(&source_time, "_SOURCE_REALTIME_TIMESTAMP=%llu",
668 (unsigned long long) timeval_load(tv)) >= 0)
669 IOVEC_SET_STRING(iovec[n++], source_time);
672 /* Note that strictly speaking storing the boot id here is
673 * redundant since the entry includes this in-line
674 * anyway. However, we need this indexed, too. */
675 r = sd_id128_get_boot(&id);
677 if (asprintf(&boot_id, "_BOOT_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
678 IOVEC_SET_STRING(iovec[n++], boot_id);
680 r = sd_id128_get_machine(&id);
682 if (asprintf(&machine_id, "_MACHINE_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
683 IOVEC_SET_STRING(iovec[n++], machine_id);
685 t = gethostname_malloc();
687 hostname = strappend("_HOSTNAME=", t);
690 IOVEC_SET_STRING(iovec[n++], hostname);
695 write_to_journal(s, realuid == 0 ? 0 : loginuid, iovec, n);
708 free(audit_loginuid);
713 free(selinux_context);
716 static void driver_message(Server *s, sd_id128_t message_id, const char *format, ...) {
717 char mid[11 + 32 + 1];
718 char buffer[16 + LINE_MAX + 1];
719 struct iovec iovec[N_IOVEC_META_FIELDS + 4];
727 IOVEC_SET_STRING(iovec[n++], "PRIORITY=6");
728 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=driver");
730 memcpy(buffer, "MESSAGE=", 8);
731 va_start(ap, format);
732 vsnprintf(buffer + 8, sizeof(buffer) - 8, format, ap);
734 char_array_0(buffer);
735 IOVEC_SET_STRING(iovec[n++], buffer);
737 snprintf(mid, sizeof(mid), "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(message_id));
739 IOVEC_SET_STRING(iovec[n++], mid);
742 ucred.pid = getpid();
743 ucred.uid = getuid();
744 ucred.gid = getgid();
746 dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL);
749 static void dispatch_message(Server *s,
750 struct iovec *iovec, unsigned n, unsigned m,
753 const char *label, size_t label_len,
757 char *path = NULL, *c;
760 assert(iovec || n == 0);
765 if (LOG_PRI(priority) > s->max_level_store)
771 path = shortened_cgroup_path(ucred->pid);
775 /* example: /user/lennart/3/foobar
776 * /system/dbus.service/foobar
778 * So let's cut of everything past the third /, since that is
779 * wher user directories start */
781 c = strchr(path, '/');
783 c = strchr(c+1, '/');
785 c = strchr(c+1, '/');
791 rl = journal_rate_limit_test(s->rate_limit, path, priority & LOG_PRIMASK, available_space(s));
798 /* Write a suppression message if we suppressed something */
800 driver_message(s, SD_MESSAGE_JOURNAL_DROPPED, "Suppressed %u messages from %s", rl - 1, path);
805 dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id);
808 static void forward_syslog_iovec(Server *s, const struct iovec *iovec, unsigned n_iovec, struct ucred *ucred, struct timeval *tv) {
809 struct msghdr msghdr;
810 struct cmsghdr *cmsg;
812 struct cmsghdr cmsghdr;
813 uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
815 union sockaddr_union sa;
822 msghdr.msg_iov = (struct iovec*) iovec;
823 msghdr.msg_iovlen = n_iovec;
826 sa.un.sun_family = AF_UNIX;
827 strncpy(sa.un.sun_path, "/run/systemd/journal/syslog", sizeof(sa.un.sun_path));
828 msghdr.msg_name = &sa;
829 msghdr.msg_namelen = offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path);
833 msghdr.msg_control = &control;
834 msghdr.msg_controllen = sizeof(control);
836 cmsg = CMSG_FIRSTHDR(&msghdr);
837 cmsg->cmsg_level = SOL_SOCKET;
838 cmsg->cmsg_type = SCM_CREDENTIALS;
839 cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
840 memcpy(CMSG_DATA(cmsg), ucred, sizeof(struct ucred));
841 msghdr.msg_controllen = cmsg->cmsg_len;
844 /* Forward the syslog message we received via /dev/log to
845 * /run/systemd/syslog. Unfortunately we currently can't set
846 * the SO_TIMESTAMP auxiliary data, and hence we don't. */
848 if (sendmsg(s->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0)
851 /* The socket is full? I guess the syslog implementation is
852 * too slow, and we shouldn't wait for that... */
856 if (ucred && errno == ESRCH) {
859 /* Hmm, presumably the sender process vanished
860 * by now, so let's fix it as good as we
865 memcpy(CMSG_DATA(cmsg), &u, sizeof(struct ucred));
867 if (sendmsg(s->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0)
875 log_debug("Failed to forward syslog message: %m");
878 static void forward_syslog_raw(Server *s, int priority, const char *buffer, struct ucred *ucred, struct timeval *tv) {
884 if (LOG_PRI(priority) > s->max_level_syslog)
887 IOVEC_SET_STRING(iovec, buffer);
888 forward_syslog_iovec(s, &iovec, 1, ucred, tv);
891 static void forward_syslog(Server *s, int priority, const char *identifier, const char *message, struct ucred *ucred, struct timeval *tv) {
892 struct iovec iovec[5];
893 char header_priority[6], header_time[64], header_pid[16];
897 char *ident_buf = NULL;
900 assert(priority >= 0);
901 assert(priority <= 999);
904 if (LOG_PRI(priority) > s->max_level_syslog)
907 /* First: priority field */
908 snprintf(header_priority, sizeof(header_priority), "<%i>", priority);
909 char_array_0(header_priority);
910 IOVEC_SET_STRING(iovec[n++], header_priority);
912 /* Second: timestamp */
913 t = tv ? tv->tv_sec : ((time_t) (now(CLOCK_REALTIME) / USEC_PER_SEC));
917 if (strftime(header_time, sizeof(header_time), "%h %e %T ", tm) <= 0)
919 IOVEC_SET_STRING(iovec[n++], header_time);
921 /* Third: identifier and PID */
924 get_process_comm(ucred->pid, &ident_buf);
925 identifier = ident_buf;
928 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
929 char_array_0(header_pid);
932 IOVEC_SET_STRING(iovec[n++], identifier);
934 IOVEC_SET_STRING(iovec[n++], header_pid);
935 } else if (identifier) {
936 IOVEC_SET_STRING(iovec[n++], identifier);
937 IOVEC_SET_STRING(iovec[n++], ": ");
940 /* Fourth: message */
941 IOVEC_SET_STRING(iovec[n++], message);
943 forward_syslog_iovec(s, iovec, n, ucred, tv);
948 static int fixup_priority(int priority) {
950 if ((priority & LOG_FACMASK) == 0)
951 return (priority & LOG_PRIMASK) | LOG_USER;
956 static void forward_kmsg(Server *s, int priority, const char *identifier, const char *message, struct ucred *ucred) {
957 struct iovec iovec[5];
958 char header_priority[6], header_pid[16];
960 char *ident_buf = NULL;
963 assert(priority >= 0);
964 assert(priority <= 999);
967 if (_unlikely_(LOG_PRI(priority) > s->max_level_kmsg))
970 if (_unlikely_(s->dev_kmsg_fd < 0))
973 /* Never allow messages with kernel facility to be written to
974 * kmsg, regardless where the data comes from. */
975 priority = fixup_priority(priority);
977 /* First: priority field */
978 snprintf(header_priority, sizeof(header_priority), "<%i>", priority);
979 char_array_0(header_priority);
980 IOVEC_SET_STRING(iovec[n++], header_priority);
982 /* Second: identifier and PID */
985 get_process_comm(ucred->pid, &ident_buf);
986 identifier = ident_buf;
989 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
990 char_array_0(header_pid);
993 IOVEC_SET_STRING(iovec[n++], identifier);
995 IOVEC_SET_STRING(iovec[n++], header_pid);
996 } else if (identifier) {
997 IOVEC_SET_STRING(iovec[n++], identifier);
998 IOVEC_SET_STRING(iovec[n++], ": ");
1001 /* Fourth: message */
1002 IOVEC_SET_STRING(iovec[n++], message);
1003 IOVEC_SET_STRING(iovec[n++], "\n");
1005 if (writev(s->dev_kmsg_fd, iovec, n) < 0)
1006 log_debug("Failed to write to /dev/kmsg for logging: %s", strerror(errno));
1011 static void forward_console(Server *s, int priority, const char *identifier, const char *message, struct ucred *ucred) {
1012 struct iovec iovec[4];
1013 char header_pid[16];
1015 char *ident_buf = NULL;
1021 if (LOG_PRI(priority) > s->max_level_console)
1024 /* First: identifier and PID */
1027 get_process_comm(ucred->pid, &ident_buf);
1028 identifier = ident_buf;
1031 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
1032 char_array_0(header_pid);
1035 IOVEC_SET_STRING(iovec[n++], identifier);
1037 IOVEC_SET_STRING(iovec[n++], header_pid);
1038 } else if (identifier) {
1039 IOVEC_SET_STRING(iovec[n++], identifier);
1040 IOVEC_SET_STRING(iovec[n++], ": ");
1043 /* Third: message */
1044 IOVEC_SET_STRING(iovec[n++], message);
1045 IOVEC_SET_STRING(iovec[n++], "\n");
1047 tty = s->tty_path ? s->tty_path : "/dev/console";
1049 fd = open_terminal(tty, O_WRONLY|O_NOCTTY|O_CLOEXEC);
1051 log_debug("Failed to open %s for logging: %s", tty, strerror(errno));
1055 if (writev(fd, iovec, n) < 0)
1056 log_debug("Failed to write to %s for logging: %s", tty, strerror(errno));
1058 close_nointr_nofail(fd);
1064 static void read_identifier(const char **buf, char **identifier, char **pid) {
1075 p += strspn(p, WHITESPACE);
1076 l = strcspn(p, WHITESPACE);
1085 if (p[l-1] == ']') {
1091 t = strndup(p+k+1, l-k-2);
1111 *buf += strspn(*buf, WHITESPACE);
1114 static void process_syslog_message(Server *s, const char *buf, struct ucred *ucred, struct timeval *tv, const char *label, size_t label_len) {
1115 char *message = NULL, *syslog_priority = NULL, *syslog_facility = NULL, *syslog_identifier = NULL, *syslog_pid = NULL;
1116 struct iovec iovec[N_IOVEC_META_FIELDS + 6];
1118 int priority = LOG_USER | LOG_INFO;
1119 char *identifier = NULL, *pid = NULL;
1126 parse_syslog_priority((char**) &buf, &priority);
1128 if (s->forward_to_syslog)
1129 forward_syslog_raw(s, priority, orig, ucred, tv);
1131 skip_syslog_date((char**) &buf);
1132 read_identifier(&buf, &identifier, &pid);
1134 if (s->forward_to_kmsg)
1135 forward_kmsg(s, priority, identifier, buf, ucred);
1137 if (s->forward_to_console)
1138 forward_console(s, priority, identifier, buf, ucred);
1140 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=syslog");
1142 if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
1143 IOVEC_SET_STRING(iovec[n++], syslog_priority);
1145 if (priority & LOG_FACMASK)
1146 if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
1147 IOVEC_SET_STRING(iovec[n++], syslog_facility);
1150 syslog_identifier = strappend("SYSLOG_IDENTIFIER=", identifier);
1151 if (syslog_identifier)
1152 IOVEC_SET_STRING(iovec[n++], syslog_identifier);
1156 syslog_pid = strappend("SYSLOG_PID=", pid);
1158 IOVEC_SET_STRING(iovec[n++], syslog_pid);
1161 message = strappend("MESSAGE=", buf);
1163 IOVEC_SET_STRING(iovec[n++], message);
1165 dispatch_message(s, iovec, n, ELEMENTSOF(iovec), ucred, tv, label, label_len, NULL, priority);
1170 free(syslog_priority);
1171 free(syslog_facility);
1172 free(syslog_identifier);
1176 static bool valid_user_field(const char *p, size_t l) {
1179 /* We kinda enforce POSIX syntax recommendations for
1180 environment variables here, but make a couple of additional
1183 http://pubs.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap08.html */
1185 /* No empty field names */
1189 /* Don't allow names longer than 64 chars */
1193 /* Variables starting with an underscore are protected */
1197 /* Don't allow digits as first character */
1198 if (p[0] >= '0' && p[0] <= '9')
1201 /* Only allow A-Z0-9 and '_' */
1202 for (a = p; a < p + l; a++)
1203 if (!((*a >= 'A' && *a <= 'Z') ||
1204 (*a >= '0' && *a <= '9') ||
1211 static void process_native_message(
1213 const void *buffer, size_t buffer_size,
1214 struct ucred *ucred,
1216 const char *label, size_t label_len) {
1218 struct iovec *iovec = NULL;
1219 unsigned n = 0, m = 0, j, tn = (unsigned) -1;
1222 int priority = LOG_INFO;
1223 char *identifier = NULL, *message = NULL;
1226 assert(buffer || buffer_size == 0);
1229 remaining = buffer_size;
1231 while (remaining > 0) {
1234 e = memchr(p, '\n', remaining);
1237 /* Trailing noise, let's ignore it, and flush what we collected */
1238 log_debug("Received message with trailing noise, ignoring.");
1243 /* Entry separator */
1244 dispatch_message(s, iovec, n, m, ucred, tv, label, label_len, NULL, priority);
1246 priority = LOG_INFO;
1253 if (*p == '.' || *p == '#') {
1254 /* Ignore control commands for now, and
1256 remaining -= (e - p) + 1;
1261 /* A property follows */
1263 if (n+N_IOVEC_META_FIELDS >= m) {
1267 u = MAX((n+N_IOVEC_META_FIELDS+1) * 2U, 4U);
1268 c = realloc(iovec, u * sizeof(struct iovec));
1278 q = memchr(p, '=', e - p);
1280 if (valid_user_field(p, q - p)) {
1285 /* If the field name starts with an
1286 * underscore, skip the variable,
1287 * since that indidates a trusted
1289 iovec[n].iov_base = (char*) p;
1290 iovec[n].iov_len = l;
1293 /* We need to determine the priority
1294 * of this entry for the rate limiting
1297 memcmp(p, "PRIORITY=", 9) == 0 &&
1298 p[9] >= '0' && p[9] <= '9')
1299 priority = (priority & LOG_FACMASK) | (p[9] - '0');
1302 memcmp(p, "SYSLOG_FACILITY=", 16) == 0 &&
1303 p[16] >= '0' && p[16] <= '9')
1304 priority = (priority & LOG_PRIMASK) | ((p[16] - '0') << 3);
1307 memcmp(p, "SYSLOG_FACILITY=", 16) == 0 &&
1308 p[16] >= '0' && p[16] <= '9' &&
1309 p[17] >= '0' && p[17] <= '9')
1310 priority = (priority & LOG_PRIMASK) | (((p[16] - '0')*10 + (p[17] - '0')) << 3);
1313 memcmp(p, "SYSLOG_IDENTIFIER=", 18) == 0) {
1316 t = strndup(p + 18, l - 18);
1321 } else if (l >= 8 &&
1322 memcmp(p, "MESSAGE=", 8) == 0) {
1325 t = strndup(p + 8, l - 8);
1333 remaining -= (e - p) + 1;
1341 if (remaining < e - p + 1 + sizeof(uint64_t) + 1) {
1342 log_debug("Failed to parse message, ignoring.");
1346 memcpy(&l_le, e + 1, sizeof(uint64_t));
1349 if (remaining < e - p + 1 + sizeof(uint64_t) + l + 1 ||
1350 e[1+sizeof(uint64_t)+l] != '\n') {
1351 log_debug("Failed to parse message, ignoring.");
1355 k = malloc((e - p) + 1 + l);
1361 memcpy(k, p, e - p);
1363 memcpy(k + (e - p) + 1, e + 1 + sizeof(uint64_t), l);
1365 if (valid_user_field(p, e - p)) {
1366 iovec[n].iov_base = k;
1367 iovec[n].iov_len = (e - p) + 1 + l;
1372 remaining -= (e - p) + 1 + sizeof(uint64_t) + l + 1;
1373 p = e + 1 + sizeof(uint64_t) + l + 1;
1381 IOVEC_SET_STRING(iovec[tn], "_TRANSPORT=journal");
1384 if (s->forward_to_syslog)
1385 forward_syslog(s, priority, identifier, message, ucred, tv);
1387 if (s->forward_to_kmsg)
1388 forward_kmsg(s, priority, identifier, message, ucred);
1390 if (s->forward_to_console)
1391 forward_console(s, priority, identifier, message, ucred);
1394 dispatch_message(s, iovec, n, m, ucred, tv, label, label_len, NULL, priority);
1397 for (j = 0; j < n; j++) {
1401 if (iovec[j].iov_base < buffer ||
1402 (const uint8_t*) iovec[j].iov_base >= (const uint8_t*) buffer + buffer_size)
1403 free(iovec[j].iov_base);
1411 static void process_native_file(
1414 struct ucred *ucred,
1416 const char *label, size_t label_len) {
1425 /* Data is in the passed file, since it didn't fit in a
1426 * datagram. We can't map the file here, since clients might
1427 * then truncate it and trigger a SIGBUS for us. So let's
1428 * stupidly read it */
1430 if (fstat(fd, &st) < 0) {
1431 log_error("Failed to stat passed file, ignoring: %m");
1435 if (!S_ISREG(st.st_mode)) {
1436 log_error("File passed is not regular. Ignoring.");
1440 if (st.st_size <= 0)
1443 if (st.st_size > ENTRY_SIZE_MAX) {
1444 log_error("File passed too large. Ignoring.");
1448 p = malloc(st.st_size);
1454 n = pread(fd, p, st.st_size, 0);
1456 log_error("Failed to read file, ignoring: %s", strerror(-n));
1458 process_native_message(s, p, n, ucred, tv, label, label_len);
1463 static int stdout_stream_log(StdoutStream *s, const char *p) {
1464 struct iovec iovec[N_IOVEC_META_FIELDS + 5];
1465 char *message = NULL, *syslog_priority = NULL, *syslog_facility = NULL, *syslog_identifier = NULL;
1469 size_t label_len = 0;
1477 priority = s->priority;
1479 if (s->level_prefix)
1480 parse_syslog_priority((char**) &p, &priority);
1482 if (s->forward_to_syslog || s->server->forward_to_syslog)
1483 forward_syslog(s->server, fixup_priority(priority), s->identifier, p, &s->ucred, NULL);
1485 if (s->forward_to_kmsg || s->server->forward_to_kmsg)
1486 forward_kmsg(s->server, priority, s->identifier, p, &s->ucred);
1488 if (s->forward_to_console || s->server->forward_to_console)
1489 forward_console(s->server, priority, s->identifier, p, &s->ucred);
1491 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=stdout");
1493 if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
1494 IOVEC_SET_STRING(iovec[n++], syslog_priority);
1496 if (priority & LOG_FACMASK)
1497 if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
1498 IOVEC_SET_STRING(iovec[n++], syslog_facility);
1500 if (s->identifier) {
1501 syslog_identifier = strappend("SYSLOG_IDENTIFIER=", s->identifier);
1502 if (syslog_identifier)
1503 IOVEC_SET_STRING(iovec[n++], syslog_identifier);
1506 message = strappend("MESSAGE=", p);
1508 IOVEC_SET_STRING(iovec[n++], message);
1511 if (s->security_context) {
1512 label = (char*) s->security_context;
1513 label_len = strlen((char*) s->security_context);
1517 dispatch_message(s->server, iovec, n, ELEMENTSOF(iovec), &s->ucred, NULL, label, label_len, s->unit_id, priority);
1520 free(syslog_priority);
1521 free(syslog_facility);
1522 free(syslog_identifier);
1527 static int stdout_stream_line(StdoutStream *s, char *p) {
1537 case STDOUT_STREAM_IDENTIFIER:
1539 s->identifier = NULL;
1541 s->identifier = strdup(p);
1546 s->state = STDOUT_STREAM_UNIT_ID;
1549 case STDOUT_STREAM_UNIT_ID:
1550 if (s->ucred.uid == 0) {
1554 s->unit_id = strdup(p);
1560 s->state = STDOUT_STREAM_PRIORITY;
1563 case STDOUT_STREAM_PRIORITY:
1564 r = safe_atoi(p, &s->priority);
1565 if (r < 0 || s->priority <= 0 || s->priority >= 999) {
1566 log_warning("Failed to parse log priority line.");
1570 s->state = STDOUT_STREAM_LEVEL_PREFIX;
1573 case STDOUT_STREAM_LEVEL_PREFIX:
1574 r = parse_boolean(p);
1576 log_warning("Failed to parse level prefix line.");
1580 s->level_prefix = !!r;
1581 s->state = STDOUT_STREAM_FORWARD_TO_SYSLOG;
1584 case STDOUT_STREAM_FORWARD_TO_SYSLOG:
1585 r = parse_boolean(p);
1587 log_warning("Failed to parse forward to syslog line.");
1591 s->forward_to_syslog = !!r;
1592 s->state = STDOUT_STREAM_FORWARD_TO_KMSG;
1595 case STDOUT_STREAM_FORWARD_TO_KMSG:
1596 r = parse_boolean(p);
1598 log_warning("Failed to parse copy to kmsg line.");
1602 s->forward_to_kmsg = !!r;
1603 s->state = STDOUT_STREAM_FORWARD_TO_CONSOLE;
1606 case STDOUT_STREAM_FORWARD_TO_CONSOLE:
1607 r = parse_boolean(p);
1609 log_warning("Failed to parse copy to console line.");
1613 s->forward_to_console = !!r;
1614 s->state = STDOUT_STREAM_RUNNING;
1617 case STDOUT_STREAM_RUNNING:
1618 return stdout_stream_log(s, p);
1621 assert_not_reached("Unknown stream state");
1624 static int stdout_stream_scan(StdoutStream *s, bool force_flush) {
1632 remaining = s->length;
1637 end = memchr(p, '\n', remaining);
1640 else if (remaining >= sizeof(s->buffer) - 1) {
1641 end = p + sizeof(s->buffer) - 1;
1648 r = stdout_stream_line(s, p);
1656 if (force_flush && remaining > 0) {
1658 r = stdout_stream_line(s, p);
1666 if (p > s->buffer) {
1667 memmove(s->buffer, p, remaining);
1668 s->length = remaining;
1674 static int stdout_stream_process(StdoutStream *s) {
1680 l = read(s->fd, s->buffer+s->length, sizeof(s->buffer)-1-s->length);
1683 if (errno == EAGAIN)
1686 log_warning("Failed to read from stream: %m");
1691 r = stdout_stream_scan(s, true);
1699 r = stdout_stream_scan(s, false);
1707 static void stdout_stream_free(StdoutStream *s) {
1711 assert(s->server->n_stdout_streams > 0);
1712 s->server->n_stdout_streams --;
1713 LIST_REMOVE(StdoutStream, stdout_stream, s->server->stdout_streams, s);
1718 epoll_ctl(s->server->epoll_fd, EPOLL_CTL_DEL, s->fd, NULL);
1720 close_nointr_nofail(s->fd);
1724 if (s->security_context)
1725 freecon(s->security_context);
1728 free(s->identifier);
1732 static int stdout_stream_new(Server *s) {
1733 StdoutStream *stream;
1736 struct epoll_event ev;
1740 fd = accept4(s->stdout_fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
1742 if (errno == EAGAIN)
1745 log_error("Failed to accept stdout connection: %m");
1749 if (s->n_stdout_streams >= STDOUT_STREAMS_MAX) {
1750 log_warning("Too many stdout streams, refusing connection.");
1751 close_nointr_nofail(fd);
1755 stream = new0(StdoutStream, 1);
1757 close_nointr_nofail(fd);
1763 len = sizeof(stream->ucred);
1764 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &stream->ucred, &len) < 0) {
1765 log_error("Failed to determine peer credentials: %m");
1771 if (getpeercon(fd, &stream->security_context) < 0 && errno != ENOPROTOOPT)
1772 log_error("Failed to determine peer security context: %m");
1775 if (shutdown(fd, SHUT_WR) < 0) {
1776 log_error("Failed to shutdown writing side of socket: %m");
1782 ev.data.ptr = stream;
1783 ev.events = EPOLLIN;
1784 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) {
1785 log_error("Failed to add stream to event loop: %m");
1791 LIST_PREPEND(StdoutStream, stdout_stream, s->stdout_streams, stream);
1792 s->n_stdout_streams ++;
1797 stdout_stream_free(stream);
1801 static bool is_us(const char *pid) {
1806 if (parse_pid(pid, &t) < 0)
1809 return t == getpid();
1812 static void dev_kmsg_record(Server *s, char *p, size_t l) {
1813 struct iovec iovec[N_IOVEC_META_FIELDS + 7 + N_IOVEC_KERNEL_FIELDS];
1814 char *message = NULL, *syslog_priority = NULL, *syslog_pid = NULL, *syslog_facility = NULL, *syslog_identifier = NULL, *source_time = NULL;
1816 unsigned n = 0, z = 0, j;
1818 char *identifier = NULL, *pid = NULL, *e, *f, *k;
1828 e = memchr(p, ',', l);
1833 r = safe_atoi(p, &priority);
1834 if (r < 0 || priority < 0 || priority > 999)
1837 if (s->forward_to_kmsg && (priority & LOG_FACMASK) != LOG_KERN)
1842 e = memchr(p, ',', l);
1847 r = safe_atou64(p, &serial);
1851 if (s->kernel_seqnum) {
1852 /* We already read this one? */
1853 if (serial < *s->kernel_seqnum)
1856 /* Did we lose any? */
1857 if (serial > *s->kernel_seqnum)
1858 driver_message(s, SD_MESSAGE_JOURNAL_MISSED, "Missed %llu kernel messages", (unsigned long long) serial - *s->kernel_seqnum - 1);
1860 /* Make sure we never read this one again. Note that
1861 * we always store the next message serial we expect
1862 * here, simply because this makes handling the first
1863 * message with serial 0 easy. */
1864 *s->kernel_seqnum = serial + 1;
1869 f = memchr(p, ';', l);
1872 /* Kernel 3.6 has the flags field, kernel 3.5 lacks that */
1873 e = memchr(p, ',', l);
1878 r = parse_usec(p, &usec);
1884 e = memchr(p, '\n', l);
1893 for (j = 0; l > 0 && j < N_IOVEC_KERNEL_FIELDS; j++) {
1895 /* Meta data fields attached */
1902 e = memchr(k, '\n', l);
1908 m = cunescape_length_with_prefix(k, e - k, "_KERNEL_");
1912 IOVEC_SET_STRING(iovec[n++], m);
1919 if (asprintf(&source_time, "_SOURCE_MONOTONIC_TIMESTAMP=%llu",
1920 (unsigned long long) usec) >= 0)
1921 IOVEC_SET_STRING(iovec[n++], source_time);
1923 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=kernel");
1925 if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
1926 IOVEC_SET_STRING(iovec[n++], syslog_priority);
1928 if ((priority & LOG_FACMASK) == LOG_KERN)
1929 IOVEC_SET_STRING(iovec[n++], "SYSLOG_IDENTIFIER=kernel");
1931 read_identifier((const char**) &p, &identifier, &pid);
1933 /* Avoid any messages we generated ourselves via
1934 * log_info() and friends. */
1935 if (pid && is_us(pid))
1939 syslog_identifier = strappend("SYSLOG_IDENTIFIER=", identifier);
1940 if (syslog_identifier)
1941 IOVEC_SET_STRING(iovec[n++], syslog_identifier);
1945 syslog_pid = strappend("SYSLOG_PID=", pid);
1947 IOVEC_SET_STRING(iovec[n++], syslog_pid);
1950 if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
1951 IOVEC_SET_STRING(iovec[n++], syslog_facility);
1954 message = cunescape_length_with_prefix(p, pl, "MESSAGE=");
1956 IOVEC_SET_STRING(iovec[n++], message);
1958 dispatch_message(s, iovec, n, ELEMENTSOF(iovec), NULL, NULL, NULL, 0, NULL, priority);
1961 for (j = 0; j < z; j++)
1962 free(iovec[j].iov_base);
1965 free(syslog_priority);
1966 free(syslog_identifier);
1968 free(syslog_facility);
1974 static int system_journal_open(Server *s) {
1980 r = sd_id128_get_machine(&machine);
1984 sd_id128_to_string(machine, ids);
1986 if (!s->system_journal &&
1987 (s->storage == STORAGE_PERSISTENT || s->storage == STORAGE_AUTO) &&
1988 access("/run/systemd/journal/flushed", F_OK) >= 0) {
1990 /* If in auto mode: first try to create the machine
1991 * path, but not the prefix.
1993 * If in persistent mode: create /var/log/journal and
1994 * the machine path */
1996 if (s->storage == STORAGE_PERSISTENT)
1997 (void) mkdir("/var/log/journal/", 0755);
1999 fn = strappend("/var/log/journal/", ids);
2003 (void) mkdir(fn, 0755);
2006 fn = strjoin("/var/log/journal/", ids, "/system.journal", NULL);
2010 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, true, &s->system_metrics, s->mmap, NULL, &s->system_journal);
2014 server_fix_perms(s, s->system_journal, 0);
2017 if (r != -ENOENT && r != -EROFS)
2018 log_warning("Failed to open system journal: %s", strerror(-r));
2024 if (!s->runtime_journal &&
2025 (s->storage != STORAGE_NONE)) {
2027 fn = strjoin("/run/log/journal/", ids, "/system.journal", NULL);
2031 if (s->system_journal) {
2033 /* Try to open the runtime journal, but only
2034 * if it already exists, so that we can flush
2035 * it into the system journal */
2037 r = journal_file_open(fn, O_RDWR, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
2042 log_warning("Failed to open runtime journal: %s", strerror(-r));
2049 /* OK, we really need the runtime journal, so create
2050 * it if necessary. */
2052 (void) mkdir_parents(fn, 0755);
2053 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
2057 log_error("Failed to open runtime journal: %s", strerror(-r));
2062 if (s->runtime_journal)
2063 server_fix_perms(s, s->runtime_journal, 0);
2069 static int server_flush_to_var(Server *s) {
2077 if (s->storage != STORAGE_AUTO &&
2078 s->storage != STORAGE_PERSISTENT)
2081 if (!s->runtime_journal)
2084 system_journal_open(s);
2086 if (!s->system_journal)
2089 log_info("Flushing to /var...");
2091 r = sd_id128_get_machine(&machine);
2093 log_error("Failed to get machine id: %s", strerror(-r));
2097 r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
2099 log_error("Failed to read runtime journal: %s", strerror(-r));
2103 SD_JOURNAL_FOREACH(j) {
2106 f = j->current_file;
2107 assert(f && f->current_offset > 0);
2109 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
2111 log_error("Can't read entry: %s", strerror(-r));
2115 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
2117 log_info("Allocation limit reached.");
2119 journal_file_post_change(s->system_journal);
2123 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
2127 log_error("Can't write entry: %s", strerror(-r));
2133 journal_file_post_change(s->system_journal);
2135 journal_file_close(s->runtime_journal);
2136 s->runtime_journal = NULL;
2139 rm_rf("/run/log/journal", false, true, false);
2144 static int server_read_dev_kmsg(Server *s) {
2145 char buffer[8192+1]; /* the kernel-side limit per record is 8K currently */
2149 assert(s->dev_kmsg_fd >= 0);
2151 l = read(s->dev_kmsg_fd, buffer, sizeof(buffer) - 1);
2155 /* Old kernels who don't allow reading from /dev/kmsg
2156 * return EINVAL when we try. So handle this cleanly,
2157 * but don' try to ever read from it again. */
2158 if (errno == EINVAL) {
2159 epoll_ctl(s->epoll_fd, EPOLL_CTL_DEL, s->dev_kmsg_fd, NULL);
2163 if (errno == EAGAIN || errno == EINTR)
2166 log_error("Failed to read from kernel: %m");
2170 dev_kmsg_record(s, buffer, l);
2174 static int server_flush_dev_kmsg(Server *s) {
2179 if (s->dev_kmsg_fd < 0)
2182 if (!s->dev_kmsg_readable)
2185 log_info("Flushing /dev/kmsg...");
2188 r = server_read_dev_kmsg(s);
2199 static int process_event(Server *s, struct epoll_event *ev) {
2203 if (ev->data.fd == s->signal_fd) {
2204 struct signalfd_siginfo sfsi;
2207 if (ev->events != EPOLLIN) {
2208 log_info("Got invalid event from epoll.");
2212 n = read(s->signal_fd, &sfsi, sizeof(sfsi));
2213 if (n != sizeof(sfsi)) {
2218 if (errno == EINTR || errno == EAGAIN)
2224 log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo));
2226 if (sfsi.ssi_signo == SIGUSR1) {
2227 touch("/run/systemd/journal/flushed");
2228 server_flush_to_var(s);
2232 if (sfsi.ssi_signo == SIGUSR2) {
2240 } else if (ev->data.fd == s->dev_kmsg_fd) {
2243 if (ev->events != EPOLLIN) {
2244 log_info("Got invalid event from epoll.");
2248 r = server_read_dev_kmsg(s);
2254 } else if (ev->data.fd == s->native_fd ||
2255 ev->data.fd == s->syslog_fd) {
2257 if (ev->events != EPOLLIN) {
2258 log_info("Got invalid event from epoll.");
2263 struct msghdr msghdr;
2265 struct ucred *ucred = NULL;
2266 struct timeval *tv = NULL;
2267 struct cmsghdr *cmsg;
2269 size_t label_len = 0;
2271 struct cmsghdr cmsghdr;
2273 /* We use NAME_MAX space for the
2274 * SELinux label here. The kernel
2275 * currently enforces no limit, but
2276 * according to suggestions from the
2277 * SELinux people this will change and
2278 * it will probably be identical to
2279 * NAME_MAX. For now we use that, but
2280 * this should be updated one day when
2281 * the final limit is known.*/
2282 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
2283 CMSG_SPACE(sizeof(struct timeval)) +
2284 CMSG_SPACE(sizeof(int)) + /* fd */
2285 CMSG_SPACE(NAME_MAX)]; /* selinux label */
2292 if (ioctl(ev->data.fd, SIOCINQ, &v) < 0) {
2293 log_error("SIOCINQ failed: %m");
2297 if (s->buffer_size < (size_t) v) {
2301 l = MAX(LINE_MAX + (size_t) v, s->buffer_size * 2);
2302 b = realloc(s->buffer, l+1);
2305 log_error("Couldn't increase buffer.");
2314 iovec.iov_base = s->buffer;
2315 iovec.iov_len = s->buffer_size;
2319 msghdr.msg_iov = &iovec;
2320 msghdr.msg_iovlen = 1;
2321 msghdr.msg_control = &control;
2322 msghdr.msg_controllen = sizeof(control);
2324 n = recvmsg(ev->data.fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
2327 if (errno == EINTR || errno == EAGAIN)
2330 log_error("recvmsg() failed: %m");
2334 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
2336 if (cmsg->cmsg_level == SOL_SOCKET &&
2337 cmsg->cmsg_type == SCM_CREDENTIALS &&
2338 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
2339 ucred = (struct ucred*) CMSG_DATA(cmsg);
2340 else if (cmsg->cmsg_level == SOL_SOCKET &&
2341 cmsg->cmsg_type == SCM_SECURITY) {
2342 label = (char*) CMSG_DATA(cmsg);
2343 label_len = cmsg->cmsg_len - CMSG_LEN(0);
2344 } else if (cmsg->cmsg_level == SOL_SOCKET &&
2345 cmsg->cmsg_type == SO_TIMESTAMP &&
2346 cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
2347 tv = (struct timeval*) CMSG_DATA(cmsg);
2348 else if (cmsg->cmsg_level == SOL_SOCKET &&
2349 cmsg->cmsg_type == SCM_RIGHTS) {
2350 fds = (int*) CMSG_DATA(cmsg);
2351 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
2355 if (ev->data.fd == s->syslog_fd) {
2358 if (n > 0 && n_fds == 0) {
2359 e = memchr(s->buffer, '\n', n);
2365 process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);
2366 } else if (n_fds > 0)
2367 log_warning("Got file descriptors via syslog socket. Ignoring.");
2370 if (n > 0 && n_fds == 0)
2371 process_native_message(s, s->buffer, n, ucred, tv, label, label_len);
2372 else if (n == 0 && n_fds == 1)
2373 process_native_file(s, fds[0], ucred, tv, label, label_len);
2375 log_warning("Got too many file descriptors via native socket. Ignoring.");
2378 close_many(fds, n_fds);
2383 } else if (ev->data.fd == s->stdout_fd) {
2385 if (ev->events != EPOLLIN) {
2386 log_info("Got invalid event from epoll.");
2390 stdout_stream_new(s);
2394 StdoutStream *stream;
2396 if ((ev->events|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
2397 log_info("Got invalid event from epoll.");
2401 /* If it is none of the well-known fds, it must be an
2402 * stdout stream fd. Note that this is a bit ugly here
2403 * (since we rely that none of the well-known fds
2404 * could be interpreted as pointer), but nonetheless
2405 * safe, since the well-known fds would never get an
2406 * fd > 4096, i.e. beyond the first memory page */
2408 stream = ev->data.ptr;
2410 if (stdout_stream_process(stream) <= 0)
2411 stdout_stream_free(stream);
2416 log_error("Unknown event.");
2420 static int open_syslog_socket(Server *s) {
2421 union sockaddr_union sa;
2423 struct epoll_event ev;
2427 if (s->syslog_fd < 0) {
2429 s->syslog_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2430 if (s->syslog_fd < 0) {
2431 log_error("socket() failed: %m");
2436 sa.un.sun_family = AF_UNIX;
2437 strncpy(sa.un.sun_path, "/dev/log", sizeof(sa.un.sun_path));
2439 unlink(sa.un.sun_path);
2441 r = bind(s->syslog_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
2443 log_error("bind() failed: %m");
2447 chmod(sa.un.sun_path, 0666);
2449 fd_nonblock(s->syslog_fd, 1);
2452 r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
2454 log_error("SO_PASSCRED failed: %m");
2460 r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one));
2462 log_warning("SO_PASSSEC failed: %m");
2466 r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one));
2468 log_error("SO_TIMESTAMP failed: %m");
2473 ev.events = EPOLLIN;
2474 ev.data.fd = s->syslog_fd;
2475 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->syslog_fd, &ev) < 0) {
2476 log_error("Failed to add syslog server fd to epoll object: %m");
2483 static int open_native_socket(Server*s) {
2484 union sockaddr_union sa;
2486 struct epoll_event ev;
2490 if (s->native_fd < 0) {
2492 s->native_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2493 if (s->native_fd < 0) {
2494 log_error("socket() failed: %m");
2499 sa.un.sun_family = AF_UNIX;
2500 strncpy(sa.un.sun_path, "/run/systemd/journal/socket", sizeof(sa.un.sun_path));
2502 unlink(sa.un.sun_path);
2504 r = bind(s->native_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
2506 log_error("bind() failed: %m");
2510 chmod(sa.un.sun_path, 0666);
2512 fd_nonblock(s->native_fd, 1);
2515 r = setsockopt(s->native_fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
2517 log_error("SO_PASSCRED failed: %m");
2523 r = setsockopt(s->syslog_fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one));
2525 log_warning("SO_PASSSEC failed: %m");
2529 r = setsockopt(s->native_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one));
2531 log_error("SO_TIMESTAMP failed: %m");
2536 ev.events = EPOLLIN;
2537 ev.data.fd = s->native_fd;
2538 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->native_fd, &ev) < 0) {
2539 log_error("Failed to add native server fd to epoll object: %m");
2546 static int open_stdout_socket(Server *s) {
2547 union sockaddr_union sa;
2549 struct epoll_event ev;
2553 if (s->stdout_fd < 0) {
2555 s->stdout_fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2556 if (s->stdout_fd < 0) {
2557 log_error("socket() failed: %m");
2562 sa.un.sun_family = AF_UNIX;
2563 strncpy(sa.un.sun_path, "/run/systemd/journal/stdout", sizeof(sa.un.sun_path));
2565 unlink(sa.un.sun_path);
2567 r = bind(s->stdout_fd, &sa.sa, offsetof(union sockaddr_union, un.sun_path) + strlen(sa.un.sun_path));
2569 log_error("bind() failed: %m");
2573 chmod(sa.un.sun_path, 0666);
2575 if (listen(s->stdout_fd, SOMAXCONN) < 0) {
2576 log_error("liste() failed: %m");
2580 fd_nonblock(s->stdout_fd, 1);
2583 ev.events = EPOLLIN;
2584 ev.data.fd = s->stdout_fd;
2585 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->stdout_fd, &ev) < 0) {
2586 log_error("Failed to add stdout server fd to epoll object: %m");
2593 static int open_dev_kmsg(Server *s) {
2594 struct epoll_event ev;
2598 s->dev_kmsg_fd = open("/dev/kmsg", O_RDWR|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);
2599 if (s->dev_kmsg_fd < 0) {
2600 log_warning("Failed to open /dev/kmsg, ignoring: %m");
2605 ev.events = EPOLLIN;
2606 ev.data.fd = s->dev_kmsg_fd;
2607 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->dev_kmsg_fd, &ev) < 0) {
2609 /* This will fail with EPERM on older kernels where
2610 * /dev/kmsg is not readable. */
2614 log_error("Failed to add /dev/kmsg fd to epoll object: %m");
2618 s->dev_kmsg_readable = true;
2623 static int open_kernel_seqnum(Server *s) {
2629 /* We store the seqnum we last read in an mmaped file. That
2630 * way we can just use it like a variable, but it is
2631 * persistant and automatically flushed at reboot. */
2633 fd = open("/run/systemd/journal/kernel-seqnum", O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0644);
2635 log_error("Failed to open /run/systemd/journal/kernel-seqnum, ignoring: %m");
2639 if (posix_fallocate(fd, 0, sizeof(uint64_t)) < 0) {
2640 log_error("Failed to allocate sequential number file, ignoring: %m");
2641 close_nointr_nofail(fd);
2645 p = mmap(NULL, sizeof(uint64_t), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
2646 if (p == MAP_FAILED) {
2647 log_error("Failed to map sequential number file, ignoring: %m");
2648 close_nointr_nofail(fd);
2652 close_nointr_nofail(fd);
2653 s->kernel_seqnum = p;
2658 static int open_signalfd(Server *s) {
2660 struct epoll_event ev;
2664 assert_se(sigemptyset(&mask) == 0);
2665 sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
2666 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
2668 s->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
2669 if (s->signal_fd < 0) {
2670 log_error("signalfd(): %m");
2675 ev.events = EPOLLIN;
2676 ev.data.fd = s->signal_fd;
2678 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->signal_fd, &ev) < 0) {
2679 log_error("epoll_ctl(): %m");
2686 static int server_parse_proc_cmdline(Server *s) {
2687 char *line, *w, *state;
2691 if (detect_container(NULL) > 0)
2694 r = read_one_line_file("/proc/cmdline", &line);
2696 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
2700 FOREACH_WORD_QUOTED(w, l, line, state) {
2703 word = strndup(w, l);
2709 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
2710 r = parse_boolean(word + 35);
2712 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
2714 s->forward_to_syslog = r;
2715 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
2716 r = parse_boolean(word + 33);
2718 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
2720 s->forward_to_kmsg = r;
2721 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
2722 r = parse_boolean(word + 36);
2724 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
2726 s->forward_to_console = r;
2727 } else if (startswith(word, "systemd.journald"))
2728 log_warning("Invalid systemd.journald parameter. Ignoring.");
2740 static int server_parse_config_file(Server *s) {
2747 fn = "/etc/systemd/journald.conf";
2748 f = fopen(fn, "re");
2750 if (errno == ENOENT)
2753 log_warning("Failed to open configuration file %s: %m", fn);
2757 r = config_parse(fn, f, "Journal\0", config_item_perf_lookup, (void*) journald_gperf_lookup, false, s);
2759 log_warning("Failed to parse configuration file: %s", strerror(-r));
2766 static int server_init(Server *s) {
2772 s->syslog_fd = s->native_fd = s->stdout_fd = s->signal_fd = s->epoll_fd = s->dev_kmsg_fd = -1;
2775 s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
2776 s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
2778 s->forward_to_syslog = true;
2780 s->max_level_store = LOG_DEBUG;
2781 s->max_level_syslog = LOG_DEBUG;
2782 s->max_level_kmsg = LOG_NOTICE;
2783 s->max_level_console = LOG_INFO;
2785 memset(&s->system_metrics, 0xFF, sizeof(s->system_metrics));
2786 memset(&s->runtime_metrics, 0xFF, sizeof(s->runtime_metrics));
2788 server_parse_config_file(s);
2789 server_parse_proc_cmdline(s);
2791 mkdir_p("/run/systemd/journal", 0755);
2793 s->user_journals = hashmap_new(trivial_hash_func, trivial_compare_func);
2794 if (!s->user_journals)
2797 s->mmap = mmap_cache_new(_OBJECT_TYPE_MAX, USER_JOURNALS_MAX + 2);
2801 s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2802 if (s->epoll_fd < 0) {
2803 log_error("Failed to create epoll object: %m");
2807 n = sd_listen_fds(true);
2809 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
2813 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
2815 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
2817 if (s->native_fd >= 0) {
2818 log_error("Too many native sockets passed.");
2824 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
2826 if (s->stdout_fd >= 0) {
2827 log_error("Too many stdout sockets passed.");
2833 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0) {
2835 if (s->syslog_fd >= 0) {
2836 log_error("Too many /dev/log sockets passed.");
2843 log_error("Unknown socket passed.");
2848 r = open_syslog_socket(s);
2852 r = open_native_socket(s);
2856 r = open_stdout_socket(s);
2860 r = open_dev_kmsg(s);
2864 r = open_kernel_seqnum(s);
2868 r = open_signalfd(s);
2872 s->rate_limit = journal_rate_limit_new(s->rate_limit_interval, s->rate_limit_burst);
2876 r = system_journal_open(s);
2883 static void server_done(Server *s) {
2887 while (s->stdout_streams)
2888 stdout_stream_free(s->stdout_streams);
2890 if (s->system_journal)
2891 journal_file_close(s->system_journal);
2893 if (s->runtime_journal)
2894 journal_file_close(s->runtime_journal);
2896 while ((f = hashmap_steal_first(s->user_journals)))
2897 journal_file_close(f);
2899 hashmap_free(s->user_journals);
2901 if (s->epoll_fd >= 0)
2902 close_nointr_nofail(s->epoll_fd);
2904 if (s->signal_fd >= 0)
2905 close_nointr_nofail(s->signal_fd);
2907 if (s->syslog_fd >= 0)
2908 close_nointr_nofail(s->syslog_fd);
2910 if (s->native_fd >= 0)
2911 close_nointr_nofail(s->native_fd);
2913 if (s->stdout_fd >= 0)
2914 close_nointr_nofail(s->stdout_fd);
2916 if (s->dev_kmsg_fd >= 0)
2917 close_nointr_nofail(s->dev_kmsg_fd);
2920 journal_rate_limit_free(s->rate_limit);
2922 if (s->kernel_seqnum)
2923 munmap(s->kernel_seqnum, sizeof(uint64_t));
2929 mmap_cache_unref(s->mmap);
2932 int main(int argc, char *argv[]) {
2936 /* if (getppid() != 1) { */
2937 /* log_error("This program should be invoked by init only."); */
2938 /* return EXIT_FAILURE; */
2942 log_error("This program does not take arguments.");
2943 return EXIT_FAILURE;
2946 log_set_target(LOG_TARGET_SAFE);
2947 log_set_facility(LOG_SYSLOG);
2948 log_set_max_level(LOG_DEBUG);
2949 log_parse_environment();
2954 r = server_init(&server);
2958 server_vacuum(&server);
2959 server_flush_to_var(&server);
2960 server_flush_dev_kmsg(&server);
2962 log_debug("systemd-journald running as pid %lu", (unsigned long) getpid());
2963 driver_message(&server, SD_MESSAGE_JOURNAL_START, "Journal started");
2967 "STATUS=Processing requests...");
2970 struct epoll_event event;
2972 r = epoll_wait(server.epoll_fd, &event, 1, -1);
2978 log_error("epoll_wait() failed: %m");
2984 r = process_event(&server, &event);
2991 log_debug("systemd-journald stopped as pid %lu", (unsigned long) getpid());
2992 driver_message(&server, SD_MESSAGE_JOURNAL_STOP, "Journal stopped");
2996 "STATUS=Shutting down...");
2998 server_done(&server);
3000 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;