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