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>
27 #include <systemd/sd-messages.h>
31 #include "journald-kmsg.h"
32 #include "journald-syslog.h"
34 void server_forward_kmsg(
37 const char *identifier,
39 struct ucred *ucred) {
41 struct iovec iovec[5];
42 char header_priority[6], header_pid[16];
44 char *ident_buf = NULL;
47 assert(priority >= 0);
48 assert(priority <= 999);
51 if (_unlikely_(LOG_PRI(priority) > s->max_level_kmsg))
54 if (_unlikely_(s->dev_kmsg_fd < 0))
57 /* Never allow messages with kernel facility to be written to
58 * kmsg, regardless where the data comes from. */
59 priority = syslog_fixup_facility(priority);
61 /* First: priority field */
62 snprintf(header_priority, sizeof(header_priority), "<%i>", priority);
63 char_array_0(header_priority);
64 IOVEC_SET_STRING(iovec[n++], header_priority);
66 /* Second: identifier and PID */
69 get_process_comm(ucred->pid, &ident_buf);
70 identifier = ident_buf;
73 snprintf(header_pid, sizeof(header_pid), "[%lu]: ", (unsigned long) ucred->pid);
74 char_array_0(header_pid);
77 IOVEC_SET_STRING(iovec[n++], identifier);
79 IOVEC_SET_STRING(iovec[n++], header_pid);
80 } else if (identifier) {
81 IOVEC_SET_STRING(iovec[n++], identifier);
82 IOVEC_SET_STRING(iovec[n++], ": ");
86 IOVEC_SET_STRING(iovec[n++], message);
87 IOVEC_SET_STRING(iovec[n++], "\n");
89 if (writev(s->dev_kmsg_fd, iovec, n) < 0)
90 log_debug("Failed to write to /dev/kmsg for logging: %s", strerror(errno));
95 static bool is_us(const char *pid) {
100 if (parse_pid(pid, &t) < 0)
103 return t == getpid();
106 static void dev_kmsg_record(Server *s, char *p, size_t l) {
107 struct iovec iovec[N_IOVEC_META_FIELDS + 7 + N_IOVEC_KERNEL_FIELDS + 2 + N_IOVEC_UDEV_FIELDS];
108 char *message = NULL, *syslog_priority = NULL, *syslog_pid = NULL, *syslog_facility = NULL, *syslog_identifier = NULL, *source_time = NULL;
110 unsigned n = 0, z = 0, j;
112 char *identifier = NULL, *pid = NULL, *e, *f, *k;
115 char *kernel_device = NULL;
123 e = memchr(p, ',', l);
128 r = safe_atoi(p, &priority);
129 if (r < 0 || priority < 0 || priority > 999)
132 if (s->forward_to_kmsg && (priority & LOG_FACMASK) != LOG_KERN)
137 e = memchr(p, ',', l);
142 r = safe_atou64(p, &serial);
146 if (s->kernel_seqnum) {
147 /* We already read this one? */
148 if (serial < *s->kernel_seqnum)
151 /* Did we lose any? */
152 if (serial > *s->kernel_seqnum)
153 server_driver_message(s, SD_MESSAGE_JOURNAL_MISSED, "Missed %llu kernel messages", (unsigned long long) serial - *s->kernel_seqnum - 1);
155 /* Make sure we never read this one again. Note that
156 * we always store the next message serial we expect
157 * here, simply because this makes handling the first
158 * message with serial 0 easy. */
159 *s->kernel_seqnum = serial + 1;
164 f = memchr(p, ';', l);
167 /* Kernel 3.6 has the flags field, kernel 3.5 lacks that */
168 e = memchr(p, ',', l);
173 r = parse_usec(p, &usec);
179 e = memchr(p, '\n', l);
188 for (j = 0; l > 0 && j < N_IOVEC_KERNEL_FIELDS; j++) {
190 /* Meta data fields attached */
197 e = memchr(k, '\n', l);
203 m = cunescape_length_with_prefix(k, e - k, "_KERNEL_");
207 if (startswith(m, "_KERNEL_DEVICE="))
208 kernel_device = m + 15;
210 IOVEC_SET_STRING(iovec[n++], m);
218 struct udev_device *ud;
220 ud = udev_device_new_from_device_id(s->udev, kernel_device);
223 struct udev_list_entry *ll;
226 g = udev_device_get_devnode(ud);
228 b = strappend("_UDEV_DEVNODE=", g);
230 IOVEC_SET_STRING(iovec[n++], b);
235 g = udev_device_get_sysname(ud);
237 b = strappend("_UDEV_SYSNAME=", g);
239 IOVEC_SET_STRING(iovec[n++], b);
245 ll = udev_device_get_devlinks_list_entry(ud);
246 udev_list_entry_foreach(ll, ll) {
248 if (j > N_IOVEC_UDEV_FIELDS)
251 g = udev_list_entry_get_name(ll);
252 b = strappend("_UDEV_DEVLINK=", g);
254 IOVEC_SET_STRING(iovec[n++], b);
261 udev_device_unref(ud);
265 if (asprintf(&source_time, "_SOURCE_MONOTONIC_TIMESTAMP=%llu",
266 (unsigned long long) usec) >= 0)
267 IOVEC_SET_STRING(iovec[n++], source_time);
269 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=kernel");
271 if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
272 IOVEC_SET_STRING(iovec[n++], syslog_priority);
274 if ((priority & LOG_FACMASK) == LOG_KERN)
275 IOVEC_SET_STRING(iovec[n++], "SYSLOG_IDENTIFIER=kernel");
277 syslog_read_identifier((const char**) &p, &identifier, &pid);
279 /* Avoid any messages we generated ourselves via
280 * log_info() and friends. */
281 if (pid && is_us(pid))
285 syslog_identifier = strappend("SYSLOG_IDENTIFIER=", identifier);
286 if (syslog_identifier)
287 IOVEC_SET_STRING(iovec[n++], syslog_identifier);
291 syslog_pid = strappend("SYSLOG_PID=", pid);
293 IOVEC_SET_STRING(iovec[n++], syslog_pid);
296 if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
297 IOVEC_SET_STRING(iovec[n++], syslog_facility);
300 message = cunescape_length_with_prefix(p, pl, "MESSAGE=");
302 IOVEC_SET_STRING(iovec[n++], message);
304 server_dispatch_message(s, iovec, n, ELEMENTSOF(iovec), NULL, NULL, NULL, 0, NULL, priority);
307 for (j = 0; j < z; j++)
308 free(iovec[j].iov_base);
311 free(syslog_priority);
312 free(syslog_identifier);
314 free(syslog_facility);
320 int server_read_dev_kmsg(Server *s) {
321 char buffer[8192+1]; /* the kernel-side limit per record is 8K currently */
325 assert(s->dev_kmsg_fd >= 0);
327 l = read(s->dev_kmsg_fd, buffer, sizeof(buffer) - 1);
331 /* Old kernels who don't allow reading from /dev/kmsg
332 * return EINVAL when we try. So handle this cleanly,
333 * but don' try to ever read from it again. */
334 if (errno == EINVAL) {
335 epoll_ctl(s->epoll_fd, EPOLL_CTL_DEL, s->dev_kmsg_fd, NULL);
339 if (errno == EAGAIN || errno == EINTR || errno == EPIPE)
342 log_error("Failed to read from kernel: %m");
346 dev_kmsg_record(s, buffer, l);
350 int server_flush_dev_kmsg(Server *s) {
355 if (s->dev_kmsg_fd < 0)
358 if (!s->dev_kmsg_readable)
361 log_info("Flushing /dev/kmsg...");
364 r = server_read_dev_kmsg(s);
375 int server_open_dev_kmsg(Server *s) {
376 struct epoll_event ev;
380 s->dev_kmsg_fd = open("/dev/kmsg", O_RDWR|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);
381 if (s->dev_kmsg_fd < 0) {
382 log_warning("Failed to open /dev/kmsg, ignoring: %m");
388 ev.data.fd = s->dev_kmsg_fd;
389 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->dev_kmsg_fd, &ev) < 0) {
391 /* This will fail with EPERM on older kernels where
392 * /dev/kmsg is not readable. */
396 log_error("Failed to add /dev/kmsg fd to epoll object: %m");
400 s->dev_kmsg_readable = true;
405 int server_open_kernel_seqnum(Server *s) {
411 /* We store the seqnum we last read in an mmaped file. That
412 * way we can just use it like a variable, but it is
413 * persistant and automatically flushed at reboot. */
415 fd = open("/run/systemd/journal/kernel-seqnum", O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0644);
417 log_error("Failed to open /run/systemd/journal/kernel-seqnum, ignoring: %m");
421 if (posix_fallocate(fd, 0, sizeof(uint64_t)) < 0) {
422 log_error("Failed to allocate sequential number file, ignoring: %m");
423 close_nointr_nofail(fd);
427 p = mmap(NULL, sizeof(uint64_t), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
428 if (p == MAP_FAILED) {
429 log_error("Failed to map sequential number file, ignoring: %m");
430 close_nointr_nofail(fd);
434 close_nointr_nofail(fd);
435 s->kernel_seqnum = p;