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