[thirdparty/systemd.git] / src / journal / journald-kmsg.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2011 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <unistd.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/socket.h>

#include "systemd/sd-messages.h"
#include <libudev.h>

#include "journald-server.h"
#include "journald-kmsg.h"
#include "journald-syslog.h"

void server_forward_kmsg(
        Server *s,
        int priority,
        const char *identifier,
        const char *message,
        const struct ucred *ucred) {

        struct iovec iovec[5];
        char header_priority[6], header_pid[16];
        int n = 0;
        char *ident_buf = NULL;

        assert(s);
        assert(priority >= 0);
        assert(priority <= 999);
        assert(message);

        if (_unlikely_(LOG_PRI(priority) > s->max_level_kmsg))
                return;

        if (_unlikely_(s->dev_kmsg_fd < 0))
                return;

        /* Never allow messages with kernel facility to be written to
         * kmsg, regardless where the data comes from. */
        priority = syslog_fixup_facility(priority);

        /* First: priority field */
        snprintf(header_priority, sizeof(header_priority), "<%i>", priority);
        char_array_0(header_priority);
        IOVEC_SET_STRING(iovec[n++], header_priority);

        /* Second: identifier and PID */
        if (ucred) {
                if (!identifier) {
                        get_process_comm(ucred->pid, &ident_buf);
                        identifier = ident_buf;
                }

                snprintf(header_pid, sizeof(header_pid), "["PID_FMT"]: ", ucred->pid);
                char_array_0(header_pid);

                if (identifier)
                        IOVEC_SET_STRING(iovec[n++], identifier);

                IOVEC_SET_STRING(iovec[n++], header_pid);
        } else if (identifier) {
                IOVEC_SET_STRING(iovec[n++], identifier);
                IOVEC_SET_STRING(iovec[n++], ": ");
        }

        /* Fourth: message */
        IOVEC_SET_STRING(iovec[n++], message);
        IOVEC_SET_STRING(iovec[n++], "\n");

        if (writev(s->dev_kmsg_fd, iovec, n) < 0)
                log_debug_errno(errno, "Failed to write to /dev/kmsg for logging: %m");

        free(ident_buf);
}

static bool is_us(const char *pid) {
        pid_t t;

        assert(pid);

        if (parse_pid(pid, &t) < 0)
                return false;

        return t == getpid();
}

