]> 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
journald: don't pass around SO_TIMESTAMP timestamp for audit, which we don't have...
[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
31 #include "sd-journal.h"
32 #include "sd-messages.h"
33 #include "sd-daemon.h"
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 "missing.h"
42 #include "conf-parser.h"
43 #include "selinux-util.h"
44 #include "journal-internal.h"
45 #include "journal-vacuum.h"
46 #include "journal-authenticate.h"
47 #include "journald-rate-limit.h"
48 #include "journald-kmsg.h"
49 #include "journald-syslog.h"
50 #include "journald-stream.h"
51 #include "journald-console.h"
52 #include "journald-native.h"
53 #include "journald-audit.h"
54 #include "journald-server.h"
55
56 #ifdef HAVE_ACL
57 #include <sys/acl.h>
58 #include <acl/libacl.h>
59 #include "acl-util.h"
60 #endif
61
62 #ifdef HAVE_SELINUX
63 #include <selinux/selinux.h>
64 #endif
65
66 #define USER_JOURNALS_MAX 1024
67
68 #define DEFAULT_SYNC_INTERVAL_USEC (5*USEC_PER_MINUTE)
69 #define DEFAULT_RATE_LIMIT_INTERVAL (30*USEC_PER_SEC)
70 #define DEFAULT_RATE_LIMIT_BURST 1000
71 #define DEFAULT_MAX_FILE_USEC USEC_PER_MONTH
72
73 #define RECHECK_AVAILABLE_SPACE_USEC (30*USEC_PER_SEC)
74
75 static const char* const storage_table[_STORAGE_MAX] = {
76 [STORAGE_AUTO] = "auto",
77 [STORAGE_VOLATILE] = "volatile",
78 [STORAGE_PERSISTENT] = "persistent",
79 [STORAGE_NONE] = "none"
80 };
81
82 DEFINE_STRING_TABLE_LOOKUP(storage, Storage);
83 DEFINE_CONFIG_PARSE_ENUM(config_parse_storage, storage, Storage, "Failed to parse storage setting");
84
85 static const char* const split_mode_table[_SPLIT_MAX] = {
86 [SPLIT_LOGIN] = "login",
87 [SPLIT_UID] = "uid",
88 [SPLIT_NONE] = "none",
89 };
90
91 DEFINE_STRING_TABLE_LOOKUP(split_mode, SplitMode);
92 DEFINE_CONFIG_PARSE_ENUM(config_parse_split_mode, split_mode, SplitMode, "Failed to parse split mode setting");
93
94 static uint64_t available_space(Server *s, bool verbose) {
95 char ids[33];
96 _cleanup_free_ char *p = NULL;
97 sd_id128_t machine;
98 struct statvfs ss;
99 uint64_t sum = 0, ss_avail = 0, avail = 0;
100 int r;
101 _cleanup_closedir_ DIR *d = NULL;
102 usec_t ts;
103 const char *f;
104 JournalMetrics *m;
105
106 ts = now(CLOCK_MONOTONIC);
107
108 if (s->cached_available_space_timestamp + RECHECK_AVAILABLE_SPACE_USEC > ts
109 && !verbose)
110 return s->cached_available_space;
111
112 r = sd_id128_get_machine(&machine);
113 if (r < 0)
114 return 0;
115
116 if (s->system_journal) {
117 f = "/var/log/journal/";
118 m = &s->system_metrics;
119 } else {
120 f = "/run/log/journal/";
121 m = &s->runtime_metrics;
122 }
123
124 assert(m);
125
126 p = strappend(f, sd_id128_to_string(machine, ids));
127 if (!p)
128 return 0;
129
130 d = opendir(p);
131 if (!d)
132 return 0;
133
134 if (fstatvfs(dirfd(d), &ss) < 0)
135 return 0;
136
137 for (;;) {
138 struct stat st;
139 struct dirent *de;
140
141 errno = 0;
142 de = readdir(d);
143 if (!de && errno != 0)
144 return 0;
145
146 if (!de)
147 break;
148
149 if (!endswith(de->d_name, ".journal") &&
150 !endswith(de->d_name, ".journal~"))
151 continue;
152
153 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
154 continue;
155
156 if (!S_ISREG(st.st_mode))
157 continue;
158
159 sum += (uint64_t) st.st_blocks * 512UL;
160 }
161
162 ss_avail = ss.f_bsize * ss.f_bavail;
163
164 /* If we reached a high mark, we will always allow this much
165 * again, unless usage goes above max_use. This watermark
166 * value is cached so that we don't give up space on pressure,
167 * but hover below the maximum usage. */
168
169 if (m->use < sum)
170 m->use = sum;
171
172 avail = LESS_BY(ss_avail, m->keep_free);
173
174 s->cached_available_space = LESS_BY(MIN(m->max_use, avail), sum);
175 s->cached_available_space_timestamp = ts;
176
177 if (verbose) {
178 char fb1[FORMAT_BYTES_MAX], fb2[FORMAT_BYTES_MAX], fb3[FORMAT_BYTES_MAX],
179 fb4[FORMAT_BYTES_MAX], fb5[FORMAT_BYTES_MAX];
180
181 server_driver_message(s, SD_MESSAGE_JOURNAL_USAGE,
182 "%s journal is using %s (max allowed %s, "
183 "trying to leave %s free of %s available → current limit %s).",
184 s->system_journal ? "Permanent" : "Runtime",
185 format_bytes(fb1, sizeof(fb1), sum),
186 format_bytes(fb2, sizeof(fb2), m->max_use),
187 format_bytes(fb3, sizeof(fb3), m->keep_free),
188 format_bytes(fb4, sizeof(fb4), ss_avail),
189 format_bytes(fb5, sizeof(fb5), s->cached_available_space + sum));
190 }
191
192 return s->cached_available_space;
193 }
194
195 void server_fix_perms(Server *s, JournalFile *f, uid_t uid) {
196 int r;
197 #ifdef HAVE_ACL
198 acl_t acl;
199 acl_entry_t entry;
200 acl_permset_t permset;
201 #endif
202
203 assert(f);
204
205 r = fchmod(f->fd, 0640);
206 if (r < 0)
207 log_warning("Failed to fix access mode on %s, ignoring: %s", f->path, strerror(-r));
208
209 #ifdef HAVE_ACL
210 if (uid <= SYSTEM_UID_MAX)
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 <= SYSTEM_UID_MAX)
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 = ordered_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-"UID_FMT".journal",
275 SD_ID128_FORMAT_VAL(machine), uid) < 0)
276 return s->system_journal;
277
278 while (ordered_hashmap_size(s->user_journals) >= USER_JOURNALS_MAX) {
279 /* Too many open? Then let's close one */
280 f = ordered_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, NULL, &f);
286 if (r < 0)
287 return s->system_journal;
288
289 server_fix_perms(s, f, uid);
290
291 r = ordered_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 static int do_rotate(Server *s, JournalFile **f, const char* name,
301 bool seal, uint32_t uid) {
302 int r;
303 assert(s);
304
305 if (!*f)
306 return -EINVAL;
307
308 r = journal_file_rotate(f, s->compress, seal);
309 if (r < 0)
310 if (*f)
311 log_error("Failed to rotate %s: %s",
312 (*f)->path, strerror(-r));
313 else
314 log_error("Failed to create new %s journal: %s",
315 name, strerror(-r));
316 else
317 server_fix_perms(s, *f, uid);
318 return r;
319 }
320
321 void server_rotate(Server *s) {
322 JournalFile *f;
323 void *k;
324 Iterator i;
325 int r;
326
327 log_debug("Rotating...");
328
329 do_rotate(s, &s->runtime_journal, "runtime", false, 0);
330 do_rotate(s, &s->system_journal, "system", s->seal, 0);
331
332 ORDERED_HASHMAP_FOREACH_KEY(f, k, s->user_journals, i) {
333 r = do_rotate(s, &f, "user", s->seal, PTR_TO_UINT32(k));
334 if (r >= 0)
335 ordered_hashmap_replace(s->user_journals, k, f);
336 else if (!f)
337 /* Old file has been closed and deallocated */
338 ordered_hashmap_remove(s->user_journals, k);
339 }
340 }
341
342 void server_sync(Server *s) {
343 JournalFile *f;
344 void *k;
345 Iterator i;
346 int r;
347
348 if (s->system_journal) {
349 r = journal_file_set_offline(s->system_journal);
350 if (r < 0)
351 log_error("Failed to sync system journal: %s", strerror(-r));
352 }
353
354 ORDERED_HASHMAP_FOREACH_KEY(f, k, s->user_journals, i) {
355 r = journal_file_set_offline(f);
356 if (r < 0)
357 log_error("Failed to sync user journal: %s", strerror(-r));
358 }
359
360 if (s->sync_event_source) {
361 r = sd_event_source_set_enabled(s->sync_event_source, SD_EVENT_OFF);
362 if (r < 0)
363 log_error("Failed to disable sync timer source: %s", strerror(-r));
364 }
365
366 s->sync_scheduled = false;
367 }
368
369 static void do_vacuum(Server *s, char *ids, JournalFile *f, const char* path,
370 JournalMetrics *metrics) {
371 char *p;
372 int r;
373
374 if (!f)
375 return;
376
377 p = strappenda(path, ids);
378 r = journal_directory_vacuum(p, metrics->max_use, s->max_retention_usec, &s->oldest_file_usec, false);
379 if (r < 0 && r != -ENOENT)
380 log_error("Failed to vacuum %s: %s", p, strerror(-r));
381 }
382
383 void server_vacuum(Server *s) {
384 char ids[33];
385 sd_id128_t machine;
386 int r;
387
388 log_debug("Vacuuming...");
389
390 s->oldest_file_usec = 0;
391
392 r = sd_id128_get_machine(&machine);
393 if (r < 0) {
394 log_error("Failed to get machine ID: %s", strerror(-r));
395 return;
396 }
397 sd_id128_to_string(machine, ids);
398
399 do_vacuum(s, ids, s->system_journal, "/var/log/journal/", &s->system_metrics);
400 do_vacuum(s, ids, s->runtime_journal, "/run/log/journal/", &s->runtime_metrics);
401
402 s->cached_available_space_timestamp = 0;
403 }
404
405 static void server_cache_machine_id(Server *s) {
406 sd_id128_t id;
407 int r;
408
409 assert(s);
410
411 r = sd_id128_get_machine(&id);
412 if (r < 0)
413 return;
414
415 sd_id128_to_string(id, stpcpy(s->machine_id_field, "_MACHINE_ID="));
416 }
417
418 static void server_cache_boot_id(Server *s) {
419 sd_id128_t id;
420 int r;
421
422 assert(s);
423
424 r = sd_id128_get_boot(&id);
425 if (r < 0)
426 return;
427
428 sd_id128_to_string(id, stpcpy(s->boot_id_field, "_BOOT_ID="));
429 }
430
431 static void server_cache_hostname(Server *s) {
432 _cleanup_free_ char *t = NULL;
433 char *x;
434
435 assert(s);
436
437 t = gethostname_malloc();
438 if (!t)
439 return;
440
441 x = strappend("_HOSTNAME=", t);
442 if (!x)
443 return;
444
445 free(s->hostname_field);
446 s->hostname_field = x;
447 }
448
449 bool shall_try_append_again(JournalFile *f, int r) {
450
451 /* -E2BIG Hit configured limit
452 -EFBIG Hit fs limit
453 -EDQUOT Quota limit hit
454 -ENOSPC Disk full
455 -EHOSTDOWN Other machine
456 -EBUSY Unclean shutdown
457 -EPROTONOSUPPORT Unsupported feature
458 -EBADMSG Corrupted
459 -ENODATA Truncated
460 -ESHUTDOWN Already archived */
461
462 if (r == -E2BIG || r == -EFBIG || r == -EDQUOT || r == -ENOSPC)
463 log_debug("%s: Allocation limit reached, rotating.", f->path);
464 else if (r == -EHOSTDOWN)
465 log_info("%s: Journal file from other machine, rotating.", f->path);
466 else if (r == -EBUSY)
467 log_info("%s: Unclean shutdown, rotating.", f->path);
468 else if (r == -EPROTONOSUPPORT)
469 log_info("%s: Unsupported feature, rotating.", f->path);
470 else if (r == -EBADMSG || r == -ENODATA || r == ESHUTDOWN)
471 log_warning("%s: Journal file corrupted, rotating.", f->path);
472 else
473 return false;
474
475 return true;
476 }
477
478 static void write_to_journal(Server *s, uid_t uid, struct iovec *iovec, unsigned n, int priority) {
479 JournalFile *f;
480 bool vacuumed = false;
481 int r;
482
483 assert(s);
484 assert(iovec);
485 assert(n > 0);
486
487 f = find_journal(s, uid);
488 if (!f)
489 return;
490
491 if (journal_file_rotate_suggested(f, s->max_file_usec)) {
492 log_debug("%s: Journal header limits reached or header out-of-date, rotating.", f->path);
493 server_rotate(s);
494 server_vacuum(s);
495 vacuumed = true;
496
497 f = find_journal(s, uid);
498 if (!f)
499 return;
500 }
501
502 r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL);
503 if (r >= 0) {
504 server_schedule_sync(s, priority);
505 return;
506 }
507
508 if (vacuumed || !shall_try_append_again(f, r)) {
509 size_t size = 0;
510 unsigned i;
511 for (i = 0; i < n; i++)
512 size += iovec[i].iov_len;
513
514 log_error("Failed to write entry (%d items, %zu bytes), ignoring: %s", n, size, strerror(-r));
515 return;
516 }
517
518 server_rotate(s);
519 server_vacuum(s);
520
521 f = find_journal(s, uid);
522 if (!f)
523 return;
524
525 log_debug("Retrying write.");
526 r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL);
527 if (r < 0) {
528 size_t size = 0;
529 unsigned i;
530 for (i = 0; i < n; i++)
531 size += iovec[i].iov_len;
532
533 log_error("Failed to write entry (%d items, %zu bytes) despite vacuuming, ignoring: %s", n, size, strerror(-r));
534 } else
535 server_schedule_sync(s, priority);
536 }
537
538 static void dispatch_message_real(
539 Server *s,
540 struct iovec *iovec, unsigned n, unsigned m,
541 const struct ucred *ucred,
542 const struct timeval *tv,
543 const char *label, size_t label_len,
544 const char *unit_id,
545 int priority,
546 pid_t object_pid) {
547
548 char pid[sizeof("_PID=") + DECIMAL_STR_MAX(pid_t)],
549 uid[sizeof("_UID=") + DECIMAL_STR_MAX(uid_t)],
550 gid[sizeof("_GID=") + DECIMAL_STR_MAX(gid_t)],
551 owner_uid[sizeof("_SYSTEMD_OWNER_UID=") + DECIMAL_STR_MAX(uid_t)],
552 source_time[sizeof("_SOURCE_REALTIME_TIMESTAMP=") + DECIMAL_STR_MAX(usec_t)],
553 o_uid[sizeof("OBJECT_UID=") + DECIMAL_STR_MAX(uid_t)],
554 o_gid[sizeof("OBJECT_GID=") + DECIMAL_STR_MAX(gid_t)],
555 o_owner_uid[sizeof("OBJECT_SYSTEMD_OWNER_UID=") + DECIMAL_STR_MAX(uid_t)];
556 uid_t object_uid;
557 gid_t object_gid;
558 char *x;
559 int r;
560 char *t, *c;
561 uid_t realuid = 0, owner = 0, journal_uid;
562 bool owner_valid = false;
563 #ifdef HAVE_AUDIT
564 char audit_session[sizeof("_AUDIT_SESSION=") + DECIMAL_STR_MAX(uint32_t)],
565 audit_loginuid[sizeof("_AUDIT_LOGINUID=") + DECIMAL_STR_MAX(uid_t)],
566 o_audit_session[sizeof("OBJECT_AUDIT_SESSION=") + DECIMAL_STR_MAX(uint32_t)],
567 o_audit_loginuid[sizeof("OBJECT_AUDIT_LOGINUID=") + DECIMAL_STR_MAX(uid_t)];
568
569 uint32_t audit;
570 uid_t loginuid;
571 #endif
572
573 assert(s);
574 assert(iovec);
575 assert(n > 0);
576 assert(n + N_IOVEC_META_FIELDS + (object_pid ? N_IOVEC_OBJECT_FIELDS : 0) <= m);
577
578 if (ucred) {
579 realuid = ucred->uid;
580
581 sprintf(pid, "_PID="PID_FMT, ucred->pid);
582 IOVEC_SET_STRING(iovec[n++], pid);
583
584 sprintf(uid, "_UID="UID_FMT, ucred->uid);
585 IOVEC_SET_STRING(iovec[n++], uid);
586
587 sprintf(gid, "_GID="GID_FMT, ucred->gid);
588 IOVEC_SET_STRING(iovec[n++], gid);
589
590 r = get_process_comm(ucred->pid, &t);
591 if (r >= 0) {
592 x = strappenda("_COMM=", t);
593 free(t);
594 IOVEC_SET_STRING(iovec[n++], x);
595 }
596
597 r = get_process_exe(ucred->pid, &t);
598 if (r >= 0) {
599 x = strappenda("_EXE=", t);
600 free(t);
601 IOVEC_SET_STRING(iovec[n++], x);
602 }
603
604 r = get_process_cmdline(ucred->pid, 0, false, &t);
605 if (r >= 0) {
606 x = strappenda("_CMDLINE=", t);
607 free(t);
608 IOVEC_SET_STRING(iovec[n++], x);
609 }
610
611 r = get_process_capeff(ucred->pid, &t);
612 if (r >= 0) {
613 x = strappenda("_CAP_EFFECTIVE=", t);
614 free(t);
615 IOVEC_SET_STRING(iovec[n++], x);
616 }
617
618 #ifdef HAVE_AUDIT
619 r = audit_session_from_pid(ucred->pid, &audit);
620 if (r >= 0) {
621 sprintf(audit_session, "_AUDIT_SESSION=%"PRIu32, audit);
622 IOVEC_SET_STRING(iovec[n++], audit_session);
623 }
624
625 r = audit_loginuid_from_pid(ucred->pid, &loginuid);
626 if (r >= 0) {
627 sprintf(audit_loginuid, "_AUDIT_LOGINUID="UID_FMT, loginuid);
628 IOVEC_SET_STRING(iovec[n++], audit_loginuid);
629 }
630 #endif
631
632 r = cg_pid_get_path_shifted(ucred->pid, s->cgroup_root, &c);
633 if (r >= 0) {
634 char *session = NULL;
635
636 x = strappenda("_SYSTEMD_CGROUP=", c);
637 IOVEC_SET_STRING(iovec[n++], x);
638
639 r = cg_path_get_session(c, &t);
640 if (r >= 0) {
641 session = strappenda("_SYSTEMD_SESSION=", t);
642 free(t);
643 IOVEC_SET_STRING(iovec[n++], session);
644 }
645
646 if (cg_path_get_owner_uid(c, &owner) >= 0) {
647 owner_valid = true;
648
649 sprintf(owner_uid, "_SYSTEMD_OWNER_UID="UID_FMT, owner);
650 IOVEC_SET_STRING(iovec[n++], owner_uid);
651 }
652
653 if (cg_path_get_unit(c, &t) >= 0) {
654 x = strappenda("_SYSTEMD_UNIT=", t);
655 free(t);
656 IOVEC_SET_STRING(iovec[n++], x);
657 } else if (unit_id && !session) {
658 x = strappenda("_SYSTEMD_UNIT=", unit_id);
659 IOVEC_SET_STRING(iovec[n++], x);
660 }
661
662 if (cg_path_get_user_unit(c, &t) >= 0) {
663 x = strappenda("_SYSTEMD_USER_UNIT=", t);
664 free(t);
665 IOVEC_SET_STRING(iovec[n++], x);
666 } else if (unit_id && session) {
667 x = strappenda("_SYSTEMD_USER_UNIT=", unit_id);
668 IOVEC_SET_STRING(iovec[n++], x);
669 }
670
671 if (cg_path_get_slice(c, &t) >= 0) {
672 x = strappenda("_SYSTEMD_SLICE=", t);
673 free(t);
674 IOVEC_SET_STRING(iovec[n++], x);
675 }
676
677 free(c);
678 } else if (unit_id) {
679 x = strappenda("_SYSTEMD_UNIT=", unit_id);
680 IOVEC_SET_STRING(iovec[n++], x);
681 }
682
683 #ifdef HAVE_SELINUX
684 if (mac_selinux_use()) {
685 if (label) {
686 x = alloca(strlen("_SELINUX_CONTEXT=") + label_len + 1);
687
688 *((char*) mempcpy(stpcpy(x, "_SELINUX_CONTEXT="), label, label_len)) = 0;
689 IOVEC_SET_STRING(iovec[n++], x);
690 } else {
691 security_context_t con;
692
693 if (getpidcon(ucred->pid, &con) >= 0) {
694 x = strappenda("_SELINUX_CONTEXT=", con);
695
696 freecon(con);
697 IOVEC_SET_STRING(iovec[n++], x);
698 }
699 }
700 }
701 #endif
702 }
703 assert(n <= m);
704
705 if (object_pid) {
706 r = get_process_uid(object_pid, &object_uid);
707 if (r >= 0) {
708 sprintf(o_uid, "OBJECT_UID="UID_FMT, object_uid);
709 IOVEC_SET_STRING(iovec[n++], o_uid);
710 }
711
712 r = get_process_gid(object_pid, &object_gid);
713 if (r >= 0) {
714 sprintf(o_gid, "OBJECT_GID="GID_FMT, object_gid);
715 IOVEC_SET_STRING(iovec[n++], o_gid);
716 }
717
718 r = get_process_comm(object_pid, &t);
719 if (r >= 0) {
720 x = strappenda("OBJECT_COMM=", t);
721 free(t);
722 IOVEC_SET_STRING(iovec[n++], x);
723 }
724
725 r = get_process_exe(object_pid, &t);
726 if (r >= 0) {
727 x = strappenda("OBJECT_EXE=", t);
728 free(t);
729 IOVEC_SET_STRING(iovec[n++], x);
730 }
731
732 r = get_process_cmdline(object_pid, 0, false, &t);
733 if (r >= 0) {
734 x = strappenda("OBJECT_CMDLINE=", t);
735 free(t);
736 IOVEC_SET_STRING(iovec[n++], x);
737 }
738
739 #ifdef HAVE_AUDIT
740 r = audit_session_from_pid(object_pid, &audit);
741 if (r >= 0) {
742 sprintf(o_audit_session, "OBJECT_AUDIT_SESSION=%"PRIu32, audit);
743 IOVEC_SET_STRING(iovec[n++], o_audit_session);
744 }
745
746 r = audit_loginuid_from_pid(object_pid, &loginuid);
747 if (r >= 0) {
748 sprintf(o_audit_loginuid, "OBJECT_AUDIT_LOGINUID="UID_FMT, loginuid);
749 IOVEC_SET_STRING(iovec[n++], o_audit_loginuid);
750 }
751 #endif
752
753 r = cg_pid_get_path_shifted(object_pid, s->cgroup_root, &c);
754 if (r >= 0) {
755 x = strappenda("OBJECT_SYSTEMD_CGROUP=", c);
756 IOVEC_SET_STRING(iovec[n++], x);
757
758 r = cg_path_get_session(c, &t);
759 if (r >= 0) {
760 x = strappenda("OBJECT_SYSTEMD_SESSION=", t);
761 free(t);
762 IOVEC_SET_STRING(iovec[n++], x);
763 }
764
765 if (cg_path_get_owner_uid(c, &owner) >= 0) {
766 sprintf(o_owner_uid, "OBJECT_SYSTEMD_OWNER_UID="UID_FMT, owner);
767 IOVEC_SET_STRING(iovec[n++], o_owner_uid);
768 }
769
770 if (cg_path_get_unit(c, &t) >= 0) {
771 x = strappenda("OBJECT_SYSTEMD_UNIT=", t);
772 free(t);
773 IOVEC_SET_STRING(iovec[n++], x);
774 }
775
776 if (cg_path_get_user_unit(c, &t) >= 0) {
777 x = strappenda("OBJECT_SYSTEMD_USER_UNIT=", t);
778 free(t);
779 IOVEC_SET_STRING(iovec[n++], x);
780 }
781
782 free(c);
783 }
784 }
785 assert(n <= m);
786
787 if (tv) {
788 sprintf(source_time, "_SOURCE_REALTIME_TIMESTAMP=%llu", (unsigned long long) timeval_load(tv));
789 IOVEC_SET_STRING(iovec[n++], source_time);
790 }
791
792 /* Note that strictly speaking storing the boot id here is
793 * redundant since the entry includes this in-line
794 * anyway. However, we need this indexed, too. */
795 if (!isempty(s->boot_id_field))
796 IOVEC_SET_STRING(iovec[n++], s->boot_id_field);
797
798 if (!isempty(s->machine_id_field))
799 IOVEC_SET_STRING(iovec[n++], s->machine_id_field);
800
801 if (!isempty(s->hostname_field))
802 IOVEC_SET_STRING(iovec[n++], s->hostname_field);
803
804 assert(n <= m);
805
806 if (s->split_mode == SPLIT_UID && realuid > 0)
807 /* Split up strictly by any UID */
808 journal_uid = realuid;
809 else if (s->split_mode == SPLIT_LOGIN && realuid > 0 && owner_valid && owner > 0)
810 /* Split up by login UIDs. We do this only if the
811 * realuid is not root, in order not to accidentally
812 * leak privileged information to the user that is
813 * logged by a privileged process that is part of an
814 * unprivileged session.*/
815 journal_uid = owner;
816 else
817 journal_uid = 0;
818
819 write_to_journal(s, journal_uid, iovec, n, priority);
820 }
821
822 void server_driver_message(Server *s, sd_id128_t message_id, const char *format, ...) {
823 char mid[11 + 32 + 1];
824 char buffer[16 + LINE_MAX + 1];
825 struct iovec iovec[N_IOVEC_META_FIELDS + 4];
826 int n = 0;
827 va_list ap;
828 struct ucred ucred = {};
829
830 assert(s);
831 assert(format);
832
833 IOVEC_SET_STRING(iovec[n++], "PRIORITY=6");
834 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=driver");
835
836 memcpy(buffer, "MESSAGE=", 8);
837 va_start(ap, format);
838 vsnprintf(buffer + 8, sizeof(buffer) - 8, format, ap);
839 va_end(ap);
840 char_array_0(buffer);
841 IOVEC_SET_STRING(iovec[n++], buffer);
842
843 if (!sd_id128_equal(message_id, SD_ID128_NULL)) {
844 snprintf(mid, sizeof(mid), MESSAGE_ID(message_id));
845 char_array_0(mid);
846 IOVEC_SET_STRING(iovec[n++], mid);
847 }
848
849 ucred.pid = getpid();
850 ucred.uid = getuid();
851 ucred.gid = getgid();
852
853 dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL, LOG_INFO, 0);
854 }
855
856 void server_dispatch_message(
857 Server *s,
858 struct iovec *iovec, unsigned n, unsigned m,
859 const struct ucred *ucred,
860 const struct timeval *tv,
861 const char *label, size_t label_len,
862 const char *unit_id,
863 int priority,
864 pid_t object_pid) {
865
866 int rl, r;
867 _cleanup_free_ char *path = NULL;
868 char *c;
869
870 assert(s);
871 assert(iovec || n == 0);
872
873 if (n == 0)
874 return;
875
876 if (LOG_PRI(priority) > s->max_level_store)
877 return;
878
879 /* Stop early in case the information will not be stored
880 * in a journal. */
881 if (s->storage == STORAGE_NONE)
882 return;
883
884 if (!ucred)
885 goto finish;
886
887 r = cg_pid_get_path_shifted(ucred->pid, s->cgroup_root, &path);
888 if (r < 0)
889 goto finish;
890
891 /* example: /user/lennart/3/foobar
892 * /system/dbus.service/foobar
893 *
894 * So let's cut of everything past the third /, since that is
895 * where user directories start */
896
897 c = strchr(path, '/');
898 if (c) {
899 c = strchr(c+1, '/');
900 if (c) {
901 c = strchr(c+1, '/');
902 if (c)
903 *c = 0;
904 }
905 }
906
907 rl = journal_rate_limit_test(s->rate_limit, path,
908 priority & LOG_PRIMASK, available_space(s, false));
909
910 if (rl == 0)
911 return;
912
913 /* Write a suppression message if we suppressed something */
914 if (rl > 1)
915 server_driver_message(s, SD_MESSAGE_JOURNAL_DROPPED,
916 "Suppressed %u messages from %s", rl - 1, path);
917
918 finish:
919 dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id, priority, object_pid);
920 }
921
922
923 static int system_journal_open(Server *s, bool flush_requested) {
924 int r;
925 char *fn;
926 sd_id128_t machine;
927 char ids[33];
928
929 r = sd_id128_get_machine(&machine);
930 if (r < 0) {
931 log_error("Failed to get machine id: %s", strerror(-r));
932 return r;
933 }
934
935 sd_id128_to_string(machine, ids);
936
937 if (!s->system_journal &&
938 (s->storage == STORAGE_PERSISTENT || s->storage == STORAGE_AUTO) &&
939 (flush_requested
940 || access("/run/systemd/journal/flushed", F_OK) >= 0)) {
941
942 /* If in auto mode: first try to create the machine
943 * path, but not the prefix.
944 *
945 * If in persistent mode: create /var/log/journal and
946 * the machine path */
947
948 if (s->storage == STORAGE_PERSISTENT)
949 (void) mkdir("/var/log/journal/", 0755);
950
951 fn = strappenda("/var/log/journal/", ids);
952 (void) mkdir(fn, 0755);
953
954 fn = strappenda(fn, "/system.journal");
955 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, NULL, &s->system_journal);
956
957 if (r >= 0)
958 server_fix_perms(s, s->system_journal, 0);
959 else if (r < 0) {
960 if (r != -ENOENT && r != -EROFS)
961 log_warning("Failed to open system journal: %s", strerror(-r));
962
963 r = 0;
964 }
965 }
966
967 if (!s->runtime_journal &&
968 (s->storage != STORAGE_NONE)) {
969
970 fn = strjoin("/run/log/journal/", ids, "/system.journal", NULL);
971 if (!fn)
972 return -ENOMEM;
973
974 if (s->system_journal) {
975
976 /* Try to open the runtime journal, but only
977 * if it already exists, so that we can flush
978 * it into the system journal */
979
980 r = journal_file_open(fn, O_RDWR, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
981 free(fn);
982
983 if (r < 0) {
984 if (r != -ENOENT)
985 log_warning("Failed to open runtime journal: %s", strerror(-r));
986
987 r = 0;
988 }
989
990 } else {
991
992 /* OK, we really need the runtime journal, so create
993 * it if necessary. */
994
995 (void) mkdir("/run/log", 0755);
996 (void) mkdir("/run/log/journal", 0755);
997 (void) mkdir_parents(fn, 0750);
998
999 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
1000 free(fn);
1001
1002 if (r < 0) {
1003 log_error("Failed to open runtime journal: %s", strerror(-r));
1004 return r;
1005 }
1006 }
1007
1008 if (s->runtime_journal)
1009 server_fix_perms(s, s->runtime_journal, 0);
1010 }
1011
1012 available_space(s, true);
1013
1014 return r;
1015 }
1016
1017 int server_flush_to_var(Server *s) {
1018 sd_id128_t machine;
1019 sd_journal *j = NULL;
1020 char ts[FORMAT_TIMESPAN_MAX];
1021 usec_t start;
1022 unsigned n = 0;
1023 int r;
1024
1025 assert(s);
1026
1027 if (s->storage != STORAGE_AUTO &&
1028 s->storage != STORAGE_PERSISTENT)
1029 return 0;
1030
1031 if (!s->runtime_journal)
1032 return 0;
1033
1034 system_journal_open(s, true);
1035
1036 if (!s->system_journal)
1037 return 0;
1038
1039 log_debug("Flushing to /var...");
1040
1041 start = now(CLOCK_MONOTONIC);
1042
1043 r = sd_id128_get_machine(&machine);
1044 if (r < 0)
1045 return r;
1046
1047 r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
1048 if (r < 0) {
1049 log_error("Failed to read runtime journal: %s", strerror(-r));
1050 return r;
1051 }
1052
1053 sd_journal_set_data_threshold(j, 0);
1054
1055 SD_JOURNAL_FOREACH(j) {
1056 Object *o = NULL;
1057 JournalFile *f;
1058
1059 f = j->current_file;
1060 assert(f && f->current_offset > 0);
1061
1062 n++;
1063
1064 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
1065 if (r < 0) {
1066 log_error("Can't read entry: %s", strerror(-r));
1067 goto finish;
1068 }
1069
1070 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
1071 if (r >= 0)
1072 continue;
1073
1074 if (!shall_try_append_again(s->system_journal, r)) {
1075 log_error("Can't write entry: %s", strerror(-r));
1076 goto finish;
1077 }
1078
1079 server_rotate(s);
1080 server_vacuum(s);
1081
1082 if (!s->system_journal) {
1083 log_notice("Didn't flush runtime journal since rotation of system journal wasn't successful.");
1084 r = -EIO;
1085 goto finish;
1086 }
1087
1088 log_debug("Retrying write.");
1089 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
1090 if (r < 0) {
1091 log_error("Can't write entry: %s", strerror(-r));
1092 goto finish;
1093 }
1094 }
1095
1096 finish:
1097 journal_file_post_change(s->system_journal);
1098
1099 journal_file_close(s->runtime_journal);
1100 s->runtime_journal = NULL;
1101
1102 if (r >= 0)
1103 rm_rf("/run/log/journal", false, true, false);
1104
1105 sd_journal_close(j);
1106
1107 server_driver_message(s, SD_ID128_NULL, "Time spent on flushing to /var is %s for %u entries.", format_timespan(ts, sizeof(ts), now(CLOCK_MONOTONIC) - start, 0), n);
1108
1109 return r;
1110 }
1111
1112 int process_datagram(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
1113 Server *s = userdata;
1114
1115 assert(s);
1116 assert(fd == s->native_fd || fd == s->syslog_fd || fd == s->audit_fd);
1117
1118 if (revents != EPOLLIN) {
1119 log_error("Got invalid event from epoll for datagram fd: %"PRIx32, revents);
1120 return -EIO;
1121 }
1122
1123 for (;;) {
1124 struct ucred *ucred = NULL;
1125 struct timeval *tv = NULL;
1126 struct cmsghdr *cmsg;
1127 char *label = NULL;
1128 size_t label_len = 0;
1129 struct iovec iovec;
1130
1131 union {
1132 struct cmsghdr cmsghdr;
1133
1134 /* We use NAME_MAX space for the SELinux label
1135 * here. The kernel currently enforces no
1136 * limit, but according to suggestions from
1137 * the SELinux people this will change and it
1138 * will probably be identical to NAME_MAX. For
1139 * now we use that, but this should be updated
1140 * one day when the final limit is known.*/
1141 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1142 CMSG_SPACE(sizeof(struct timeval)) +
1143 CMSG_SPACE(sizeof(int)) + /* fd */
1144 CMSG_SPACE(NAME_MAX)]; /* selinux label */
1145 } control = {};
1146 union sockaddr_union sa = {};
1147 struct msghdr msghdr = {
1148 .msg_iov = &iovec,
1149 .msg_iovlen = 1,
1150 .msg_control = &control,
1151 .msg_controllen = sizeof(control),
1152 .msg_name = &sa,
1153 .msg_namelen = sizeof(sa),
1154 };
1155
1156 ssize_t n;
1157 int *fds = NULL;
1158 unsigned n_fds = 0;
1159 int v = 0;
1160 size_t m;
1161
1162 /* Try to get the right size, if we can. (Not all
1163 * sockets support SIOCINQ, hence we just try, but
1164 * don't rely on it. */
1165 (void) ioctl(fd, SIOCINQ, &v);
1166
1167 /* Fix it up, if it is too small. We use the same fixed value as auditd here. Awful!*/
1168 m = PAGE_ALIGN(MAX3((size_t) v + 1,
1169 (size_t) LINE_MAX,
1170 ALIGN(sizeof(struct nlmsghdr)) + ALIGN((size_t) MAX_AUDIT_MESSAGE_LENGTH)) + 1);
1171
1172 if (!GREEDY_REALLOC(s->buffer, s->buffer_size, m))
1173 return log_oom();
1174
1175 iovec.iov_base = s->buffer;
1176 iovec.iov_len = s->buffer_size - 1; /* Leave room for trailing NUL we add later */
1177
1178 n = recvmsg(fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1179 if (n < 0) {
1180 if (errno == EINTR || errno == EAGAIN)
1181 return 0;
1182
1183 log_error("recvmsg() failed: %m");
1184 return -errno;
1185 }
1186
1187 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1188
1189 if (cmsg->cmsg_level == SOL_SOCKET &&
1190 cmsg->cmsg_type == SCM_CREDENTIALS &&
1191 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
1192 ucred = (struct ucred*) CMSG_DATA(cmsg);
1193 else if (cmsg->cmsg_level == SOL_SOCKET &&
1194 cmsg->cmsg_type == SCM_SECURITY) {
1195 label = (char*) CMSG_DATA(cmsg);
1196 label_len = cmsg->cmsg_len - CMSG_LEN(0);
1197 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1198 cmsg->cmsg_type == SO_TIMESTAMP &&
1199 cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
1200 tv = (struct timeval*) CMSG_DATA(cmsg);
1201 else if (cmsg->cmsg_level == SOL_SOCKET &&
1202 cmsg->cmsg_type == SCM_RIGHTS) {
1203 fds = (int*) CMSG_DATA(cmsg);
1204 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1205 }
1206 }
1207
1208 /* And a trailing NUL, just in case */
1209 s->buffer[n] = 0;
1210
1211 if (fd == s->syslog_fd) {
1212 if (n > 0 && n_fds == 0)
1213 server_process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);
1214 else if (n_fds > 0)
1215 log_warning("Got file descriptors via syslog socket. Ignoring.");
1216
1217 } else if (fd == s->native_fd) {
1218 if (n > 0 && n_fds == 0)
1219 server_process_native_message(s, s->buffer, n, ucred, tv, label, label_len);
1220 else if (n == 0 && n_fds == 1)
1221 server_process_native_file(s, fds[0], ucred, tv, label, label_len);
1222 else if (n_fds > 0)
1223 log_warning("Got too many file descriptors via native socket. Ignoring.");
1224
1225 } else {
1226 assert(fd == s->audit_fd);
1227
1228 if (n > 0 && n_fds == 0)
1229 server_process_audit_message(s, s->buffer, n, ucred, &sa, msghdr.msg_namelen);
1230 else if (n_fds > 0)
1231 log_warning("Got file descriptors via audit socket. Ignoring.");
1232 }
1233
1234 close_many(fds, n_fds);
1235 }
1236 }
1237
1238 static int dispatch_sigusr1(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) {
1239 Server *s = userdata;
1240
1241 assert(s);
1242
1243 log_info("Received request to flush runtime journal from PID %"PRIu32, si->ssi_pid);
1244
1245 server_flush_to_var(s);
1246 server_sync(s);
1247 server_vacuum(s);
1248
1249 touch("/run/systemd/journal/flushed");
1250
1251 return 0;
1252 }
1253
1254 static int dispatch_sigusr2(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) {
1255 Server *s = userdata;
1256
1257 assert(s);
1258
1259 log_info("Received request to rotate journal from PID %"PRIu32, si->ssi_pid);
1260 server_rotate(s);
1261 server_vacuum(s);
1262
1263 return 0;
1264 }
1265
1266 static int dispatch_sigterm(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) {
1267 Server *s = userdata;
1268
1269 assert(s);
1270
1271 log_received_signal(LOG_INFO, si);
1272
1273 sd_event_exit(s->event, 0);
1274 return 0;
1275 }
1276
1277 static int setup_signals(Server *s) {
1278 sigset_t mask;
1279 int r;
1280
1281 assert(s);
1282
1283 assert_se(sigemptyset(&mask) == 0);
1284 sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
1285 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
1286
1287 r = sd_event_add_signal(s->event, &s->sigusr1_event_source, SIGUSR1, dispatch_sigusr1, s);
1288 if (r < 0)
1289 return r;
1290
1291 r = sd_event_add_signal(s->event, &s->sigusr2_event_source, SIGUSR2, dispatch_sigusr2, s);
1292 if (r < 0)
1293 return r;
1294
1295 r = sd_event_add_signal(s->event, &s->sigterm_event_source, SIGTERM, dispatch_sigterm, s);
1296 if (r < 0)
1297 return r;
1298
1299 r = sd_event_add_signal(s->event, &s->sigint_event_source, SIGINT, dispatch_sigterm, s);
1300 if (r < 0)
1301 return r;
1302
1303 return 0;
1304 }
1305
1306 static int server_parse_proc_cmdline(Server *s) {
1307 _cleanup_free_ char *line = NULL;
1308 const char *w, *state;
1309 size_t l;
1310 int r;
1311
1312 r = proc_cmdline(&line);
1313 if (r < 0)
1314 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
1315 if (r <= 0)
1316 return 0;
1317
1318 FOREACH_WORD_QUOTED(w, l, line, state) {
1319 _cleanup_free_ char *word;
1320
1321 word = strndup(w, l);
1322 if (!word)
1323 return -ENOMEM;
1324
1325 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
1326 r = parse_boolean(word + 35);
1327 if (r < 0)
1328 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
1329 else
1330 s->forward_to_syslog = r;
1331 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
1332 r = parse_boolean(word + 33);
1333 if (r < 0)
1334 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
1335 else
1336 s->forward_to_kmsg = r;
1337 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
1338 r = parse_boolean(word + 36);
1339 if (r < 0)
1340 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
1341 else
1342 s->forward_to_console = r;
1343 } else if (startswith(word, "systemd.journald.forward_to_wall=")) {
1344 r = parse_boolean(word + 33);
1345 if (r < 0)
1346 log_warning("Failed to parse forward to wall switch %s. Ignoring.", word + 33);
1347 else
1348 s->forward_to_wall = r;
1349 } else if (startswith(word, "systemd.journald"))
1350 log_warning("Invalid systemd.journald parameter. Ignoring.");
1351 }
1352 /* do not warn about state here, since probably systemd already did */
1353
1354 return 0;
1355 }
1356
1357 static int server_parse_config_file(Server *s) {
1358 assert(s);
1359
1360 return config_parse(NULL, "/etc/systemd/journald.conf", NULL,
1361 "Journal\0",
1362 config_item_perf_lookup, journald_gperf_lookup,
1363 false, false, true, s);
1364 }
1365
1366 static int server_dispatch_sync(sd_event_source *es, usec_t t, void *userdata) {
1367 Server *s = userdata;
1368
1369 assert(s);
1370
1371 server_sync(s);
1372 return 0;
1373 }
1374
1375 int server_schedule_sync(Server *s, int priority) {
1376 int r;
1377
1378 assert(s);
1379
1380 if (priority <= LOG_CRIT) {
1381 /* Immediately sync to disk when this is of priority CRIT, ALERT, EMERG */
1382 server_sync(s);
1383 return 0;
1384 }
1385
1386 if (s->sync_scheduled)
1387 return 0;
1388
1389 if (s->sync_interval_usec > 0) {
1390 usec_t when;
1391
1392 r = sd_event_now(s->event, CLOCK_MONOTONIC, &when);
1393 if (r < 0)
1394 return r;
1395
1396 when += s->sync_interval_usec;
1397
1398 if (!s->sync_event_source) {
1399 r = sd_event_add_time(
1400 s->event,
1401 &s->sync_event_source,
1402 CLOCK_MONOTONIC,
1403 when, 0,
1404 server_dispatch_sync, s);
1405 if (r < 0)
1406 return r;
1407
1408 r = sd_event_source_set_priority(s->sync_event_source, SD_EVENT_PRIORITY_IMPORTANT);
1409 } else {
1410 r = sd_event_source_set_time(s->sync_event_source, when);
1411 if (r < 0)
1412 return r;
1413
1414 r = sd_event_source_set_enabled(s->sync_event_source, SD_EVENT_ONESHOT);
1415 }
1416 if (r < 0)
1417 return r;
1418
1419 s->sync_scheduled = true;
1420 }
1421
1422 return 0;
1423 }
1424
1425 static int dispatch_hostname_change(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
1426 Server *s = userdata;
1427
1428 assert(s);
1429
1430 server_cache_hostname(s);
1431 return 0;
1432 }
1433
1434 static int server_open_hostname(Server *s) {
1435 int r;
1436
1437 assert(s);
1438
1439 s->hostname_fd = open("/proc/sys/kernel/hostname", O_RDONLY|O_CLOEXEC|O_NDELAY|O_NOCTTY);
1440 if (s->hostname_fd < 0) {
1441 log_error("Failed to open /proc/sys/kernel/hostname: %m");
1442 return -errno;
1443 }
1444
1445 r = sd_event_add_io(s->event, &s->hostname_event_source, s->hostname_fd, 0, dispatch_hostname_change, s);
1446 if (r < 0) {
1447 /* kernels prior to 3.2 don't support polling this file. Ignore
1448 * the failure. */
1449 if (r == -EPERM) {
1450 log_warning("Failed to register hostname fd in event loop: %s. Ignoring.",
1451 strerror(-r));
1452 s->hostname_fd = safe_close(s->hostname_fd);
1453 return 0;
1454 }
1455
1456 log_error("Failed to register hostname fd in event loop: %s", strerror(-r));
1457 return r;
1458 }
1459
1460 r = sd_event_source_set_priority(s->hostname_event_source, SD_EVENT_PRIORITY_IMPORTANT-10);
1461 if (r < 0) {
1462 log_error("Failed to adjust priority of host name event source: %s", strerror(-r));
1463 return r;
1464 }
1465
1466 return 0;
1467 }
1468
1469 int server_init(Server *s) {
1470 int n, r, fd;
1471
1472 assert(s);
1473
1474 zero(*s);
1475 s->syslog_fd = s->native_fd = s->stdout_fd = s->dev_kmsg_fd = s->audit_fd = s->hostname_fd = -1;
1476 s->compress = true;
1477 s->seal = true;
1478
1479 s->sync_interval_usec = DEFAULT_SYNC_INTERVAL_USEC;
1480 s->sync_scheduled = false;
1481
1482 s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
1483 s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
1484
1485 s->forward_to_wall = true;
1486
1487 s->max_file_usec = DEFAULT_MAX_FILE_USEC;
1488
1489 s->max_level_store = LOG_DEBUG;
1490 s->max_level_syslog = LOG_DEBUG;
1491 s->max_level_kmsg = LOG_NOTICE;
1492 s->max_level_console = LOG_INFO;
1493 s->max_level_wall = LOG_EMERG;
1494
1495 memset(&s->system_metrics, 0xFF, sizeof(s->system_metrics));
1496 memset(&s->runtime_metrics, 0xFF, sizeof(s->runtime_metrics));
1497
1498 server_parse_config_file(s);
1499 server_parse_proc_cmdline(s);
1500 if (!!s->rate_limit_interval ^ !!s->rate_limit_burst) {
1501 log_debug("Setting both rate limit interval and burst from "USEC_FMT",%u to 0,0",
1502 s->rate_limit_interval, s->rate_limit_burst);
1503 s->rate_limit_interval = s->rate_limit_burst = 0;
1504 }
1505
1506 mkdir_p("/run/systemd/journal", 0755);
1507
1508 s->user_journals = ordered_hashmap_new(NULL);
1509 if (!s->user_journals)
1510 return log_oom();
1511
1512 s->mmap = mmap_cache_new();
1513 if (!s->mmap)
1514 return log_oom();
1515
1516 r = sd_event_default(&s->event);
1517 if (r < 0) {
1518 log_error("Failed to create event loop: %s", strerror(-r));
1519 return r;
1520 }
1521
1522 sd_event_set_watchdog(s->event, true);
1523
1524 n = sd_listen_fds(true);
1525 if (n < 0) {
1526 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
1527 return n;
1528 }
1529
1530 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
1531
1532 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
1533
1534 if (s->native_fd >= 0) {
1535 log_error("Too many native sockets passed.");
1536 return -EINVAL;
1537 }
1538
1539 s->native_fd = fd;
1540
1541 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
1542
1543 if (s->stdout_fd >= 0) {
1544 log_error("Too many stdout sockets passed.");
1545 return -EINVAL;
1546 }
1547
1548 s->stdout_fd = fd;
1549
1550 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0 ||
1551 sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/dev-log", 0) > 0) {
1552
1553 if (s->syslog_fd >= 0) {
1554 log_error("Too many /dev/log sockets passed.");
1555 return -EINVAL;
1556 }
1557
1558 s->syslog_fd = fd;
1559
1560 } else if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
1561
1562 if (s->audit_fd >= 0) {
1563 log_error("Too many audit sockets passed.");
1564 return -EINVAL;
1565 }
1566
1567 s->audit_fd = fd;
1568
1569 } else {
1570 log_error("Unknown socket passed.");
1571 return -EINVAL;
1572 }
1573 }
1574
1575 r = server_open_syslog_socket(s);
1576 if (r < 0)
1577 return r;
1578
1579 r = server_open_native_socket(s);
1580 if (r < 0)
1581 return r;
1582
1583 r = server_open_stdout_socket(s);
1584 if (r < 0)
1585 return r;
1586
1587 r = server_open_dev_kmsg(s);
1588 if (r < 0)
1589 return r;
1590
1591 r = server_open_audit(s);
1592 if (r < 0)
1593 return r;
1594
1595 r = server_open_kernel_seqnum(s);
1596 if (r < 0)
1597 return r;
1598
1599 r = server_open_hostname(s);
1600 if (r < 0)
1601 return r;
1602
1603 r = setup_signals(s);
1604 if (r < 0)
1605 return r;
1606
1607 s->udev = udev_new();
1608 if (!s->udev)
1609 return -ENOMEM;
1610
1611 s->rate_limit = journal_rate_limit_new(s->rate_limit_interval, s->rate_limit_burst);
1612 if (!s->rate_limit)
1613 return -ENOMEM;
1614
1615 r = cg_get_root_path(&s->cgroup_root);
1616 if (r < 0)
1617 return r;
1618
1619 server_cache_hostname(s);
1620 server_cache_boot_id(s);
1621 server_cache_machine_id(s);
1622
1623 r = system_journal_open(s, false);
1624 if (r < 0)
1625 return r;
1626
1627 return 0;
1628 }
1629
1630 void server_maybe_append_tags(Server *s) {
1631 #ifdef HAVE_GCRYPT
1632 JournalFile *f;
1633 Iterator i;
1634 usec_t n;
1635
1636 n = now(CLOCK_REALTIME);
1637
1638 if (s->system_journal)
1639 journal_file_maybe_append_tag(s->system_journal, n);
1640
1641 ORDERED_HASHMAP_FOREACH(f, s->user_journals, i)
1642 journal_file_maybe_append_tag(f, n);
1643 #endif
1644 }
1645
1646 void server_done(Server *s) {
1647 JournalFile *f;
1648 assert(s);
1649
1650 while (s->stdout_streams)
1651 stdout_stream_free(s->stdout_streams);
1652
1653 if (s->system_journal)
1654 journal_file_close(s->system_journal);
1655
1656 if (s->runtime_journal)
1657 journal_file_close(s->runtime_journal);
1658
1659 while ((f = ordered_hashmap_steal_first(s->user_journals)))
1660 journal_file_close(f);
1661
1662 ordered_hashmap_free(s->user_journals);
1663
1664 sd_event_source_unref(s->syslog_event_source);
1665 sd_event_source_unref(s->native_event_source);
1666 sd_event_source_unref(s->stdout_event_source);
1667 sd_event_source_unref(s->dev_kmsg_event_source);
1668 sd_event_source_unref(s->audit_event_source);
1669 sd_event_source_unref(s->sync_event_source);
1670 sd_event_source_unref(s->sigusr1_event_source);
1671 sd_event_source_unref(s->sigusr2_event_source);
1672 sd_event_source_unref(s->sigterm_event_source);
1673 sd_event_source_unref(s->sigint_event_source);
1674 sd_event_source_unref(s->hostname_event_source);
1675 sd_event_unref(s->event);
1676
1677 safe_close(s->syslog_fd);
1678 safe_close(s->native_fd);
1679 safe_close(s->stdout_fd);
1680 safe_close(s->dev_kmsg_fd);
1681 safe_close(s->audit_fd);
1682 safe_close(s->hostname_fd);
1683
1684 if (s->rate_limit)
1685 journal_rate_limit_free(s->rate_limit);
1686
1687 if (s->kernel_seqnum)
1688 munmap(s->kernel_seqnum, sizeof(uint64_t));
1689
1690 free(s->buffer);
1691 free(s->tty_path);
1692 free(s->cgroup_root);
1693 free(s->hostname_field);
1694
1695 if (s->mmap)
1696 mmap_cache_unref(s->mmap);
1697
1698 if (s->udev)
1699 udev_unref(s->udev);
1700 }
Unnamed repository; edit this file 'description' to name the repository.