]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/journal/journald-server.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
journalctl: print monotonic timestamp in --header
[thirdparty/systemd.git] / src / journal / journald-server.c
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 <sys/signalfd.h>
23 #include <sys/ioctl.h>
24 #include <linux/sockios.h>
25 #include <sys/statvfs.h>
26 #include <sys/mman.h>
27 #include <sys/timerfd.h>
28
29 #include <libudev.h>
30 #include <systemd/sd-journal.h>
31 #include <systemd/sd-messages.h>
32 #include <systemd/sd-daemon.h>
33
34 #include "fileio.h"
35 #include "mkdir.h"
36 #include "hashmap.h"
37 #include "journal-file.h"
38 #include "socket-util.h"
39 #include "cgroup-util.h"
40 #include "list.h"
41 #include "virt.h"
42 #include "missing.h"
43 #include "conf-parser.h"
44 #include "journal-internal.h"
45 #include "journal-vacuum.h"
46 #include "journal-authenticate.h"
47 #include "journald-server.h"
48 #include "journald-rate-limit.h"
49 #include "journald-kmsg.h"
50 #include "journald-syslog.h"
51 #include "journald-stream.h"
52 #include "journald-console.h"
53 #include "journald-native.h"
54
55 #ifdef HAVE_ACL
56 #include <sys/acl.h>
57 #include <acl/libacl.h>
58 #include "acl-util.h"
59 #endif
60
61 #ifdef HAVE_SELINUX
62 #include <selinux/selinux.h>
63 #endif
64
65 #define USER_JOURNALS_MAX 1024
66
67 #define DEFAULT_SYNC_INTERVAL_USEC (5*USEC_PER_MINUTE)
68 #define DEFAULT_RATE_LIMIT_INTERVAL (10*USEC_PER_SEC)
69 #define DEFAULT_RATE_LIMIT_BURST 200
70
71 #define RECHECK_AVAILABLE_SPACE_USEC (30*USEC_PER_SEC)
72
73 static const char* const storage_table[] = {
74 [STORAGE_AUTO] = "auto",
75 [STORAGE_VOLATILE] = "volatile",
76 [STORAGE_PERSISTENT] = "persistent",
77 [STORAGE_NONE] = "none"
78 };
79
80 DEFINE_STRING_TABLE_LOOKUP(storage, Storage);
81 DEFINE_CONFIG_PARSE_ENUM(config_parse_storage, storage, Storage, "Failed to parse storage setting");
82
83 static const char* const split_mode_table[] = {
84 [SPLIT_NONE] = "none",
85 [SPLIT_UID] = "uid",
86 [SPLIT_LOGIN] = "login"
87 };
88
89 DEFINE_STRING_TABLE_LOOKUP(split_mode, SplitMode);
90 DEFINE_CONFIG_PARSE_ENUM(config_parse_split_mode, split_mode, SplitMode, "Failed to parse split mode setting");
91
92 static uint64_t available_space(Server *s) {
93 char ids[33];
94 _cleanup_free_ char *p = NULL;
95 const char *f;
96 sd_id128_t machine;
97 struct statvfs ss;
98 uint64_t sum = 0, avail = 0, ss_avail = 0;
99 int r;
100 _cleanup_closedir_ DIR *d = NULL;
101 usec_t ts;
102 JournalMetrics *m;
103
104 ts = now(CLOCK_MONOTONIC);
105
106 if (s->cached_available_space_timestamp + RECHECK_AVAILABLE_SPACE_USEC > ts)
107 return s->cached_available_space;
108
109 r = sd_id128_get_machine(&machine);
110 if (r < 0)
111 return 0;
112
113 if (s->system_journal) {
114 f = "/var/log/journal/";
115 m = &s->system_metrics;
116 } else {
117 f = "/run/log/journal/";
118 m = &s->runtime_metrics;
119 }
120
121 assert(m);
122
123 p = strappend(f, sd_id128_to_string(machine, ids));
124 if (!p)
125 return 0;
126
127 d = opendir(p);
128 if (!d)
129 return 0;
130
131 if (fstatvfs(dirfd(d), &ss) < 0)
132 return 0;
133
134 for (;;) {
135 struct stat st;
136 struct dirent *de;
137 union dirent_storage buf;
138
139 r = readdir_r(d, &buf.de, &de);
140 if (r != 0)
141 break;
142
143 if (!de)
144 break;
145
146 if (!endswith(de->d_name, ".journal") &&
147 !endswith(de->d_name, ".journal~"))
148 continue;
149
150 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
151 continue;
152
153 if (!S_ISREG(st.st_mode))
154 continue;
155
156 sum += (uint64_t) st.st_blocks * 512UL;
157 }
158
159 avail = sum >= m->max_use ? 0 : m->max_use - sum;
160
161 ss_avail = ss.f_bsize * ss.f_bavail;
162
163 ss_avail = ss_avail < m->keep_free ? 0 : ss_avail - m->keep_free;
164
165 if (ss_avail < avail)
166 avail = ss_avail;
167
168 s->cached_available_space = avail;
169 s->cached_available_space_timestamp = ts;
170
171 return avail;
172 }
173
174 static void server_read_file_gid(Server *s) {
175 const char *g = "systemd-journal";
176 int r;
177
178 assert(s);
179
180 if (s->file_gid_valid)
181 return;
182
183 r = get_group_creds(&g, &s->file_gid);
184 if (r < 0)
185 log_warning("Failed to resolve '%s' group: %s", g, strerror(-r));
186
187 /* if we couldn't read the gid, then it will be 0, but that's
188 * fine and we shouldn't try to resolve the group again, so
189 * let's just pretend it worked right-away. */
190 s->file_gid_valid = true;
191 }
192
193 void server_fix_perms(Server *s, JournalFile *f, uid_t uid) {
194 int r;
195 #ifdef HAVE_ACL
196 acl_t acl;
197 acl_entry_t entry;
198 acl_permset_t permset;
199 #endif
200
201 assert(f);
202
203 server_read_file_gid(s);
204
205 r = fchmod_and_fchown(f->fd, 0640, 0, s->file_gid);
206 if (r < 0)
207 log_warning("Failed to fix access mode/rights on %s, ignoring: %s", f->path, strerror(-r));
208
209 #ifdef HAVE_ACL
210 if (uid <= 0)
211 return;
212
213 acl = acl_get_fd(f->fd);
214 if (!acl) {
215 log_warning("Failed to read ACL on %s, ignoring: %m", f->path);
216 return;
217 }
218
219 r = acl_find_uid(acl, uid, &entry);
220 if (r <= 0) {
221
222 if (acl_create_entry(&acl, &entry) < 0 ||
223 acl_set_tag_type(entry, ACL_USER) < 0 ||
224 acl_set_qualifier(entry, &uid) < 0) {
225 log_warning("Failed to patch ACL on %s, ignoring: %m", f->path);
226 goto finish;
227 }
228 }
229
230 /* We do not recalculate the mask unconditionally here,
231 * so that the fchmod() mask above stays intact. */
232 if (acl_get_permset(entry, &permset) < 0 ||
233 acl_add_perm(permset, ACL_READ) < 0 ||
234 calc_acl_mask_if_needed(&acl) < 0) {
235 log_warning("Failed to patch ACL on %s, ignoring: %m", f->path);
236 goto finish;
237 }
238
239 if (acl_set_fd(f->fd, acl) < 0)
240 log_warning("Failed to set ACL on %s, ignoring: %m", f->path);
241
242 finish:
243 acl_free(acl);
244 #endif
245 }
246
247 static JournalFile* find_journal(Server *s, uid_t uid) {
248 _cleanup_free_ char *p = NULL;
249 int r;
250 JournalFile *f;
251 sd_id128_t machine;
252
253 assert(s);
254
255 /* We split up user logs only on /var, not on /run. If the
256 * runtime file is open, we write to it exclusively, in order
257 * to guarantee proper order as soon as we flush /run to
258 * /var and close the runtime file. */
259
260 if (s->runtime_journal)
261 return s->runtime_journal;
262
263 if (uid <= 0)
264 return s->system_journal;
265
266 r = sd_id128_get_machine(&machine);
267 if (r < 0)
268 return s->system_journal;
269
270 f = hashmap_get(s->user_journals, UINT32_TO_PTR(uid));
271 if (f)
272 return f;
273
274 if (asprintf(&p, "/var/log/journal/" SD_ID128_FORMAT_STR "/user-%lu.journal",
275 SD_ID128_FORMAT_VAL(machine), (unsigned long) uid) < 0)
276 return s->system_journal;
277
278 while (hashmap_size(s->user_journals) >= USER_JOURNALS_MAX) {
279 /* Too many open? Then let's close one */
280 f = hashmap_steal_first(s->user_journals);
281 assert(f);
282 journal_file_close(f);
283 }
284
285 r = journal_file_open_reliably(p, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, s->system_journal, &f);
286 if (r < 0)
287 return s->system_journal;
288
289 server_fix_perms(s, f, uid);
290
291 r = hashmap_put(s->user_journals, UINT32_TO_PTR(uid), f);
292 if (r < 0) {
293 journal_file_close(f);
294 return s->system_journal;
295 }
296
297 return f;
298 }
299
300 void server_rotate(Server *s) {
301 JournalFile *f;
302 void *k;
303 Iterator i;
304 int r;
305
306 log_debug("Rotating...");
307
308 if (s->runtime_journal) {
309 r = journal_file_rotate(&s->runtime_journal, s->compress, false);
310 if (r < 0)
311 if (s->runtime_journal)
312 log_error("Failed to rotate %s: %s", s->runtime_journal->path, strerror(-r));
313 else
314 log_error("Failed to create new runtime journal: %s", strerror(-r));
315 else
316 server_fix_perms(s, s->runtime_journal, 0);
317 }
318
319 if (s->system_journal) {
320 r = journal_file_rotate(&s->system_journal, s->compress, s->seal);
321 if (r < 0)
322 if (s->system_journal)
323 log_error("Failed to rotate %s: %s", s->system_journal->path, strerror(-r));
324 else
325 log_error("Failed to create new system journal: %s", strerror(-r));
326
327 else
328 server_fix_perms(s, s->system_journal, 0);
329 }
330
331 HASHMAP_FOREACH_KEY(f, k, s->user_journals, i) {
332 r = journal_file_rotate(&f, s->compress, s->seal);
333 if (r < 0)
334 if (f)
335 log_error("Failed to rotate %s: %s", f->path, strerror(-r));
336 else
337 log_error("Failed to create user journal: %s", strerror(-r));
338 else {
339 hashmap_replace(s->user_journals, k, f);
340 server_fix_perms(s, f, PTR_TO_UINT32(k));
341 }
342 }
343 }
344
345 void server_sync(Server *s) {
346 JournalFile *f;
347 void *k;
348 Iterator i;
349 int r;
350
351 static const struct itimerspec sync_timer_disable = {};
352
353 if (s->system_journal) {
354 r = journal_file_set_offline(s->system_journal);
355 if (r < 0)
356 log_error("Failed to sync system journal: %s", strerror(-r));
357 }
358
359 HASHMAP_FOREACH_KEY(f, k, s->user_journals, i) {
360 r = journal_file_set_offline(f);
361 if (r < 0)
362 log_error("Failed to sync user journal: %s", strerror(-r));
363 }
364
365 r = timerfd_settime(s->sync_timer_fd, 0, &sync_timer_disable, NULL);
366 if (r < 0)
367 log_error("Failed to disable max timer: %m");
368
369 s->sync_scheduled = false;
370 }
371
372 void server_vacuum(Server *s) {
373 char ids[33];
374 sd_id128_t machine;
375 int r;
376
377 log_debug("Vacuuming...");
378
379 s->oldest_file_usec = 0;
380
381 r = sd_id128_get_machine(&machine);
382 if (r < 0) {
383 log_error("Failed to get machine ID: %s", strerror(-r));
384 return;
385 }
386
387 sd_id128_to_string(machine, ids);
388
389 if (s->system_journal) {
390 char *p = strappenda("/var/log/journal/", ids);
391
392 r = journal_directory_vacuum(p, s->system_metrics.max_use, s->system_metrics.keep_free, s->max_retention_usec, &s->oldest_file_usec);
393 if (r < 0 && r != -ENOENT)
394 log_error("Failed to vacuum %s: %s", p, strerror(-r));
395 }
396
397 if (s->runtime_journal) {
398 char *p = strappenda("/run/log/journal/", ids);
399
400 r = journal_directory_vacuum(p, s->runtime_metrics.max_use, s->runtime_metrics.keep_free, s->max_retention_usec, &s->oldest_file_usec);
401 if (r < 0 && r != -ENOENT)
402 log_error("Failed to vacuum %s: %s", p, strerror(-r));
403 }
404
405 s->cached_available_space_timestamp = 0;
406 }
407
408 bool shall_try_append_again(JournalFile *f, int r) {
409
410 /* -E2BIG Hit configured limit
411 -EFBIG Hit fs limit
412 -EDQUOT Quota limit hit
413 -ENOSPC Disk full
414 -EHOSTDOWN Other machine
415 -EBUSY Unclean shutdown
416 -EPROTONOSUPPORT Unsupported feature
417 -EBADMSG Corrupted
418 -ENODATA Truncated
419 -ESHUTDOWN Already archived */
420
421 if (r == -E2BIG || r == -EFBIG || r == -EDQUOT || r == -ENOSPC)
422 log_debug("%s: Allocation limit reached, rotating.", f->path);
423 else if (r == -EHOSTDOWN)
424 log_info("%s: Journal file from other machine, rotating.", f->path);
425 else if (r == -EBUSY)
426 log_info("%s: Unclean shutdown, rotating.", f->path);
427 else if (r == -EPROTONOSUPPORT)
428 log_info("%s: Unsupported feature, rotating.", f->path);
429 else if (r == -EBADMSG || r == -ENODATA || r == ESHUTDOWN)
430 log_warning("%s: Journal file corrupted, rotating.", f->path);
431 else
432 return false;
433
434 return true;
435 }
436
437 static void write_to_journal(Server *s, uid_t uid, struct iovec *iovec, unsigned n) {
438 JournalFile *f;
439 bool vacuumed = false;
440 int r;
441
442 assert(s);
443 assert(iovec);
444 assert(n > 0);
445
446 f = find_journal(s, uid);
447 if (!f)
448 return;
449
450 if (journal_file_rotate_suggested(f, s->max_file_usec)) {
451 log_debug("%s: Journal header limits reached or header out-of-date, rotating.", f->path);
452 server_rotate(s);
453 server_vacuum(s);
454 vacuumed = true;
455
456 f = find_journal(s, uid);
457 if (!f)
458 return;
459 }
460
461 r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL);
462 if (r >= 0) {
463 server_schedule_sync(s);
464 return;
465 }
466
467 if (vacuumed || !shall_try_append_again(f, r)) {
468 log_error("Failed to write entry, ignoring: %s", strerror(-r));
469 return;
470 }
471
472 server_rotate(s);
473 server_vacuum(s);
474
475 f = find_journal(s, uid);
476 if (!f)
477 return;
478
479 log_debug("Retrying write.");
480 r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL);
481 if (r < 0)
482 log_error("Failed to write entry, ignoring: %s", strerror(-r));
483 }
484
485 static void dispatch_message_real(
486 Server *s,
487 struct iovec *iovec, unsigned n, unsigned m,
488 struct ucred *ucred,
489 struct timeval *tv,
490 const char *label, size_t label_len,
491 const char *unit_id) {
492
493 char pid[sizeof("_PID=") + DECIMAL_STR_MAX(pid_t)],
494 uid[sizeof("_UID=") + DECIMAL_STR_MAX(uid_t)],
495 gid[sizeof("_GID=") + DECIMAL_STR_MAX(gid_t)],
496 owner_uid[sizeof("_SYSTEMD_OWNER_UID=") + DECIMAL_STR_MAX(uid_t)],
497 source_time[sizeof("_SOURCE_REALTIME_TIMESTAMP=") + DECIMAL_STR_MAX(usec_t)],
498 boot_id[sizeof("_BOOT_ID=") + 32] = "_BOOT_ID=",
499 machine_id[sizeof("_MACHINE_ID=") + 32] = "_MACHINE_ID=";
500 char *comm, *exe, *cmdline, *cgroup, *session, *unit, *hostname;
501 sd_id128_t id;
502 int r;
503 char *t, *c;
504 uid_t realuid = 0, owner = 0, journal_uid;
505 bool owner_valid = false;
506 #ifdef HAVE_AUDIT
507 char audit_session[sizeof("_AUDIT_SESSION=") + DECIMAL_STR_MAX(uint32_t)],
508 audit_loginuid[sizeof("_AUDIT_LOGINUID=") + DECIMAL_STR_MAX(uid_t)];
509
510 uint32_t audit;
511 uid_t loginuid;
512 #endif
513
514 assert(s);
515 assert(iovec);
516 assert(n > 0);
517 assert(n + N_IOVEC_META_FIELDS <= m);
518
519 if (ucred) {
520 realuid = ucred->uid;
521
522 sprintf(pid, "_PID=%lu", (unsigned long) ucred->pid);
523 IOVEC_SET_STRING(iovec[n++], pid);
524
525 sprintf(uid, "_UID=%lu", (unsigned long) ucred->uid);
526 IOVEC_SET_STRING(iovec[n++], uid);
527
528 sprintf(gid, "_GID=%lu", (unsigned long) ucred->gid);
529 IOVEC_SET_STRING(iovec[n++], gid);
530
531 r = get_process_comm(ucred->pid, &t);
532 if (r >= 0) {
533 comm = strappenda("_COMM=", t);
534 free(t);
535 IOVEC_SET_STRING(iovec[n++], comm);
536 }
537
538 r = get_process_exe(ucred->pid, &t);
539 if (r >= 0) {
540 exe = strappenda("_EXE=", t);
541 free(t);
542 IOVEC_SET_STRING(iovec[n++], exe);
543 }
544
545 r = get_process_cmdline(ucred->pid, 0, false, &t);
546 if (r >= 0) {
547 cmdline = strappenda("_CMDLINE=", t);
548 free(t);
549 IOVEC_SET_STRING(iovec[n++], cmdline);
550 }
551
552 #ifdef HAVE_AUDIT
553 r = audit_session_from_pid(ucred->pid, &audit);
554 if (r >= 0) {
555 sprintf(audit_session, "_AUDIT_SESSION=%lu", (unsigned long) audit);
556 IOVEC_SET_STRING(iovec[n++], audit_session);
557 }
558
559 r = audit_loginuid_from_pid(ucred->pid, &loginuid);
560 if (r >= 0) {
561 sprintf(audit_loginuid, "_AUDIT_LOGINUID=%lu", (unsigned long) loginuid);
562 IOVEC_SET_STRING(iovec[n++], audit_loginuid);
563 }
564 #endif
565
566 r = cg_pid_get_path_shifted(ucred->pid, NULL, &c);
567 if (r >= 0) {
568 cgroup = strappenda("_SYSTEMD_CGROUP=", c);
569 IOVEC_SET_STRING(iovec[n++], cgroup);
570
571 r = cg_path_get_session(c, &t);
572 if (r >= 0) {
573 session = strappenda("_SYSTEMD_SESSION=", t);
574 free(t);
575 IOVEC_SET_STRING(iovec[n++], session);
576 }
577
578 if (cg_path_get_owner_uid(c, &owner) >= 0) {
579 owner_valid = true;
580
581 sprintf(owner_uid, "_SYSTEMD_OWNER_UID=%lu", (unsigned long) owner);
582 IOVEC_SET_STRING(iovec[n++], owner_uid);
583 }
584
585 if (cg_path_get_unit(c, &t) >= 0) {
586 unit = strappenda("_SYSTEMD_UNIT=", t);
587 free(t);
588 } else if (cg_path_get_user_unit(c, &t) >= 0) {
589 unit = strappenda("_SYSTEMD_USER_UNIT=", t);
590 free(t);
591 } else if (unit_id) {
592 if (session)
593 unit = strappenda("_SYSTEMD_USER_UNIT=", unit_id);
594 else
595 unit = strappenda("_SYSTEMD_UNIT=", unit_id);
596 } else
597 unit = NULL;
598
599 if (unit)
600 IOVEC_SET_STRING(iovec[n++], unit);
601
602 free(c);
603 }
604
605 #ifdef HAVE_SELINUX
606 if (label) {
607 char *selinux_context = alloca(sizeof("_SELINUX_CONTEXT=") + label_len);
608
609 *((char*) mempcpy(stpcpy(selinux_context, "_SELINUX_CONTEXT="), label, label_len)) = 0;
610 IOVEC_SET_STRING(iovec[n++], selinux_context);
611 } else {
612 security_context_t con;
613
614 if (getpidcon(ucred->pid, &con) >= 0) {
615 char *selinux_context = strappenda("_SELINUX_CONTEXT=", con);
616
617 freecon(con);
618 IOVEC_SET_STRING(iovec[n++], selinux_context);
619 }
620 }
621 #endif
622 }
623
624 if (tv) {
625 sprintf(source_time, "_SOURCE_REALTIME_TIMESTAMP=%llu", (unsigned long long) timeval_load(tv));
626 IOVEC_SET_STRING(iovec[n++], source_time);
627 }
628
629 /* Note that strictly speaking storing the boot id here is
630 * redundant since the entry includes this in-line
631 * anyway. However, we need this indexed, too. */
632 r = sd_id128_get_boot(&id);
633 if (r >= 0) {
634 sd_id128_to_string(id, boot_id + sizeof("_BOOT_ID=") - 1);
635 IOVEC_SET_STRING(iovec[n++], boot_id);
636 }
637
638 r = sd_id128_get_machine(&id);
639 if (r >= 0) {
640 sd_id128_to_string(id, machine_id + sizeof("_MACHINE_ID=") - 1);
641 IOVEC_SET_STRING(iovec[n++], machine_id);
642 }
643
644 t = gethostname_malloc();
645 if (t) {
646 hostname = strappenda("_HOSTNAME=", t);
647 free(t);
648 IOVEC_SET_STRING(iovec[n++], hostname);
649 }
650
651 assert(n <= m);
652
653 if (s->split_mode == SPLIT_UID && realuid > 0)
654 /* Split up strictly by any UID */
655 journal_uid = realuid;
656 else if (s->split_mode == SPLIT_LOGIN && realuid > 0 && owner_valid && owner > 0)
657 /* Split up by login UIDs, this avoids creation of
658 * individual journals for system UIDs. We do this
659 * only if the realuid is not root, in order not to
660 * accidentally leak privileged information to the
661 * user that is logged by a privileged process that is
662 * part of an unprivileged session.*/
663 journal_uid = owner;
664 else
665 journal_uid = 0;
666
667 write_to_journal(s, journal_uid, iovec, n);
668 }
669
670 void server_driver_message(Server *s, sd_id128_t message_id, const char *format, ...) {
671 char mid[11 + 32 + 1];
672 char buffer[16 + LINE_MAX + 1];
673 struct iovec iovec[N_IOVEC_META_FIELDS + 4];
674 int n = 0;
675 va_list ap;
676 struct ucred ucred = {};
677
678 assert(s);
679 assert(format);
680
681 IOVEC_SET_STRING(iovec[n++], "PRIORITY=6");
682 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=driver");
683
684 memcpy(buffer, "MESSAGE=", 8);
685 va_start(ap, format);
686 vsnprintf(buffer + 8, sizeof(buffer) - 8, format, ap);
687 va_end(ap);
688 char_array_0(buffer);
689 IOVEC_SET_STRING(iovec[n++], buffer);
690
691 if (!sd_id128_equal(message_id, SD_ID128_NULL)) {
692 snprintf(mid, sizeof(mid), MESSAGE_ID(message_id));
693 char_array_0(mid);
694 IOVEC_SET_STRING(iovec[n++], mid);
695 }
696
697 ucred.pid = getpid();
698 ucred.uid = getuid();
699 ucred.gid = getgid();
700
701 dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL);
702 }
703
704 void server_dispatch_message(
705 Server *s,
706 struct iovec *iovec, unsigned n, unsigned m,
707 struct ucred *ucred,
708 struct timeval *tv,
709 const char *label, size_t label_len,
710 const char *unit_id,
711 int priority) {
712
713 int rl, r;
714 _cleanup_free_ char *path = NULL;
715 char *c;
716
717 assert(s);
718 assert(iovec || n == 0);
719
720 if (n == 0)
721 return;
722
723 if (LOG_PRI(priority) > s->max_level_store)
724 return;
725
726 if (!ucred)
727 goto finish;
728
729 r = cg_pid_get_path_shifted(ucred->pid, NULL, &path);
730 if (r < 0)
731 goto finish;
732
733 /* example: /user/lennart/3/foobar
734 * /system/dbus.service/foobar
735 *
736 * So let's cut of everything past the third /, since that is
737 * where user directories start */
738
739 c = strchr(path, '/');
740 if (c) {
741 c = strchr(c+1, '/');
742 if (c) {
743 c = strchr(c+1, '/');
744 if (c)
745 *c = 0;
746 }
747 }
748
749 rl = journal_rate_limit_test(s->rate_limit, path,
750 priority & LOG_PRIMASK, available_space(s));
751
752 if (rl == 0)
753 return;
754
755 /* Write a suppression message if we suppressed something */
756 if (rl > 1)
757 server_driver_message(s, SD_MESSAGE_JOURNAL_DROPPED,
758 "Suppressed %u messages from %s", rl - 1, path);
759
760 finish:
761 dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id);
762 }
763
764
765 static int system_journal_open(Server *s) {
766 int r;
767 char *fn;
768 sd_id128_t machine;
769 char ids[33];
770 uint64_t avail;
771
772 avail = available_space(s);
773
774 r = sd_id128_get_machine(&machine);
775 if (r < 0)
776 return r;
777
778 sd_id128_to_string(machine, ids);
779
780 if (!s->system_journal &&
781 (s->storage == STORAGE_PERSISTENT || s->storage == STORAGE_AUTO) &&
782 access("/run/systemd/journal/flushed", F_OK) >= 0) {
783
784 /* If in auto mode: first try to create the machine
785 * path, but not the prefix.
786 *
787 * If in persistent mode: create /var/log/journal and
788 * the machine path */
789
790 if (s->storage == STORAGE_PERSISTENT)
791 (void) mkdir("/var/log/journal/", 0755);
792
793 fn = strappend("/var/log/journal/", ids);
794 if (!fn)
795 return -ENOMEM;
796
797 (void) mkdir(fn, 0755);
798 free(fn);
799
800 fn = strjoin("/var/log/journal/", ids, "/system.journal", NULL);
801 if (!fn)
802 return -ENOMEM;
803
804 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, NULL, &s->system_journal);
805 free(fn);
806
807 if (r >= 0) {
808 char fb[FORMAT_BYTES_MAX];
809
810 server_fix_perms(s, s->system_journal, 0);
811 server_driver_message(s, SD_ID128_NULL, "Allowing system journal files to grow to %s.",
812 format_bytes(fb, sizeof(fb), s->system_metrics.max_use));
813
814 if (s->system_metrics.max_use > avail)
815 server_driver_message(s, SD_ID128_NULL, "Journal size currently limited to %s due to SystemKeepFree.",
816 format_bytes(fb, sizeof(fb), avail));
817
818 } else if (r < 0) {
819
820 if (r != -ENOENT && r != -EROFS)
821 log_warning("Failed to open system journal: %s", strerror(-r));
822
823 r = 0;
824 }
825 }
826
827 if (!s->runtime_journal &&
828 (s->storage != STORAGE_NONE)) {
829
830 fn = strjoin("/run/log/journal/", ids, "/system.journal", NULL);
831 if (!fn)
832 return -ENOMEM;
833
834 if (s->system_journal) {
835
836 /* Try to open the runtime journal, but only
837 * if it already exists, so that we can flush
838 * it into the system journal */
839
840 r = journal_file_open(fn, O_RDWR, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
841 free(fn);
842
843 if (r < 0) {
844 if (r != -ENOENT)
845 log_warning("Failed to open runtime journal: %s", strerror(-r));
846
847 r = 0;
848 }
849
850 } else {
851
852 /* OK, we really need the runtime journal, so create
853 * it if necessary. */
854
855 (void) mkdir_parents(fn, 0755);
856 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
857 free(fn);
858
859 if (r < 0) {
860 log_error("Failed to open runtime journal: %s", strerror(-r));
861 return r;
862 }
863 }
864
865 if (s->runtime_journal) {
866 char fb[FORMAT_BYTES_MAX];
867
868 server_fix_perms(s, s->runtime_journal, 0);
869 server_driver_message(s, SD_ID128_NULL, "Allowing runtime journal files to grow to %s.",
870 format_bytes(fb, sizeof(fb), s->runtime_metrics.max_use));
871
872 if (s->system_metrics.max_use > avail)
873 server_driver_message(s, SD_ID128_NULL, "Journal size currently limited to %s due to RuntimeKeepFree.",
874 format_bytes(fb, sizeof(fb), avail));
875 }
876 }
877
878 return r;
879 }
880
881 int server_flush_to_var(Server *s) {
882 int r;
883 sd_id128_t machine;
884 sd_journal *j = NULL;
885
886 assert(s);
887
888 if (s->storage != STORAGE_AUTO &&
889 s->storage != STORAGE_PERSISTENT)
890 return 0;
891
892 if (!s->runtime_journal)
893 return 0;
894
895 system_journal_open(s);
896
897 if (!s->system_journal)
898 return 0;
899
900 log_debug("Flushing to /var...");
901
902 r = sd_id128_get_machine(&machine);
903 if (r < 0) {
904 log_error("Failed to get machine id: %s", strerror(-r));
905 return r;
906 }
907
908 r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
909 if (r < 0) {
910 log_error("Failed to read runtime journal: %s", strerror(-r));
911 return r;
912 }
913
914 sd_journal_set_data_threshold(j, 0);
915
916 SD_JOURNAL_FOREACH(j) {
917 Object *o = NULL;
918 JournalFile *f;
919
920 f = j->current_file;
921 assert(f && f->current_offset > 0);
922
923 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
924 if (r < 0) {
925 log_error("Can't read entry: %s", strerror(-r));
926 goto finish;
927 }
928
929 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
930 if (r >= 0)
931 continue;
932
933 if (!shall_try_append_again(s->system_journal, r)) {
934 log_error("Can't write entry: %s", strerror(-r));
935 goto finish;
936 }
937
938 server_rotate(s);
939 server_vacuum(s);
940
941 if (!s->system_journal) {
942 log_notice("Didn't flush runtime journal since rotation of system journal wasn't successful.");
943 r = -EIO;
944 goto finish;
945 }
946
947 log_debug("Retrying write.");
948 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
949 if (r < 0) {
950 log_error("Can't write entry: %s", strerror(-r));
951 goto finish;
952 }
953 }
954
955 finish:
956 journal_file_post_change(s->system_journal);
957
958 journal_file_close(s->runtime_journal);
959 s->runtime_journal = NULL;
960
961 if (r >= 0)
962 rm_rf("/run/log/journal", false, true, false);
963
964 sd_journal_close(j);
965
966 return r;
967 }
968
969 int process_event(Server *s, struct epoll_event *ev) {
970 assert(s);
971 assert(ev);
972
973 if (ev->data.fd == s->signal_fd) {
974 struct signalfd_siginfo sfsi;
975 ssize_t n;
976
977 if (ev->events != EPOLLIN) {
978 log_error("Got invalid event from epoll.");
979 return -EIO;
980 }
981
982 n = read(s->signal_fd, &sfsi, sizeof(sfsi));
983 if (n != sizeof(sfsi)) {
984
985 if (n >= 0)
986 return -EIO;
987
988 if (errno == EINTR || errno == EAGAIN)
989 return 1;
990
991 return -errno;
992 }
993
994 if (sfsi.ssi_signo == SIGUSR1) {
995 touch("/run/systemd/journal/flushed");
996 server_flush_to_var(s);
997 server_sync(s);
998 return 1;
999 }
1000
1001 if (sfsi.ssi_signo == SIGUSR2) {
1002 server_rotate(s);
1003 server_vacuum(s);
1004 return 1;
1005 }
1006
1007 log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo));
1008
1009 return 0;
1010
1011 } else if (ev->data.fd == s->sync_timer_fd) {
1012 int r;
1013 uint64_t t;
1014
1015 log_debug("Got sync request from epoll.");
1016
1017 r = read(ev->data.fd, (void *)&t, sizeof(t));
1018 if (r < 0)
1019 return 0;
1020
1021 server_sync(s);
1022 return 1;
1023
1024 } else if (ev->data.fd == s->dev_kmsg_fd) {
1025 int r;
1026
1027 if (ev->events != EPOLLIN) {
1028 log_error("Got invalid event from epoll.");
1029 return -EIO;
1030 }
1031
1032 r = server_read_dev_kmsg(s);
1033 if (r < 0)
1034 return r;
1035
1036 return 1;
1037
1038 } else if (ev->data.fd == s->native_fd ||
1039 ev->data.fd == s->syslog_fd) {
1040
1041 if (ev->events != EPOLLIN) {
1042 log_error("Got invalid event from epoll.");
1043 return -EIO;
1044 }
1045
1046 for (;;) {
1047 struct msghdr msghdr;
1048 struct iovec iovec;
1049 struct ucred *ucred = NULL;
1050 struct timeval *tv = NULL;
1051 struct cmsghdr *cmsg;
1052 char *label = NULL;
1053 size_t label_len = 0;
1054 union {
1055 struct cmsghdr cmsghdr;
1056
1057 /* We use NAME_MAX space for the
1058 * SELinux label here. The kernel
1059 * currently enforces no limit, but
1060 * according to suggestions from the
1061 * SELinux people this will change and
1062 * it will probably be identical to
1063 * NAME_MAX. For now we use that, but
1064 * this should be updated one day when
1065 * the final limit is known.*/
1066 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1067 CMSG_SPACE(sizeof(struct timeval)) +
1068 CMSG_SPACE(sizeof(int)) + /* fd */
1069 CMSG_SPACE(NAME_MAX)]; /* selinux label */
1070 } control;
1071 ssize_t n;
1072 int v;
1073 int *fds = NULL;
1074 unsigned n_fds = 0;
1075
1076 if (ioctl(ev->data.fd, SIOCINQ, &v) < 0) {
1077 log_error("SIOCINQ failed: %m");
1078 return -errno;
1079 }
1080
1081 if (s->buffer_size < (size_t) v) {
1082 void *b;
1083 size_t l;
1084
1085 l = MAX(LINE_MAX + (size_t) v, s->buffer_size * 2);
1086 b = realloc(s->buffer, l+1);
1087
1088 if (!b) {
1089 log_error("Couldn't increase buffer.");
1090 return -ENOMEM;
1091 }
1092
1093 s->buffer_size = l;
1094 s->buffer = b;
1095 }
1096
1097 zero(iovec);
1098 iovec.iov_base = s->buffer;
1099 iovec.iov_len = s->buffer_size;
1100
1101 zero(control);
1102 zero(msghdr);
1103 msghdr.msg_iov = &iovec;
1104 msghdr.msg_iovlen = 1;
1105 msghdr.msg_control = &control;
1106 msghdr.msg_controllen = sizeof(control);
1107
1108 n = recvmsg(ev->data.fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1109 if (n < 0) {
1110
1111 if (errno == EINTR || errno == EAGAIN)
1112 return 1;
1113
1114 log_error("recvmsg() failed: %m");
1115 return -errno;
1116 }
1117
1118 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1119
1120 if (cmsg->cmsg_level == SOL_SOCKET &&
1121 cmsg->cmsg_type == SCM_CREDENTIALS &&
1122 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
1123 ucred = (struct ucred*) CMSG_DATA(cmsg);
1124 else if (cmsg->cmsg_level == SOL_SOCKET &&
1125 cmsg->cmsg_type == SCM_SECURITY) {
1126 label = (char*) CMSG_DATA(cmsg);
1127 label_len = cmsg->cmsg_len - CMSG_LEN(0);
1128 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1129 cmsg->cmsg_type == SO_TIMESTAMP &&
1130 cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
1131 tv = (struct timeval*) CMSG_DATA(cmsg);
1132 else if (cmsg->cmsg_level == SOL_SOCKET &&
1133 cmsg->cmsg_type == SCM_RIGHTS) {
1134 fds = (int*) CMSG_DATA(cmsg);
1135 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1136 }
1137 }
1138
1139 if (ev->data.fd == s->syslog_fd) {
1140 char *e;
1141
1142 if (n > 0 && n_fds == 0) {
1143 e = memchr(s->buffer, '\n', n);
1144 if (e)
1145 *e = 0;
1146 else
1147 s->buffer[n] = 0;
1148
1149 server_process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);
1150 } else if (n_fds > 0)
1151 log_warning("Got file descriptors via syslog socket. Ignoring.");
1152
1153 } else {
1154 if (n > 0 && n_fds == 0)
1155 server_process_native_message(s, s->buffer, n, ucred, tv, label, label_len);
1156 else if (n == 0 && n_fds == 1)
1157 server_process_native_file(s, fds[0], ucred, tv, label, label_len);
1158 else if (n_fds > 0)
1159 log_warning("Got too many file descriptors via native socket. Ignoring.");
1160 }
1161
1162 close_many(fds, n_fds);
1163 }
1164
1165 return 1;
1166
1167 } else if (ev->data.fd == s->stdout_fd) {
1168
1169 if (ev->events != EPOLLIN) {
1170 log_error("Got invalid event from epoll.");
1171 return -EIO;
1172 }
1173
1174 stdout_stream_new(s);
1175 return 1;
1176
1177 } else {
1178 StdoutStream *stream;
1179
1180 if ((ev->events|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
1181 log_error("Got invalid event from epoll.");
1182 return -EIO;
1183 }
1184
1185 /* If it is none of the well-known fds, it must be an
1186 * stdout stream fd. Note that this is a bit ugly here
1187 * (since we rely that none of the well-known fds
1188 * could be interpreted as pointer), but nonetheless
1189 * safe, since the well-known fds would never get an
1190 * fd > 4096, i.e. beyond the first memory page */
1191
1192 stream = ev->data.ptr;
1193
1194 if (stdout_stream_process(stream) <= 0)
1195 stdout_stream_free(stream);
1196
1197 return 1;
1198 }
1199
1200 log_error("Unknown event.");
1201 return 0;
1202 }
1203
1204 static int open_signalfd(Server *s) {
1205 sigset_t mask;
1206 struct epoll_event ev;
1207
1208 assert(s);
1209
1210 assert_se(sigemptyset(&mask) == 0);
1211 sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
1212 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
1213
1214 s->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
1215 if (s->signal_fd < 0) {
1216 log_error("signalfd(): %m");
1217 return -errno;
1218 }
1219
1220 zero(ev);
1221 ev.events = EPOLLIN;
1222 ev.data.fd = s->signal_fd;
1223
1224 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->signal_fd, &ev) < 0) {
1225 log_error("epoll_ctl(): %m");
1226 return -errno;
1227 }
1228
1229 return 0;
1230 }
1231
1232 static int server_parse_proc_cmdline(Server *s) {
1233 _cleanup_free_ char *line = NULL;
1234 char *w, *state;
1235 int r;
1236 size_t l;
1237
1238 if (detect_container(NULL) > 0)
1239 return 0;
1240
1241 r = read_one_line_file("/proc/cmdline", &line);
1242 if (r < 0) {
1243 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
1244 return 0;
1245 }
1246
1247 FOREACH_WORD_QUOTED(w, l, line, state) {
1248 _cleanup_free_ char *word;
1249
1250 word = strndup(w, l);
1251 if (!word)
1252 return -ENOMEM;
1253
1254 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
1255 r = parse_boolean(word + 35);
1256 if (r < 0)
1257 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
1258 else
1259 s->forward_to_syslog = r;
1260 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
1261 r = parse_boolean(word + 33);
1262 if (r < 0)
1263 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
1264 else
1265 s->forward_to_kmsg = r;
1266 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
1267 r = parse_boolean(word + 36);
1268 if (r < 0)
1269 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
1270 else
1271 s->forward_to_console = r;
1272 } else if (startswith(word, "systemd.journald"))
1273 log_warning("Invalid systemd.journald parameter. Ignoring.");
1274 }
1275
1276 return 0;
1277 }
1278
1279 static int server_parse_config_file(Server *s) {
1280 static const char fn[] = "/etc/systemd/journald.conf";
1281 _cleanup_fclose_ FILE *f = NULL;
1282 int r;
1283
1284 assert(s);
1285
1286 f = fopen(fn, "re");
1287 if (!f) {
1288 if (errno == ENOENT)
1289 return 0;
1290
1291 log_warning("Failed to open configuration file %s: %m", fn);
1292 return -errno;
1293 }
1294
1295 r = config_parse(NULL, fn, f, "Journal\0", config_item_perf_lookup,
1296 (void*) journald_gperf_lookup, false, false, s);
1297 if (r < 0)
1298 log_warning("Failed to parse configuration file: %s", strerror(-r));
1299
1300 return r;
1301 }
1302
1303 static int server_open_sync_timer(Server *s) {
1304 int r;
1305 struct epoll_event ev;
1306
1307 assert(s);
1308
1309 s->sync_timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
1310 if (s->sync_timer_fd < 0)
1311 return -errno;
1312
1313 zero(ev);
1314 ev.events = EPOLLIN;
1315 ev.data.fd = s->sync_timer_fd;
1316
1317 r = epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->sync_timer_fd, &ev);
1318 if (r < 0) {
1319 log_error("Failed to add idle timer fd to epoll object: %m");
1320 return -errno;
1321 }
1322
1323 return 0;
1324 }
1325
1326 int server_schedule_sync(Server *s) {
1327 int r;
1328
1329 assert(s);
1330
1331 if (s->sync_scheduled)
1332 return 0;
1333
1334 if (s->sync_interval_usec) {
1335 struct itimerspec sync_timer_enable = {};
1336
1337 timespec_store(&sync_timer_enable.it_value, s->sync_interval_usec);
1338
1339 r = timerfd_settime(s->sync_timer_fd, 0, &sync_timer_enable, NULL);
1340 if (r < 0)
1341 return -errno;
1342 }
1343
1344 s->sync_scheduled = true;
1345
1346 return 0;
1347 }
1348
1349 int server_init(Server *s) {
1350 int n, r, fd;
1351
1352 assert(s);
1353
1354 zero(*s);
1355 s->sync_timer_fd = s->syslog_fd = s->native_fd = s->stdout_fd =
1356 s->signal_fd = s->epoll_fd = s->dev_kmsg_fd = -1;
1357 s->compress = true;
1358 s->seal = true;
1359
1360 s->sync_interval_usec = DEFAULT_SYNC_INTERVAL_USEC;
1361 s->sync_scheduled = false;
1362
1363 s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
1364 s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
1365
1366 s->forward_to_syslog = true;
1367
1368 s->max_level_store = LOG_DEBUG;
1369 s->max_level_syslog = LOG_DEBUG;
1370 s->max_level_kmsg = LOG_NOTICE;
1371 s->max_level_console = LOG_INFO;
1372
1373 memset(&s->system_metrics, 0xFF, sizeof(s->system_metrics));
1374 memset(&s->runtime_metrics, 0xFF, sizeof(s->runtime_metrics));
1375
1376 server_parse_config_file(s);
1377 server_parse_proc_cmdline(s);
1378 if (!!s->rate_limit_interval ^ !!s->rate_limit_burst) {
1379 log_debug("Setting both rate limit interval and burst from %llu,%u to 0,0",
1380 (long long unsigned) s->rate_limit_interval,
1381 s->rate_limit_burst);
1382 s->rate_limit_interval = s->rate_limit_burst = 0;
1383 }
1384
1385 mkdir_p("/run/systemd/journal", 0755);
1386
1387 s->user_journals = hashmap_new(trivial_hash_func, trivial_compare_func);
1388 if (!s->user_journals)
1389 return log_oom();
1390
1391 s->mmap = mmap_cache_new();
1392 if (!s->mmap)
1393 return log_oom();
1394
1395 s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1396 if (s->epoll_fd < 0) {
1397 log_error("Failed to create epoll object: %m");
1398 return -errno;
1399 }
1400
1401 n = sd_listen_fds(true);
1402 if (n < 0) {
1403 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
1404 return n;
1405 }
1406
1407 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
1408
1409 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
1410
1411 if (s->native_fd >= 0) {
1412 log_error("Too many native sockets passed.");
1413 return -EINVAL;
1414 }
1415
1416 s->native_fd = fd;
1417
1418 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
1419
1420 if (s->stdout_fd >= 0) {
1421 log_error("Too many stdout sockets passed.");
1422 return -EINVAL;
1423 }
1424
1425 s->stdout_fd = fd;
1426
1427 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0) {
1428
1429 if (s->syslog_fd >= 0) {
1430 log_error("Too many /dev/log sockets passed.");
1431 return -EINVAL;
1432 }
1433
1434 s->syslog_fd = fd;
1435
1436 } else {
1437 log_error("Unknown socket passed.");
1438 return -EINVAL;
1439 }
1440 }
1441
1442 r = server_open_syslog_socket(s);
1443 if (r < 0)
1444 return r;
1445
1446 r = server_open_native_socket(s);
1447 if (r < 0)
1448 return r;
1449
1450 r = server_open_stdout_socket(s);
1451 if (r < 0)
1452 return r;
1453
1454 r = server_open_dev_kmsg(s);
1455 if (r < 0)
1456 return r;
1457
1458 r = server_open_kernel_seqnum(s);
1459 if (r < 0)
1460 return r;
1461
1462 r = server_open_sync_timer(s);
1463 if (r < 0)
1464 return r;
1465
1466 r = open_signalfd(s);
1467 if (r < 0)
1468 return r;
1469
1470 s->udev = udev_new();
1471 if (!s->udev)
1472 return -ENOMEM;
1473
1474 s->rate_limit = journal_rate_limit_new(s->rate_limit_interval,
1475 s->rate_limit_burst);
1476 if (!s->rate_limit)
1477 return -ENOMEM;
1478
1479 r = system_journal_open(s);
1480 if (r < 0)
1481 return r;
1482
1483 return 0;
1484 }
1485
1486 void server_maybe_append_tags(Server *s) {
1487 #ifdef HAVE_GCRYPT
1488 JournalFile *f;
1489 Iterator i;
1490 usec_t n;
1491
1492 n = now(CLOCK_REALTIME);
1493
1494 if (s->system_journal)
1495 journal_file_maybe_append_tag(s->system_journal, n);
1496
1497 HASHMAP_FOREACH(f, s->user_journals, i)
1498 journal_file_maybe_append_tag(f, n);
1499 #endif
1500 }
1501
1502 void server_done(Server *s) {
1503 JournalFile *f;
1504 assert(s);
1505
1506 while (s->stdout_streams)
1507 stdout_stream_free(s->stdout_streams);
1508
1509 if (s->system_journal)
1510 journal_file_close(s->system_journal);
1511
1512 if (s->runtime_journal)
1513 journal_file_close(s->runtime_journal);
1514
1515 while ((f = hashmap_steal_first(s->user_journals)))
1516 journal_file_close(f);
1517
1518 hashmap_free(s->user_journals);
1519
1520 if (s->epoll_fd >= 0)
1521 close_nointr_nofail(s->epoll_fd);
1522
1523 if (s->signal_fd >= 0)
1524 close_nointr_nofail(s->signal_fd);
1525
1526 if (s->syslog_fd >= 0)
1527 close_nointr_nofail(s->syslog_fd);
1528
1529 if (s->native_fd >= 0)
1530 close_nointr_nofail(s->native_fd);
1531
1532 if (s->stdout_fd >= 0)
1533 close_nointr_nofail(s->stdout_fd);
1534
1535 if (s->dev_kmsg_fd >= 0)
1536 close_nointr_nofail(s->dev_kmsg_fd);
1537
1538 if (s->sync_timer_fd >= 0)
1539 close_nointr_nofail(s->sync_timer_fd);
1540
1541 if (s->rate_limit)
1542 journal_rate_limit_free(s->rate_limit);
1543
1544 if (s->kernel_seqnum)
1545 munmap(s->kernel_seqnum, sizeof(uint64_t));
1546
1547 free(s->buffer);
1548 free(s->tty_path);
1549
1550 if (s->mmap)
1551 mmap_cache_unref(s->mmap);
1552
1553 if (s->udev)
1554 udev_unref(s->udev);
1555 }
Unnamed repository; edit this file 'description' to name the repository.