static void dev_kmsg_record(Server *s, const char *p, size_t l) {
        struct iovec iovec[N_IOVEC_META_FIELDS + 7 + N_IOVEC_KERNEL_FIELDS + 2 + N_IOVEC_UDEV_FIELDS];
        char *message = NULL, *syslog_priority = NULL, *syslog_pid = NULL, *syslog_facility = NULL, *syslog_identifier = NULL, *source_time = NULL;
        int priority, r;
        unsigned n = 0, z = 0, j;
        unsigned long long usec;
        char *identifier = NULL, *pid = NULL, *e, *f, *k;
        uint64_t serial;
        size_t pl;
        char *kernel_device = NULL;

        assert(s);
        assert(p);

        if (l <= 0)
                return;

        e = memchr(p, ',', l);
        if (!e)
                return;
        *e = 0;

        r = safe_atoi(p, &priority);
        if (r < 0 || priority < 0 || priority > 999)
                return;

        if (s->forward_to_kmsg && (priority & LOG_FACMASK) != LOG_KERN)
                return;

        l -= (e - p) + 1;
        p = e + 1;
        e = memchr(p, ',', l);
        if (!e)
                return;
        *e = 0;

        r = safe_atou64(p, &serial);
        if (r < 0)
                return;

        if (s->kernel_seqnum) {
                /* We already read this one? */
                if (serial < *s->kernel_seqnum)
                        return;

                /* Did we lose any? */
                if (serial > *s->kernel_seqnum)
                        server_driver_message(s, SD_MESSAGE_JOURNAL_MISSED, "Missed %"PRIu64" kernel messages",
                                              serial - *s->kernel_seqnum);

                /* Make sure we never read this one again. Note that
                 * we always store the next message serial we expect
                 * here, simply because this makes handling the first
                 * message with serial 0 easy. */
                *s->kernel_seqnum = serial + 1;
        }

        l -= (e - p) + 1;
        p = e + 1;
        f = memchr(p, ';', l);
        if (!f)
                return;
        /* Kernel 3.6 has the flags field, kernel 3.5 lacks that */
        e = memchr(p, ',', l);
        if (!e || f < e)
                e = f;
        *e = 0;

        r = safe_atollu(p, &usec);
        if (r < 0)
                return;

        l -= (f - p) + 1;
        p = f + 1;
        e = memchr(p, '\n', l);
        if (!e)
                return;
        *e = 0;

        pl = e - p;
        l -= (e - p) + 1;
        k = e + 1;

        for (j = 0; l > 0 && j < N_IOVEC_KERNEL_FIELDS; j++) {
                char *m;
                /* Meta data fields attached */

                if (*k != ' ')
                        break;

                k ++, l --;

                e = memchr(k, '\n', l);
                if (!e)
                        return;

                *e = 0;

                m = cunescape_length_with_prefix(k, e - k, "_KERNEL_");
                if (!m)
                        break;

                if (startswith(m, "_KERNEL_DEVICE="))
                        kernel_device = m + 15;

                IOVEC_SET_STRING(iovec[n++], m);
                z++;

                l -= (e - k) + 1;
                k = e + 1;
        }

        if (kernel_device) {
                struct udev_device *ud;

                ud = udev_device_new_from_device_id(s->udev, kernel_device);
                if (ud) {
                        const char *g;
                        struct udev_list_entry *ll;
                        char *b;

                        g = udev_device_get_devnode(ud);
                        if (g) {
                                b = strappend("_UDEV_DEVNODE=", g);
                                if (b) {
                                        IOVEC_SET_STRING(iovec[n++], b);
                                        z++;
                                }
                        }

                        g = udev_device_get_sysname(ud);
                        if (g) {
                                b = strappend("_UDEV_SYSNAME=", g);
                                if (b) {
                                        IOVEC_SET_STRING(iovec[n++], b);
                                        z++;
                                }
                        }

                        j = 0;
                        ll = udev_device_get_devlinks_list_entry(ud);
                        udev_list_entry_foreach(ll, ll) {

                                if (j > N_IOVEC_UDEV_FIELDS)
                                        break;

                                g = udev_list_entry_get_name(ll);
                                if (g) {
                                        b = strappend("_UDEV_DEVLINK=", g);
                                        if (b) {
                                                IOVEC_SET_STRING(iovec[n++], b);
                                                z++;
                                        }
                                }

                                j++;
                        }

                        udev_device_unref(ud);
                }
        }

        if (asprintf(&source_time, "_SOURCE_MONOTONIC_TIMESTAMP=%llu", usec) >= 0)
                IOVEC_SET_STRING(iovec[n++], source_time);

        IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=kernel");

        if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
                IOVEC_SET_STRING(iovec[n++], syslog_priority);

        if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
                IOVEC_SET_STRING(iovec[n++], syslog_facility);

        if ((priority & LOG_FACMASK) == LOG_KERN)
                IOVEC_SET_STRING(iovec[n++], "SYSLOG_IDENTIFIER=kernel");
        else {
                pl -= syslog_parse_identifier((const char**) &p, &identifier, &pid);

                /* Avoid any messages we generated ourselves via
                 * log_info() and friends. */
                if (pid && is_us(pid))
                        goto finish;

                if (identifier) {
                        syslog_identifier = strappend("SYSLOG_IDENTIFIER=", identifier);
                        if (syslog_identifier)
                                IOVEC_SET_STRING(iovec[n++], syslog_identifier);
                }

                if (pid) {
                        syslog_pid = strappend("SYSLOG_PID=", pid);
                        if (syslog_pid)
                                IOVEC_SET_STRING(iovec[n++], syslog_pid);
                }
        }

        message = cunescape_length_with_prefix(p, pl, "MESSAGE=");
        if (message)
                IOVEC_SET_STRING(iovec[n++], message);

        server_dispatch_message(s, iovec, n, ELEMENTSOF(iovec), NULL, NULL, NULL, 0, NULL, priority, 0);

finish:
        for (j = 0; j < z; j++)
                free(iovec[j].iov_base);

        free(message);
        free(syslog_priority);
        free(syslog_identifier);
        free(syslog_pid);
        free(syslog_facility);
        free(source_time);
        free(identifier);
        free(pid);
}

