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