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