static int server_read_dev_kmsg(Server *s) {
        char buffer[8192+1]; /* the kernel-side limit per record is 8K currently */
        ssize_t l;

        assert(s);
        assert(s->dev_kmsg_fd >= 0);

        l = read(s->dev_kmsg_fd, buffer, sizeof(buffer) - 1);
        if (l == 0)
                return 0;
        if (l < 0) {
                /* Old kernels who don't allow reading from /dev/kmsg
                 * return EINVAL when we try. So handle this cleanly,
                 * but don' try to ever read from it again. */
                if (errno == EINVAL) {
                        s->dev_kmsg_event_source = sd_event_source_unref(s->dev_kmsg_event_source);
                        return 0;
                }

                if (errno == EAGAIN || errno == EINTR || errno == EPIPE)
                        return 0;

                log_error_errno(errno, "Failed to read from kernel: %m");
                return -errno;
        }

        dev_kmsg_record(s, buffer, l);
        return 1;
}

int server_flush_dev_kmsg(Server *s) {
        int r;

        assert(s);

        if (s->dev_kmsg_fd < 0)
                return 0;

        if (!s->dev_kmsg_readable)
                return 0;

        log_debug("Flushing /dev/kmsg...");

        for (;;) {
                r = server_read_dev_kmsg(s);
                if (r < 0)
                        return r;

                if (r == 0)
                        break;
        }

        return 0;
}

static int dispatch_dev_kmsg(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
        Server *s = userdata;

        assert(es);
        assert(fd == s->dev_kmsg_fd);
        assert(s);

        if (revents & EPOLLERR)
                log_warning("/dev/kmsg buffer overrun, some messages lost.");

        if (!(revents & EPOLLIN))
                log_error("Got invalid event from epoll for /dev/kmsg: %"PRIx32, revents);

        return server_read_dev_kmsg(s);
}

int server_open_dev_kmsg(Server *s) {
        int r;

        assert(s);

        s->dev_kmsg_fd = open("/dev/kmsg", O_RDWR|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);
        if (s->dev_kmsg_fd < 0) {
                log_full(errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
                         "Failed to open /dev/kmsg, ignoring: %m");
                return 0;
        }

        r = sd_event_add_io(s->event, &s->dev_kmsg_event_source, s->dev_kmsg_fd, EPOLLIN, dispatch_dev_kmsg, s);
        if (r < 0) {

                /* This will fail with EPERM on older kernels where
                 * /dev/kmsg is not readable. */
                if (r == -EPERM) {
                        r = 0;
                        goto fail;
                }

                log_error_errno(r, "Failed to add /dev/kmsg fd to event loop: %m");
                goto fail;
        }

        r = sd_event_source_set_priority(s->dev_kmsg_event_source, SD_EVENT_PRIORITY_IMPORTANT+10);
        if (r < 0) {
                log_error_errno(r, "Failed to adjust priority of kmsg event source: %m");
                goto fail;
        }

        s->dev_kmsg_readable = true;

        return 0;

fail:
        s->dev_kmsg_event_source = sd_event_source_unref(s->dev_kmsg_event_source);
        s->dev_kmsg_fd = safe_close(s->dev_kmsg_fd);

        return r;
}

