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/>.
23 #include <sys/epoll.h>
26 #include <sys/socket.h>
28 #include <systemd/sd-messages.h>
31 #include "journald-server.h"
32 #include "journald-kmsg.h"
33 #include "journald-syslog.h"
35 void server_forward_kmsg(
38 const char *identifier,
40 struct ucred *ucred) {
42 struct iovec iovec[5];
43 char header_priority[6], header_pid[16];
45 char *ident_buf = NULL;
48 assert(priority >= 0);
49 assert(priority <= 999);
52 if (_unlikely_(LOG_PRI(priority) > s->max_level_kmsg))
55 if (_unlikely_(s->dev_kmsg_fd < 0))
58 /* Never allow messages with kernel facility to be written to
59 * kmsg, regardless where the data comes from. */
60 priority = syslog_fixup_facility(priority);
62 /* First: priority field */
63 snprintf(header_priority, sizeof(header_priority), "<%i>", priority);
64 char_array_0(header_priority);
65 IOVEC_SET_STRING(iovec[n++], header_priority);
67 /* Second: identifier and PID */
70 get_process_comm(ucred->pid, &ident_buf);
71 identifier = ident_buf;
74 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
75 char_array_0(header_pid);
78 IOVEC_SET_STRING(iovec[n++], identifier);
80 IOVEC_SET_STRING(iovec[n++], header_pid);
81 } else if (identifier) {
82 IOVEC_SET_STRING(iovec[n++], identifier);
83 IOVEC_SET_STRING(iovec[n++], ": ");
87 IOVEC_SET_STRING(iovec[n++], message);
88 IOVEC_SET_STRING(iovec[n++], "\n");
90 if (writev(s->dev_kmsg_fd, iovec, n) < 0)
91 log_debug("Failed to write to /dev/kmsg for logging: %s", strerror(errno));
96 static bool is_us(const char *pid) {
101 if (parse_pid(pid, &t) < 0)
104 return t == getpid();
107 static void dev_kmsg_record(Server *s, char *p, size_t l) {
108 struct iovec iovec[N_IOVEC_META_FIELDS + 7 + N_IOVEC_KERNEL_FIELDS + 2 + N_IOVEC_UDEV_FIELDS];
109 char *message = NULL, *syslog_priority = NULL, *syslog_pid = NULL, *syslog_facility = NULL, *syslog_identifier = NULL, *source_time = NULL;
111 unsigned n = 0, z = 0, j;
112 unsigned long long usec;
113 char *identifier = NULL, *pid = NULL, *e, *f, *k;
116 char *kernel_device = NULL;
124 e = memchr(p, ',', l);
129 r = safe_atoi(p, &priority);
130 if (r < 0 || priority < 0 || priority > 999)
133 if (s->forward_to_kmsg && (priority & LOG_FACMASK) != LOG_KERN)
138 e = memchr(p, ',', l);
143 r = safe_atou64(p, &serial);
147 if (s->kernel_seqnum) {
148 /* We already read this one? */
149 if (serial < *s->kernel_seqnum)
152 /* Did we lose any? */
153 if (serial > *s->kernel_seqnum)
154 server_driver_message(s, SD_MESSAGE_JOURNAL_MISSED, "Missed %"PRIu64" kernel messages",
155 serial - *s->kernel_seqnum - 1);
157 /* Make sure we never read this one again. Note that
158 * we always store the next message serial we expect
159 * here, simply because this makes handling the first
160 * message with serial 0 easy. */
161 *s->kernel_seqnum = serial + 1;
166 f = memchr(p, ';', l);
169 /* Kernel 3.6 has the flags field, kernel 3.5 lacks that */
170 e = memchr(p, ',', l);
175 r = safe_atollu(p, &usec);
181 e = memchr(p, '\n', l);
190 for (j = 0; l > 0 && j < N_IOVEC_KERNEL_FIELDS; j++) {
192 /* Meta data fields attached */
199 e = memchr(k, '\n', l);
205 m = cunescape_length_with_prefix(k, e - k, "_KERNEL_");
209 if (startswith(m, "_KERNEL_DEVICE="))
210 kernel_device = m + 15;
212 IOVEC_SET_STRING(iovec[n++], m);
220 struct udev_device *ud;
222 ud = udev_device_new_from_device_id(s->udev, kernel_device);
225 struct udev_list_entry *ll;
228 g = udev_device_get_devnode(ud);
230 b = strappend("_UDEV_DEVNODE=", g);
232 IOVEC_SET_STRING(iovec[n++], b);
237 g = udev_device_get_sysname(ud);
239 b = strappend("_UDEV_SYSNAME=", g);
241 IOVEC_SET_STRING(iovec[n++], b);
247 ll = udev_device_get_devlinks_list_entry(ud);
248 udev_list_entry_foreach(ll, ll) {
250 if (j > N_IOVEC_UDEV_FIELDS)
253 g = udev_list_entry_get_name(ll);
255 b = strappend("_UDEV_DEVLINK=", g);
257 IOVEC_SET_STRING(iovec[n++], b);
265 udev_device_unref(ud);
269 if (asprintf(&source_time, "_SOURCE_MONOTONIC_TIMESTAMP=%llu", usec) >= 0)
270 IOVEC_SET_STRING(iovec[n++], source_time);
272 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=kernel");
274 if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
275 IOVEC_SET_STRING(iovec[n++], syslog_priority);
277 if ((priority & LOG_FACMASK) == LOG_KERN)
278 IOVEC_SET_STRING(iovec[n++], "SYSLOG_IDENTIFIER=kernel");
280 pl -= syslog_parse_identifier((const char**) &p, &identifier, &pid);
282 /* Avoid any messages we generated ourselves via
283 * log_info() and friends. */
284 if (pid && is_us(pid))
288 syslog_identifier = strappend("SYSLOG_IDENTIFIER=", identifier);
289 if (syslog_identifier)
290 IOVEC_SET_STRING(iovec[n++], syslog_identifier);
294 syslog_pid = strappend("SYSLOG_PID=", pid);
296 IOVEC_SET_STRING(iovec[n++], syslog_pid);
299 if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
300 IOVEC_SET_STRING(iovec[n++], syslog_facility);
303 message = cunescape_length_with_prefix(p, pl, "MESSAGE=");
305 IOVEC_SET_STRING(iovec[n++], message);
307 server_dispatch_message(s, iovec, n, ELEMENTSOF(iovec), NULL, NULL, NULL, 0, NULL, priority, 0);
310 for (j = 0; j < z; j++)
311 free(iovec[j].iov_base);
314 free(syslog_priority);
315 free(syslog_identifier);
317 free(syslog_facility);
323 int server_read_dev_kmsg(Server *s) {
324 char buffer[8192+1]; /* the kernel-side limit per record is 8K currently */
328 assert(s->dev_kmsg_fd >= 0);
330 l = read(s->dev_kmsg_fd, buffer, sizeof(buffer) - 1);
334 /* Old kernels who don't allow reading from /dev/kmsg
335 * return EINVAL when we try. So handle this cleanly,
336 * but don' try to ever read from it again. */
337 if (errno == EINVAL) {
338 epoll_ctl(s->epoll_fd, EPOLL_CTL_DEL, s->dev_kmsg_fd, NULL);
342 if (errno == EAGAIN || errno == EINTR || errno == EPIPE)
345 log_error("Failed to read from kernel: %m");
349 dev_kmsg_record(s, buffer, l);
353 int server_flush_dev_kmsg(Server *s) {
358 if (s->dev_kmsg_fd < 0)
361 if (!s->dev_kmsg_readable)
364 log_debug("Flushing /dev/kmsg...");
367 r = server_read_dev_kmsg(s);
378 int server_open_dev_kmsg(Server *s) {
379 struct epoll_event ev;
383 s->dev_kmsg_fd = open("/dev/kmsg", O_RDWR|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);
384 if (s->dev_kmsg_fd < 0) {
385 log_warning("Failed to open /dev/kmsg, ignoring: %m");
391 ev.data.fd = s->dev_kmsg_fd;
392 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->dev_kmsg_fd, &ev) < 0) {
394 /* This will fail with EPERM on older kernels where
395 * /dev/kmsg is not readable. */
399 log_error("Failed to add /dev/kmsg fd to epoll object: %m");
403 s->dev_kmsg_readable = true;
408 int server_open_kernel_seqnum(Server *s) {
414 /* We store the seqnum we last read in an mmaped file. That
415 * way we can just use it like a variable, but it is
416 * persistent and automatically flushed at reboot. */
418 fd = open("/run/systemd/journal/kernel-seqnum", O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0644);
420 log_error("Failed to open /run/systemd/journal/kernel-seqnum, ignoring: %m");
424 if (posix_fallocate(fd, 0, sizeof(uint64_t)) < 0) {
425 log_error("Failed to allocate sequential number file, ignoring: %m");
426 close_nointr_nofail(fd);
430 p = mmap(NULL, sizeof(uint64_t), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
431 if (p == MAP_FAILED) {
432 log_error("Failed to map sequential number file, ignoring: %m");
433 close_nointr_nofail(fd);
437 close_nointr_nofail(fd);
438 s->kernel_seqnum = p;