int server_open_kernel_seqnum(Server *s) {
        _cleanup_close_ int fd;
        uint64_t *p;

        assert(s);

        /* We store the seqnum we last read in an mmaped file. That
         * way we can just use it like a variable, but it is
         * persistent and automatically flushed at reboot. */

        fd = open("/run/systemd/journal/kernel-seqnum", O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0644);
        if (fd < 0) {
                log_error_errno(errno, "Failed to open /run/systemd/journal/kernel-seqnum, ignoring: %m");
                return 0;
        }

        if (posix_fallocate(fd, 0, sizeof(uint64_t)) < 0) {
                log_error_errno(errno, "Failed to allocate sequential number file, ignoring: %m");
                return 0;
        }

        p = mmap(NULL, sizeof(uint64_t), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
        if (p == MAP_FAILED) {
                log_error_errno(errno, "Failed to map sequential number file, ignoring: %m");
                return 0;
        }

        s->kernel_seqnum = p;

        return 0;
}
Commit	Line	Data
ef63833d LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2011 Lennart Poettering
	7
	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.
	12
	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.
	17
	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/>.
	20	***/
	21
	22	#include <unistd.h>
	23	#include <sys/epoll.h>
	24	#include <fcntl.h>
	25	#include <sys/mman.h>
4871690d	26	#include <sys/socket.h>
ef63833d	27
73f860db	28	#include "systemd/sd-messages.h"
ef63833d LP	29	#include <libudev.h>
ef63833d LP	30
d025f1e4	31	#include "journald-server.h"
ef63833d	32	#include "journald-kmsg.h"
35e2e347	33	#include "journald-syslog.h"
ef63833d LP	34
	35	void server_forward_kmsg(
	36	Server *s,
	37	int priority,
	38	const char *identifier,
	39	const char *message,
3b3154df	40	const struct ucred *ucred) {
ef63833d LP	41
	42	struct iovec iovec[5];
	43	char header_priority[6], header_pid[16];
	44	int n = 0;
	45	char *ident_buf = NULL;
	46
	47	assert(s);
	48	assert(priority >= 0);
	49	assert(priority <= 999);
	50	assert(message);
	51
	52	if (_unlikely_(LOG_PRI(priority) > s->max_level_kmsg))
	53	return;
	54
	55	if (_unlikely_(s->dev_kmsg_fd < 0))
	56	return;
	57
	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);
	61
	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);
	66
	67	/* Second: identifier and PID */
	68	if (ucred) {
	69	if (!identifier) {
	70	get_process_comm(ucred->pid, &ident_buf);
	71	identifier = ident_buf;
	72	}
	73
de0671ee	74	snprintf(header_pid, sizeof(header_pid), "["PID_FMT"]: ", ucred->pid);
ef63833d LP	75	char_array_0(header_pid);
	76
	77	if (identifier)
	78	IOVEC_SET_STRING(iovec[n++], identifier);
	79
	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++], ": ");
	84	}
	85
	86	/* Fourth: message */
	87	IOVEC_SET_STRING(iovec[n++], message);
	88	IOVEC_SET_STRING(iovec[n++], "\n");
	89
	90	if (writev(s->dev_kmsg_fd, iovec, n) < 0)
56f64d95	91	log_debug_errno(errno, "Failed to write to /dev/kmsg for logging: %m");
ef63833d LP	92
	93	free(ident_buf);
	94	}
	95
	96	static bool is_us(const char *pid) {
	97	pid_t t;
	98
	99	assert(pid);
	100
	101	if (parse_pid(pid, &t) < 0)
	102	return false;
	103
	104	return t == getpid();
	105	}
	106
3b3154df	107	static void dev_kmsg_record(Server s, const char p, size_t l) {
ef63833d LP	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;
	110	int priority, r;
	111	unsigned n = 0, z = 0, j;
e9f600f2	112	unsigned long long usec;
ef63833d LP	113	char identifier = NULL, pid = NULL, e, f, *k;
	114	uint64_t serial;
	115	size_t pl;
	116	char *kernel_device = NULL;
	117
	118	assert(s);
	119	assert(p);
	120
	121	if (l <= 0)
	122	return;
	123
	124	e = memchr(p, ',', l);
	125	if (!e)
	126	return;
	127	*e = 0;
	128
	129	r = safe_atoi(p, &priority);
	130	if (r < 0 \|\| priority < 0 \|\| priority > 999)
	131	return;
	132
	133	if (s->forward_to_kmsg && (priority & LOG_FACMASK) != LOG_KERN)
	134	return;
	135
	136	l -= (e - p) + 1;
	137	p = e + 1;
	138	e = memchr(p, ',', l);
	139	if (!e)
	140	return;
	141	*e = 0;
	142
	143	r = safe_atou64(p, &serial);
	144	if (r < 0)
	145	return;
	146
	147	if (s->kernel_seqnum) {
	148	/* We already read this one? */
	149	if (serial < *s->kernel_seqnum)
	150	return;
	151
	152	/* Did we lose any? */
	153	if (serial > *s->kernel_seqnum)
507f22bd	154	server_driver_message(s, SD_MESSAGE_JOURNAL_MISSED, "Missed %"PRIu64" kernel messages",
b9c488f6	155	serial - *s->kernel_seqnum);
ef63833d LP	156
	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;
	162	}
	163
	164	l -= (e - p) + 1;
	165	p = e + 1;
	166	f = memchr(p, ';', l);
	167	if (!f)
	168	return;
	169	/* Kernel 3.6 has the flags field, kernel 3.5 lacks that */
	170	e = memchr(p, ',', l);
	171	if (!e \|\| f < e)
	172	e = f;
	173	*e = 0;
	174
e9f600f2	175	r = safe_atollu(p, &usec);
ef63833d LP	176	if (r < 0)
	177	return;
	178
	179	l -= (f - p) + 1;
	180	p = f + 1;
	181	e = memchr(p, '\n', l);
	182	if (!e)
	183	return;
	184	*e = 0;
	185
	186	pl = e - p;
	187	l -= (e - p) + 1;
	188	k = e + 1;
	189
	190	for (j = 0; l > 0 && j < N_IOVEC_KERNEL_FIELDS; j++) {
	191	char *m;
	192	/* Meta data fields attached */
	193
	194	if (*k != ' ')
	195	break;
	196
	197	k ++, l --;
	198
	199	e = memchr(k, '\n', l);
	200	if (!e)
	201	return;
	202
	203	*e = 0;
	204
	205	m = cunescape_length_with_prefix(k, e - k, "_KERNEL_");
	206	if (!m)
	207	break;
	208
	209	if (startswith(m, "_KERNEL_DEVICE="))
	210	kernel_device = m + 15;
	211
	212	IOVEC_SET_STRING(iovec[n++], m);
	213	z++;
	214
	215	l -= (e - k) + 1;
	216	k = e + 1;
	217	}
	218
	219	if (kernel_device) {
	220	struct udev_device *ud;
	221
	222	ud = udev_device_new_from_device_id(s->udev, kernel_device);
	223	if (ud) {
	224	const char *g;
	225	struct udev_list_entry *ll;
	226	char *b;
	227
	228	g = udev_device_get_devnode(ud);
	229	if (g) {
	230	b = strappend("_UDEV_DEVNODE=", g);
	231	if (b) {
	232	IOVEC_SET_STRING(iovec[n++], b);
	233	z++;
	234	}
	235	}
	236
	237	g = udev_device_get_sysname(ud);
	238	if (g) {
	239	b = strappend("_UDEV_SYSNAME=", g);
240	if (b) {
241	IOVEC_SET_STRING(iovec[n++], b);
242	z++;
243	}
244	}
245
246	j = 0;
247	ll = udev_device_get_devlinks_list_entry(ud);
248	udev_list_entry_foreach(ll, ll) {
249
250	if (j > N_IOVEC_UDEV_FIELDS)
251	break;
252
253	g = udev_list_entry_get_name(ll);
ef63833d	254	if (g) {
4b94f3b8 ZJS	255	b = strappend("_UDEV_DEVLINK=", g);
	256	if (b) {
	257	IOVEC_SET_STRING(iovec[n++], b);
	258	z++;
	259	}
ef63833d LP	260	}
	261
	262	j++;
	263	}
	264
	265	udev_device_unref(ud);
	266	}
	267	}
	268
e9f600f2	269	if (asprintf(&source_time, "_SOURCE_MONOTONIC_TIMESTAMP=%llu", usec) >= 0)
ef63833d LP	270	IOVEC_SET_STRING(iovec[n++], source_time);
	271
	272	IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=kernel");
	273
	274	if (asprintf(&syslog_priority, "PRIORITY=%i", priority & LOG_PRIMASK) >= 0)
	275	IOVEC_SET_STRING(iovec[n++], syslog_priority);
	276
36dd072c MS	277	if (asprintf(&syslog_facility, "SYSLOG_FACILITY=%i", LOG_FAC(priority)) >= 0)
	278	IOVEC_SET_STRING(iovec[n++], syslog_facility);
	279
ef63833d LP	280	if ((priority & LOG_FACMASK) == LOG_KERN)
	281	IOVEC_SET_STRING(iovec[n++], "SYSLOG_IDENTIFIER=kernel");
	282	else {
e88baee8	283	pl -= syslog_parse_identifier((const char**) &p, &identifier, &pid);
ef63833d LP	284
	285	/* Avoid any messages we generated ourselves via
	286	* log_info() and friends. */
	287	if (pid && is_us(pid))
	288	goto finish;
	289
	290	if (identifier) {
	291	syslog_identifier = strappend("SYSLOG_IDENTIFIER=", identifier);
	292	if (syslog_identifier)
	293	IOVEC_SET_STRING(iovec[n++], syslog_identifier);
	294	}
	295
	296	if (pid) {
	297	syslog_pid = strappend("SYSLOG_PID=", pid);
	298	if (syslog_pid)
	299	IOVEC_SET_STRING(iovec[n++], syslog_pid);
	300	}
ef63833d LP	301	}
	302
	303	message = cunescape_length_with_prefix(p, pl, "MESSAGE=");
	304	if (message)
	305	IOVEC_SET_STRING(iovec[n++], message);
	306
968f3196	307	server_dispatch_message(s, iovec, n, ELEMENTSOF(iovec), NULL, NULL, NULL, 0, NULL, priority, 0);
ef63833d LP	308
	309	finish:
	310	for (j = 0; j < z; j++)
	311	free(iovec[j].iov_base);
	312
	313	free(message);
	314	free(syslog_priority);
	315	free(syslog_identifier);
	316	free(syslog_pid);
	317	free(syslog_facility);
	318	free(source_time);
	319	free(identifier);
	320	free(pid);
	321	}
	322
f9a810be	323	static int server_read_dev_kmsg(Server *s) {
ef63833d LP	324	char buffer[8192+1]; /* the kernel-side limit per record is 8K currently */
	325	ssize_t l;
	326
	327	assert(s);
	328	assert(s->dev_kmsg_fd >= 0);
	329
	330	l = read(s->dev_kmsg_fd, buffer, sizeof(buffer) - 1);
	331	if (l == 0)
	332	return 0;
	333	if (l < 0) {
	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) {
f9a810be	338	s->dev_kmsg_event_source = sd_event_source_unref(s->dev_kmsg_event_source);
ef63833d LP	339	return 0;
	340	}
	341
	342	if (errno == EAGAIN \|\| errno == EINTR \|\| errno == EPIPE)
	343	return 0;
	344
56f64d95	345	log_error_errno(errno, "Failed to read from kernel: %m");
ef63833d LP	346	return -errno;
	347	}
	348
	349	dev_kmsg_record(s, buffer, l);
	350	return 1;
	351	}
	352
	353	int server_flush_dev_kmsg(Server *s) {
	354	int r;
	355
	356	assert(s);
	357
	358	if (s->dev_kmsg_fd < 0)
	359	return 0;
	360
	361	if (!s->dev_kmsg_readable)
	362	return 0;
	363
2b43f939	364	log_debug("Flushing /dev/kmsg...");
ef63833d LP	365
	366	for (;;) {
	367	r = server_read_dev_kmsg(s);
	368	if (r < 0)
	369	return r;
	370
	371	if (r == 0)
	372	break;
	373	}
	374
	375	return 0;
	376	}
	377
f9a810be LP	378	static int dispatch_dev_kmsg(sd_event_source es, int fd, uint32_t revents, void userdata) {
	379	Server *s = userdata;
	380
	381	assert(es);
	382	assert(fd == s->dev_kmsg_fd);
	383	assert(s);
	384
	385	if (revents & EPOLLERR)
	386	log_warning("/dev/kmsg buffer overrun, some messages lost.");
	387
	388	if (!(revents & EPOLLIN))
	389	log_error("Got invalid event from epoll for /dev/kmsg: %"PRIx32, revents);
	390
	391	return server_read_dev_kmsg(s);
	392	}
	393
ef63833d	394	int server_open_dev_kmsg(Server *s) {
f9a810be	395	int r;
ef63833d LP	396
	397	assert(s);
	398
	399	s->dev_kmsg_fd = open("/dev/kmsg", O_RDWR\|O_CLOEXEC\|O_NONBLOCK\|O_NOCTTY);
	400	if (s->dev_kmsg_fd < 0) {
445ea9be LP	401	log_full(errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
445ea9be LP	402	"Failed to open /dev/kmsg, ignoring: %m");
ef63833d LP	403	return 0;
	404	}
	405
151b9b96	406	r = sd_event_add_io(s->event, &s->dev_kmsg_event_source, s->dev_kmsg_fd, EPOLLIN, dispatch_dev_kmsg, s);
f9a810be	407	if (r < 0) {
ef63833d LP	408
	409	/* This will fail with EPERM on older kernels where
	410	* /dev/kmsg is not readable. */
c0f71f46 LP	411	if (r == -EPERM) {
	412	r = 0;
	413	goto fail;
	414	}
ef63833d	415
da927ba9	416	log_error_errno(r, "Failed to add /dev/kmsg fd to event loop: %m");
c0f71f46	417	goto fail;
f9a810be LP	418	}
	419
	420	r = sd_event_source_set_priority(s->dev_kmsg_event_source, SD_EVENT_PRIORITY_IMPORTANT+10);
	421	if (r < 0) {
da927ba9	422	log_error_errno(r, "Failed to adjust priority of kmsg event source: %m");
c0f71f46	423	goto fail;
ef63833d LP	424	}
	425
	426	s->dev_kmsg_readable = true;
	427
	428	return 0;
c0f71f46 LP	429
c0f71f46 LP	430	fail:
03e334a1 LP	431	s->dev_kmsg_event_source = sd_event_source_unref(s->dev_kmsg_event_source);
03e334a1 LP	432	s->dev_kmsg_fd = safe_close(s->dev_kmsg_fd);
c0f71f46 LP	433
c0f71f46 LP	434	return r;
ef63833d LP	435	}
	436
	437	int server_open_kernel_seqnum(Server *s) {
03e334a1	438	_cleanup_close_ int fd;
ef63833d LP	439	uint64_t *p;
	440
	441	assert(s);
	442
	443	/* We store the seqnum we last read in an mmaped file. That
	444	* way we can just use it like a variable, but it is
b2e6df73	445	* persistent and automatically flushed at reboot. */
ef63833d LP	446
	447	fd = open("/run/systemd/journal/kernel-seqnum", O_RDWR\|O_CREAT\|O_CLOEXEC\|O_NOCTTY\|O_NOFOLLOW, 0644);
	448	if (fd < 0) {
56f64d95	449	log_error_errno(errno, "Failed to open /run/systemd/journal/kernel-seqnum, ignoring: %m");
ef63833d LP	450	return 0;
	451	}
	452
	453	if (posix_fallocate(fd, 0, sizeof(uint64_t)) < 0) {
56f64d95	454	log_error_errno(errno, "Failed to allocate sequential number file, ignoring: %m");
ef63833d LP	455	return 0;
	456	}
	457
	458	p = mmap(NULL, sizeof(uint64_t), PROT_READ\|PROT_WRITE, MAP_SHARED, fd, 0);
	459	if (p == MAP_FAILED) {
56f64d95	460	log_error_errno(errno, "Failed to map sequential number file, ignoring: %m");
ef63833d LP	461	return 0;
	462	}
	463
ef63833d LP	464	s->kernel_seqnum = p;
	465
	466	return 0;
	467	}