]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/journal/journald-server.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
journald: use structured message + catalog entry for disk usage
[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 "alloc-util.h"
38 #include "audit-util.h"
39 #include "cgroup-util.h"
40 #include "conf-parser.h"
41 #include "dirent-util.h"
42 #include "extract-word.h"
43 #include "fd-util.h"
44 #include "fileio.h"
45 #include "formats-util.h"
46 #include "fs-util.h"
47 #include "hashmap.h"
48 #include "hostname-util.h"
49 #include "io-util.h"
50 #include "journal-authenticate.h"
51 #include "journal-file.h"
52 #include "journal-internal.h"
53 #include "journal-vacuum.h"
54 #include "journald-audit.h"
55 #include "journald-kmsg.h"
56 #include "journald-native.h"
57 #include "journald-rate-limit.h"
58 #include "journald-server.h"
59 #include "journald-stream.h"
60 #include "journald-syslog.h"
61 #include "missing.h"
62 #include "mkdir.h"
63 #include "parse-util.h"
64 #include "proc-cmdline.h"
65 #include "process-util.h"
66 #include "rm-rf.h"
67 #include "selinux-util.h"
68 #include "signal-util.h"
69 #include "socket-util.h"
70 #include "string-table.h"
71 #include "string-util.h"
72 #include "user-util.h"
73 #include "log.h"
74
75 #define USER_JOURNALS_MAX 1024
76
77 #define DEFAULT_SYNC_INTERVAL_USEC (5*USEC_PER_MINUTE)
78 #define DEFAULT_RATE_LIMIT_INTERVAL (30*USEC_PER_SEC)
79 #define DEFAULT_RATE_LIMIT_BURST 1000
80 #define DEFAULT_MAX_FILE_USEC USEC_PER_MONTH
81
82 #define RECHECK_SPACE_USEC (30*USEC_PER_SEC)
83
84 #define NOTIFY_SNDBUF_SIZE (8*1024*1024)
85
86 static int determine_space_for(
87 Server *s,
88 JournalMetrics *metrics,
89 const char *path,
90 const char *name,
91 bool verbose,
92 bool patch_min_use,
93 uint64_t *available,
94 uint64_t *limit) {
95
96 uint64_t sum = 0, ss_avail, avail;
97 _cleanup_closedir_ DIR *d = NULL;
98 struct dirent *de;
99 struct statvfs ss;
100 const char *p;
101 usec_t ts;
102
103 assert(s);
104 assert(metrics);
105 assert(path);
106 assert(name);
107
108 ts = now(CLOCK_MONOTONIC);
109
110 if (!verbose && s->cached_space_timestamp + RECHECK_SPACE_USEC > ts) {
111
112 if (available)
113 *available = s->cached_space_available;
114 if (limit)
115 *limit = s->cached_space_limit;
116
117 return 0;
118 }
119
120 p = strjoina(path, SERVER_MACHINE_ID(s));
121 d = opendir(p);
122 if (!d)
123 return log_full_errno(errno == ENOENT ? LOG_DEBUG : LOG_ERR, errno, "Failed to open %s: %m", p);
124
125 if (fstatvfs(dirfd(d), &ss) < 0)
126 return log_error_errno(errno, "Failed to fstatvfs(%s): %m", p);
127
128 FOREACH_DIRENT_ALL(de, d, break) {
129 struct stat st;
130
131 if (!endswith(de->d_name, ".journal") &&
132 !endswith(de->d_name, ".journal~"))
133 continue;
134
135 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
136 log_debug_errno(errno, "Failed to stat %s/%s, ignoring: %m", p, de->d_name);
137 continue;
138 }
139
140 if (!S_ISREG(st.st_mode))
141 continue;
142
143 sum += (uint64_t) st.st_blocks * 512UL;
144 }
145
146 /* If requested, then let's bump the min_use limit to the
147 * current usage on disk. We do this when starting up and
148 * first opening the journal files. This way sudden spikes in
149 * disk usage will not cause journald to vacuum files without
150 * bounds. Note that this means that only a restart of
151 * journald will make it reset this value. */
152
153 if (patch_min_use)
154 metrics->min_use = MAX(metrics->min_use, sum);
155
156 ss_avail = ss.f_bsize * ss.f_bavail;
157 avail = LESS_BY(ss_avail, metrics->keep_free);
158
159 s->cached_space_limit = MIN(MAX(sum + avail, metrics->min_use), metrics->max_use);
160 s->cached_space_available = LESS_BY(s->cached_space_limit, sum);
161 s->cached_space_timestamp = ts;
162
163 if (verbose) {
164 char fb1[FORMAT_BYTES_MAX], fb2[FORMAT_BYTES_MAX], fb3[FORMAT_BYTES_MAX],
165 fb4[FORMAT_BYTES_MAX], fb5[FORMAT_BYTES_MAX], fb6[FORMAT_BYTES_MAX];
166 format_bytes(fb1, sizeof(fb1), sum);
167 format_bytes(fb2, sizeof(fb2), metrics->max_use);
168 format_bytes(fb3, sizeof(fb3), metrics->keep_free);
169 format_bytes(fb4, sizeof(fb4), ss_avail);
170 format_bytes(fb5, sizeof(fb5), s->cached_space_limit);
171 format_bytes(fb6, sizeof(fb6), s->cached_space_available);
172
173 server_driver_message(s, SD_MESSAGE_JOURNAL_USAGE,
174 LOG_MESSAGE("%s (%s) is %s, max %s, %s free.",
175 name, path, fb1, fb5, fb6),
176 "JOURNAL_NAME=%s", name,
177 "JOURNAL_PATH=%s", path,
178 "CURRENT_USE=%"PRIu64, sum,
179 "CURRENT_USE_PRETTY=%s", fb1,
180 "MAX_USE=%"PRIu64, metrics->max_use,
181 "MAX_USE_PRETTY=%s", fb2,
182 "DISK_KEEP_FREE=%"PRIu64, metrics->keep_free,
183 "DISK_KEEP_FREE_PRETTY=%s", fb3,
184 "DISK_AVAILABLE=%"PRIu64, ss_avail,
185 "DISK_AVAILABLE_PRETTY=%s", fb4,
186 "LIMIT=%"PRIu64, s->cached_space_limit,
187 "LIMIT_PRETTY=%s", fb5,
188 "AVAILABLE=%"PRIu64, s->cached_space_available,
189 "AVAILABLE_PRETTY=%s", fb6,
190 NULL);
191 }
192
193 if (available)
194 *available = s->cached_space_available;
195 if (limit)
196 *limit = s->cached_space_limit;
197
198 return 1;
199 }
200
201 static int determine_space(Server *s, bool verbose, bool patch_min_use, uint64_t *available, uint64_t *limit) {
202 JournalMetrics *metrics;
203 const char *path, *name;
204
205 assert(s);
206
207 if (s->system_journal) {
208 path = "/var/log/journal/";
209 metrics = &s->system_metrics;
210 name = "System journal";
211 } else {
212 path = "/run/log/journal/";
213 metrics = &s->runtime_metrics;
214 name = "Runtime journal";
215 }
216
217 return determine_space_for(s, metrics, path, name, verbose, patch_min_use, available, limit);
218 }
219
220 static void server_add_acls(JournalFile *f, uid_t uid) {
221 #ifdef HAVE_ACL
222 int r;
223 #endif
224 assert(f);
225
226 #ifdef HAVE_ACL
227 if (uid <= SYSTEM_UID_MAX)
228 return;
229
230 r = add_acls_for_user(f->fd, uid);
231 if (r < 0)
232 log_warning_errno(r, "Failed to set ACL on %s, ignoring: %m", f->path);
233 #endif
234 }
235
236 static JournalFile* find_journal(Server *s, uid_t uid) {
237 _cleanup_free_ char *p = NULL;
238 int r;
239 JournalFile *f;
240 sd_id128_t machine;
241
242 assert(s);
243
244 /* We split up user logs only on /var, not on /run. If the
245 * runtime file is open, we write to it exclusively, in order
246 * to guarantee proper order as soon as we flush /run to
247 * /var and close the runtime file. */
248
249 if (s->runtime_journal)
250 return s->runtime_journal;
251
252 if (uid <= SYSTEM_UID_MAX)
253 return s->system_journal;
254
255 r = sd_id128_get_machine(&machine);
256 if (r < 0)
257 return s->system_journal;
258
259 f = ordered_hashmap_get(s->user_journals, UID_TO_PTR(uid));
260 if (f)
261 return f;
262
263 if (asprintf(&p, "/var/log/journal/" SD_ID128_FORMAT_STR "/user-"UID_FMT".journal",
264 SD_ID128_FORMAT_VAL(machine), uid) < 0)
265 return s->system_journal;
266
267 while (ordered_hashmap_size(s->user_journals) >= USER_JOURNALS_MAX) {
268 /* Too many open? Then let's close one */
269 f = ordered_hashmap_steal_first(s->user_journals);
270 assert(f);
271 journal_file_close(f);
272 }
273
274 r = journal_file_open_reliably(p, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, NULL, &f);
275 if (r < 0)
276 return s->system_journal;
277
278 server_add_acls(f, uid);
279
280 r = ordered_hashmap_put(s->user_journals, UID_TO_PTR(uid), f);
281 if (r < 0) {
282 journal_file_close(f);
283 return s->system_journal;
284 }
285
286 return f;
287 }
288
289 static int do_rotate(
290 Server *s,
291 JournalFile **f,
292 const char* name,
293 bool seal,
294 uint32_t uid) {
295
296 int r;
297 assert(s);
298
299 if (!*f)
300 return -EINVAL;
301
302 r = journal_file_rotate(f, s->compress, seal);
303 if (r < 0)
304 if (*f)
305 log_error_errno(r, "Failed to rotate %s: %m", (*f)->path);
306 else
307 log_error_errno(r, "Failed to create new %s journal: %m", name);
308 else
309 server_add_acls(*f, uid);
310
311 return r;
312 }
313
314 void server_rotate(Server *s) {
315 JournalFile *f;
316 void *k;
317 Iterator i;
318 int r;
319
320 log_debug("Rotating...");
321
322 (void) do_rotate(s, &s->runtime_journal, "runtime", false, 0);
323 (void) do_rotate(s, &s->system_journal, "system", s->seal, 0);
324
325 ORDERED_HASHMAP_FOREACH_KEY(f, k, s->user_journals, i) {
326 r = do_rotate(s, &f, "user", s->seal, PTR_TO_UID(k));
327 if (r >= 0)
328 ordered_hashmap_replace(s->user_journals, k, f);
329 else if (!f)
330 /* Old file has been closed and deallocated */
331 ordered_hashmap_remove(s->user_journals, k);
332 }
333 }
334
335 void server_sync(Server *s) {
336 JournalFile *f;
337 Iterator i;
338 int r;
339
340 if (s->system_journal) {
341 r = journal_file_set_offline(s->system_journal);
342 if (r < 0)
343 log_warning_errno(r, "Failed to sync system journal, ignoring: %m");
344 }
345
346 ORDERED_HASHMAP_FOREACH(f, s->user_journals, i) {
347 r = journal_file_set_offline(f);
348 if (r < 0)
349 log_warning_errno(r, "Failed to sync user journal, ignoring: %m");
350 }
351
352 if (s->sync_event_source) {
353 r = sd_event_source_set_enabled(s->sync_event_source, SD_EVENT_OFF);
354 if (r < 0)
355 log_error_errno(r, "Failed to disable sync timer source: %m");
356 }
357
358 s->sync_scheduled = false;
359 }
360
361 static void do_vacuum(
362 Server *s,
363 JournalFile *f,
364 JournalMetrics *metrics,
365 const char *path,
366 const char *name,
367 bool verbose,
368 bool patch_min_use) {
369
370 const char *p;
371 uint64_t limit;
372 int r;
373
374 assert(s);
375 assert(metrics);
376 assert(path);
377 assert(name);
378
379 if (!f)
380 return;
381
382 p = strjoina(path, SERVER_MACHINE_ID(s));
383
384 limit = metrics->max_use;
385 (void) determine_space_for(s, metrics, path, name, verbose, patch_min_use, NULL, &limit);
386
387 r = journal_directory_vacuum(p, limit, metrics->n_max_files, s->max_retention_usec, &s->oldest_file_usec, verbose);
388 if (r < 0 && r != -ENOENT)
389 log_warning_errno(r, "Failed to vacuum %s, ignoring: %m", p);
390 }
391
392 int server_vacuum(Server *s, bool verbose, bool patch_min_use) {
393 assert(s);
394
395 log_debug("Vacuuming...");
396
397 s->oldest_file_usec = 0;
398
399 do_vacuum(s, s->system_journal, &s->system_metrics, "/var/log/journal/", "System journal", verbose, patch_min_use);
400 do_vacuum(s, s->runtime_journal, &s->runtime_metrics, "/run/log/journal/", "Runtime journal", verbose, patch_min_use);
401
402 s->cached_space_limit = 0;
403 s->cached_space_available = 0;
404 s->cached_space_timestamp = 0;
405
406 return 0;
407 }
408
409 static void server_cache_machine_id(Server *s) {
410 sd_id128_t id;
411 int r;
412
413 assert(s);
414
415 r = sd_id128_get_machine(&id);
416 if (r < 0)
417 return;
418
419 sd_id128_to_string(id, stpcpy(s->machine_id_field, "_MACHINE_ID="));
420 }
421
422 static void server_cache_boot_id(Server *s) {
423 sd_id128_t id;
424 int r;
425
426 assert(s);
427
428 r = sd_id128_get_boot(&id);
429 if (r < 0)
430 return;
431
432 sd_id128_to_string(id, stpcpy(s->boot_id_field, "_BOOT_ID="));
433 }
434
435 static void server_cache_hostname(Server *s) {
436 _cleanup_free_ char *t = NULL;
437 char *x;
438
439 assert(s);
440
441 t = gethostname_malloc();
442 if (!t)
443 return;
444
445 x = strappend("_HOSTNAME=", t);
446 if (!x)
447 return;
448
449 free(s->hostname_field);
450 s->hostname_field = x;
451 }
452
453 static bool shall_try_append_again(JournalFile *f, int r) {
454
455 /* -E2BIG Hit configured limit
456 -EFBIG Hit fs limit
457 -EDQUOT Quota limit hit
458 -ENOSPC Disk full
459 -EIO I/O error of some kind (mmap)
460 -EHOSTDOWN Other machine
461 -EBUSY Unclean shutdown
462 -EPROTONOSUPPORT Unsupported feature
463 -EBADMSG Corrupted
464 -ENODATA Truncated
465 -ESHUTDOWN Already archived
466 -EIDRM Journal file has been deleted */
467
468 if (r == -E2BIG || r == -EFBIG || r == -EDQUOT || r == -ENOSPC)
469 log_debug("%s: Allocation limit reached, rotating.", f->path);
470 else if (r == -EHOSTDOWN)
471 log_info("%s: Journal file from other machine, rotating.", f->path);
472 else if (r == -EBUSY)
473 log_info("%s: Unclean shutdown, rotating.", f->path);
474 else if (r == -EPROTONOSUPPORT)
475 log_info("%s: Unsupported feature, rotating.", f->path);
476 else if (r == -EBADMSG || r == -ENODATA || r == ESHUTDOWN)
477 log_warning("%s: Journal file corrupted, rotating.", f->path);
478 else if (r == -EIO)
479 log_warning("%s: IO error, rotating.", f->path);
480 else if (r == -EIDRM)
481 log_warning("%s: Journal file has been deleted, rotating.", f->path);
482 else
483 return false;
484
485 return true;
486 }
487
488 static void write_to_journal(Server *s, uid_t uid, struct iovec *iovec, unsigned n, int priority) {
489 JournalFile *f;
490 bool vacuumed = false;
491 int r;
492
493 assert(s);
494 assert(iovec);
495 assert(n > 0);
496
497 f = find_journal(s, uid);
498 if (!f)
499 return;
500
501 if (journal_file_rotate_suggested(f, s->max_file_usec)) {
502 log_debug("%s: Journal header limits reached or header out-of-date, rotating.", f->path);
503 server_rotate(s);
504 server_vacuum(s, false, false);
505 vacuumed = true;
506
507 f = find_journal(s, uid);
508 if (!f)
509 return;
510 }
511
512 r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL);
513 if (r >= 0) {
514 server_schedule_sync(s, priority);
515 return;
516 }
517
518 if (vacuumed || !shall_try_append_again(f, r)) {
519 log_error_errno(r, "Failed to write entry (%d items, %zu bytes), ignoring: %m", n, IOVEC_TOTAL_SIZE(iovec, n));
520 return;
521 }
522
523 server_rotate(s);
524 server_vacuum(s, false, false);
525
526 f = find_journal(s, uid);
527 if (!f)
528 return;
529
530 log_debug("Retrying write.");
531 r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL);
532 if (r < 0)
533 log_error_errno(r, "Failed to write entry (%d items, %zu bytes) despite vacuuming, ignoring: %m", n, IOVEC_TOTAL_SIZE(iovec, n));
534 else
535 server_schedule_sync(s, priority);
536 }
537
538 static void dispatch_message_real(
539 Server *s,
540 struct iovec *iovec, unsigned n, unsigned m,
541 const struct ucred *ucred,
542 const struct timeval *tv,
543 const char *label, size_t label_len,
544 const char *unit_id,
545 int priority,
546 pid_t object_pid) {
547
548 char pid[sizeof("_PID=") + DECIMAL_STR_MAX(pid_t)],
549 uid[sizeof("_UID=") + DECIMAL_STR_MAX(uid_t)],
550 gid[sizeof("_GID=") + DECIMAL_STR_MAX(gid_t)],
551 owner_uid[sizeof("_SYSTEMD_OWNER_UID=") + DECIMAL_STR_MAX(uid_t)],
552 source_time[sizeof("_SOURCE_REALTIME_TIMESTAMP=") + DECIMAL_STR_MAX(usec_t)],
553 o_uid[sizeof("OBJECT_UID=") + DECIMAL_STR_MAX(uid_t)],
554 o_gid[sizeof("OBJECT_GID=") + DECIMAL_STR_MAX(gid_t)],
555 o_owner_uid[sizeof("OBJECT_SYSTEMD_OWNER_UID=") + DECIMAL_STR_MAX(uid_t)];
556 uid_t object_uid;
557 gid_t object_gid;
558 char *x;
559 int r;
560 char *t, *c;
561 uid_t realuid = 0, owner = 0, journal_uid;
562 bool owner_valid = false;
563 #ifdef HAVE_AUDIT
564 char audit_session[sizeof("_AUDIT_SESSION=") + DECIMAL_STR_MAX(uint32_t)],
565 audit_loginuid[sizeof("_AUDIT_LOGINUID=") + DECIMAL_STR_MAX(uid_t)],
566 o_audit_session[sizeof("OBJECT_AUDIT_SESSION=") + DECIMAL_STR_MAX(uint32_t)],
567 o_audit_loginuid[sizeof("OBJECT_AUDIT_LOGINUID=") + DECIMAL_STR_MAX(uid_t)];
568
569 uint32_t audit;
570 uid_t loginuid;
571 #endif
572
573 assert(s);
574 assert(iovec);
575 assert(n > 0);
576 assert(n + N_IOVEC_META_FIELDS + (object_pid ? N_IOVEC_OBJECT_FIELDS : 0) <= m);
577
578 if (ucred) {
579 realuid = ucred->uid;
580
581 sprintf(pid, "_PID="PID_FMT, ucred->pid);
582 IOVEC_SET_STRING(iovec[n++], pid);
583
584 sprintf(uid, "_UID="UID_FMT, ucred->uid);
585 IOVEC_SET_STRING(iovec[n++], uid);
586
587 sprintf(gid, "_GID="GID_FMT, ucred->gid);
588 IOVEC_SET_STRING(iovec[n++], gid);
589
590 r = get_process_comm(ucred->pid, &t);
591 if (r >= 0) {
592 x = strjoina("_COMM=", t);
593 free(t);
594 IOVEC_SET_STRING(iovec[n++], x);
595 }
596
597 r = get_process_exe(ucred->pid, &t);
598 if (r >= 0) {
599 x = strjoina("_EXE=", t);
600 free(t);
601 IOVEC_SET_STRING(iovec[n++], x);
602 }
603
604 r = get_process_cmdline(ucred->pid, 0, false, &t);
605 if (r >= 0) {
606 x = strjoina("_CMDLINE=", t);
607 free(t);
608 IOVEC_SET_STRING(iovec[n++], x);
609 }
610
611 r = get_process_capeff(ucred->pid, &t);
612 if (r >= 0) {
613 x = strjoina("_CAP_EFFECTIVE=", t);
614 free(t);
615 IOVEC_SET_STRING(iovec[n++], x);
616 }
617
618 #ifdef HAVE_AUDIT
619 r = audit_session_from_pid(ucred->pid, &audit);
620 if (r >= 0) {
621 sprintf(audit_session, "_AUDIT_SESSION=%"PRIu32, audit);
622 IOVEC_SET_STRING(iovec[n++], audit_session);
623 }
624
625 r = audit_loginuid_from_pid(ucred->pid, &loginuid);
626 if (r >= 0) {
627 sprintf(audit_loginuid, "_AUDIT_LOGINUID="UID_FMT, loginuid);
628 IOVEC_SET_STRING(iovec[n++], audit_loginuid);
629 }
630 #endif
631
632 r = cg_pid_get_path_shifted(ucred->pid, s->cgroup_root, &c);
633 if (r >= 0) {
634 char *session = NULL;
635
636 x = strjoina("_SYSTEMD_CGROUP=", c);
637 IOVEC_SET_STRING(iovec[n++], x);
638
639 r = cg_path_get_session(c, &t);
640 if (r >= 0) {
641 session = strjoina("_SYSTEMD_SESSION=", t);
642 free(t);
643 IOVEC_SET_STRING(iovec[n++], session);
644 }
645
646 if (cg_path_get_owner_uid(c, &owner) >= 0) {
647 owner_valid = true;
648
649 sprintf(owner_uid, "_SYSTEMD_OWNER_UID="UID_FMT, owner);
650 IOVEC_SET_STRING(iovec[n++], owner_uid);
651 }
652
653 if (cg_path_get_unit(c, &t) >= 0) {
654 x = strjoina("_SYSTEMD_UNIT=", t);
655 free(t);
656 IOVEC_SET_STRING(iovec[n++], x);
657 } else if (unit_id && !session) {
658 x = strjoina("_SYSTEMD_UNIT=", unit_id);
659 IOVEC_SET_STRING(iovec[n++], x);
660 }
661
662 if (cg_path_get_user_unit(c, &t) >= 0) {
663 x = strjoina("_SYSTEMD_USER_UNIT=", t);
664 free(t);
665 IOVEC_SET_STRING(iovec[n++], x);
666 } else if (unit_id && session) {
667 x = strjoina("_SYSTEMD_USER_UNIT=", unit_id);
668 IOVEC_SET_STRING(iovec[n++], x);
669 }
670
671 if (cg_path_get_slice(c, &t) >= 0) {
672 x = strjoina("_SYSTEMD_SLICE=", t);
673 free(t);
674 IOVEC_SET_STRING(iovec[n++], x);
675 }
676
677 free(c);
678 } else if (unit_id) {
679 x = strjoina("_SYSTEMD_UNIT=", unit_id);
680 IOVEC_SET_STRING(iovec[n++], x);
681 }
682
683 #ifdef HAVE_SELINUX
684 if (mac_selinux_have()) {
685 if (label) {
686 x = alloca(strlen("_SELINUX_CONTEXT=") + label_len + 1);
687
688 *((char*) mempcpy(stpcpy(x, "_SELINUX_CONTEXT="), label, label_len)) = 0;
689 IOVEC_SET_STRING(iovec[n++], x);
690 } else {
691 security_context_t con;
692
693 if (getpidcon(ucred->pid, &con) >= 0) {
694 x = strjoina("_SELINUX_CONTEXT=", con);
695
696 freecon(con);
697 IOVEC_SET_STRING(iovec[n++], x);
698 }
699 }
700 }
701 #endif
702 }
703 assert(n <= m);
704
705 if (object_pid) {
706 r = get_process_uid(object_pid, &object_uid);
707 if (r >= 0) {
708 sprintf(o_uid, "OBJECT_UID="UID_FMT, object_uid);
709 IOVEC_SET_STRING(iovec[n++], o_uid);
710 }
711
712 r = get_process_gid(object_pid, &object_gid);
713 if (r >= 0) {
714 sprintf(o_gid, "OBJECT_GID="GID_FMT, object_gid);
715 IOVEC_SET_STRING(iovec[n++], o_gid);
716 }
717
718 r = get_process_comm(object_pid, &t);
719 if (r >= 0) {
720 x = strjoina("OBJECT_COMM=", t);
721 free(t);
722 IOVEC_SET_STRING(iovec[n++], x);
723 }
724
725 r = get_process_exe(object_pid, &t);
726 if (r >= 0) {
727 x = strjoina("OBJECT_EXE=", t);
728 free(t);
729 IOVEC_SET_STRING(iovec[n++], x);
730 }
731
732 r = get_process_cmdline(object_pid, 0, false, &t);
733 if (r >= 0) {
734 x = strjoina("OBJECT_CMDLINE=", t);
735 free(t);
736 IOVEC_SET_STRING(iovec[n++], x);
737 }
738
739 #ifdef HAVE_AUDIT
740 r = audit_session_from_pid(object_pid, &audit);
741 if (r >= 0) {
742 sprintf(o_audit_session, "OBJECT_AUDIT_SESSION=%"PRIu32, audit);
743 IOVEC_SET_STRING(iovec[n++], o_audit_session);
744 }
745
746 r = audit_loginuid_from_pid(object_pid, &loginuid);
747 if (r >= 0) {
748 sprintf(o_audit_loginuid, "OBJECT_AUDIT_LOGINUID="UID_FMT, loginuid);
749 IOVEC_SET_STRING(iovec[n++], o_audit_loginuid);
750 }
751 #endif
752
753 r = cg_pid_get_path_shifted(object_pid, s->cgroup_root, &c);
754 if (r >= 0) {
755 x = strjoina("OBJECT_SYSTEMD_CGROUP=", c);
756 IOVEC_SET_STRING(iovec[n++], x);
757
758 r = cg_path_get_session(c, &t);
759 if (r >= 0) {
760 x = strjoina("OBJECT_SYSTEMD_SESSION=", t);
761 free(t);
762 IOVEC_SET_STRING(iovec[n++], x);
763 }
764
765 if (cg_path_get_owner_uid(c, &owner) >= 0) {
766 sprintf(o_owner_uid, "OBJECT_SYSTEMD_OWNER_UID="UID_FMT, owner);
767 IOVEC_SET_STRING(iovec[n++], o_owner_uid);
768 }
769
770 if (cg_path_get_unit(c, &t) >= 0) {
771 x = strjoina("OBJECT_SYSTEMD_UNIT=", t);
772 free(t);
773 IOVEC_SET_STRING(iovec[n++], x);
774 }
775
776 if (cg_path_get_user_unit(c, &t) >= 0) {
777 x = strjoina("OBJECT_SYSTEMD_USER_UNIT=", t);
778 free(t);
779 IOVEC_SET_STRING(iovec[n++], x);
780 }
781
782 free(c);
783 }
784 }
785 assert(n <= m);
786
787 if (tv) {
788 sprintf(source_time, "_SOURCE_REALTIME_TIMESTAMP=%llu", (unsigned long long) timeval_load(tv));
789 IOVEC_SET_STRING(iovec[n++], source_time);
790 }
791
792 /* Note that strictly speaking storing the boot id here is
793 * redundant since the entry includes this in-line
794 * anyway. However, we need this indexed, too. */
795 if (!isempty(s->boot_id_field))
796 IOVEC_SET_STRING(iovec[n++], s->boot_id_field);
797
798 if (!isempty(s->machine_id_field))
799 IOVEC_SET_STRING(iovec[n++], s->machine_id_field);
800
801 if (!isempty(s->hostname_field))
802 IOVEC_SET_STRING(iovec[n++], s->hostname_field);
803
804 assert(n <= m);
805
806 if (s->split_mode == SPLIT_UID && realuid > 0)
807 /* Split up strictly by any UID */
808 journal_uid = realuid;
809 else if (s->split_mode == SPLIT_LOGIN && realuid > 0 && owner_valid && owner > 0)
810 /* Split up by login UIDs. We do this only if the
811 * realuid is not root, in order not to accidentally
812 * leak privileged information to the user that is
813 * logged by a privileged process that is part of an
814 * unprivileged session. */
815 journal_uid = owner;
816 else
817 journal_uid = 0;
818
819 write_to_journal(s, journal_uid, iovec, n, priority);
820 }
821
822 void server_driver_message(Server *s, sd_id128_t message_id, const char *format, ...) {
823 char mid[11 + 32 + 1];
824 struct iovec iovec[N_IOVEC_META_FIELDS + 5 + N_IOVEC_PAYLOAD_FIELDS];
825 unsigned n = 0, m;
826 va_list ap;
827 struct ucred ucred = {};
828
829 assert(s);
830 assert(format);
831
832 IOVEC_SET_STRING(iovec[n++], "SYSLOG_FACILITY=3");
833 IOVEC_SET_STRING(iovec[n++], "SYSLOG_IDENTIFIER=systemd-journald");
834
835 IOVEC_SET_STRING(iovec[n++], "PRIORITY=6");
836 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=driver");
837
838 if (!sd_id128_equal(message_id, SD_ID128_NULL)) {
839 snprintf(mid, sizeof(mid), LOG_MESSAGE_ID(message_id));
840 IOVEC_SET_STRING(iovec[n++], mid);
841 }
842
843 m = n;
844
845 va_start(ap, format);
846 assert_se(log_format_iovec(iovec, ELEMENTSOF(iovec), &n, false, 0, format, ap) >= 0);
847 va_end(ap);
848
849 ucred.pid = getpid();
850 ucred.uid = getuid();
851 ucred.gid = getgid();
852
853 dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL, LOG_INFO, 0);
854
855 while (m < n)
856 free(iovec[m++].iov_base);
857 }
858
859 void server_dispatch_message(
860 Server *s,
861 struct iovec *iovec, unsigned n, unsigned m,
862 const struct ucred *ucred,
863 const struct timeval *tv,
864 const char *label, size_t label_len,
865 const char *unit_id,
866 int priority,
867 pid_t object_pid) {
868
869 int rl, r;
870 _cleanup_free_ char *path = NULL;
871 uint64_t available = 0;
872 char *c;
873
874 assert(s);
875 assert(iovec || n == 0);
876
877 if (n == 0)
878 return;
879
880 if (LOG_PRI(priority) > s->max_level_store)
881 return;
882
883 /* Stop early in case the information will not be stored
884 * in a journal. */
885 if (s->storage == STORAGE_NONE)
886 return;
887
888 if (!ucred)
889 goto finish;
890
891 r = cg_pid_get_path_shifted(ucred->pid, s->cgroup_root, &path);
892 if (r < 0)
893 goto finish;
894
895 /* example: /user/lennart/3/foobar
896 * /system/dbus.service/foobar
897 *
898 * So let's cut of everything past the third /, since that is
899 * where user directories start */
900
901 c = strchr(path, '/');
902 if (c) {
903 c = strchr(c+1, '/');
904 if (c) {
905 c = strchr(c+1, '/');
906 if (c)
907 *c = 0;
908 }
909 }
910
911 (void) determine_space(s, false, false, &available, NULL);
912 rl = journal_rate_limit_test(s->rate_limit, path, priority & LOG_PRIMASK, available);
913 if (rl == 0)
914 return;
915
916 /* Write a suppression message if we suppressed something */
917 if (rl > 1)
918 server_driver_message(s, SD_MESSAGE_JOURNAL_DROPPED,
919 LOG_MESSAGE("Suppressed %u messages from %s", rl - 1, path),
920 NULL);
921
922 finish:
923 dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id, priority, object_pid);
924 }
925
926
927 static int system_journal_open(Server *s, bool flush_requested) {
928 const char *fn;
929 int r = 0;
930
931 if (!s->system_journal &&
932 (s->storage == STORAGE_PERSISTENT || s->storage == STORAGE_AUTO) &&
933 (flush_requested
934 || access("/run/systemd/journal/flushed", F_OK) >= 0)) {
935
936 /* If in auto mode: first try to create the machine
937 * path, but not the prefix.
938 *
939 * If in persistent mode: create /var/log/journal and
940 * the machine path */
941
942 if (s->storage == STORAGE_PERSISTENT)
943 (void) mkdir_p("/var/log/journal/", 0755);
944
945 fn = strjoina("/var/log/journal/", SERVER_MACHINE_ID(s));
946 (void) mkdir(fn, 0755);
947
948 fn = strjoina(fn, "/system.journal");
949 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, NULL, &s->system_journal);
950 if (r >= 0) {
951 server_add_acls(s->system_journal, 0);
952 (void) determine_space_for(s, &s->system_metrics, "/var/log/journal/", "System journal", true, true, NULL, NULL);
953 } else if (r < 0) {
954 if (r != -ENOENT && r != -EROFS)
955 log_warning_errno(r, "Failed to open system journal: %m");
956
957 r = 0;
958 }
959 }
960
961 if (!s->runtime_journal &&
962 (s->storage != STORAGE_NONE)) {
963
964 fn = strjoina("/run/log/journal/", SERVER_MACHINE_ID(s), "/system.journal");
965
966 if (s->system_journal) {
967
968 /* Try to open the runtime journal, but only
969 * if it already exists, so that we can flush
970 * it into the system journal */
971
972 r = journal_file_open(fn, O_RDWR, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
973 if (r < 0) {
974 if (r != -ENOENT)
975 log_warning_errno(r, "Failed to open runtime journal: %m");
976
977 r = 0;
978 }
979
980 } else {
981
982 /* OK, we really need the runtime journal, so create
983 * it if necessary. */
984
985 (void) mkdir("/run/log", 0755);
986 (void) mkdir("/run/log/journal", 0755);
987 (void) mkdir_parents(fn, 0750);
988
989 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
990 if (r < 0)
991 return log_error_errno(r, "Failed to open runtime journal: %m");
992 }
993
994 if (s->runtime_journal) {
995 server_add_acls(s->runtime_journal, 0);
996 (void) determine_space_for(s, &s->runtime_metrics, "/run/log/journal/", "Runtime journal", true, true, NULL, NULL);
997 }
998 }
999
1000 return r;
1001 }
1002
1003 int server_flush_to_var(Server *s) {
1004 sd_id128_t machine;
1005 sd_journal *j = NULL;
1006 char ts[FORMAT_TIMESPAN_MAX];
1007 usec_t start;
1008 unsigned n = 0;
1009 int r;
1010
1011 assert(s);
1012
1013 if (s->storage != STORAGE_AUTO &&
1014 s->storage != STORAGE_PERSISTENT)
1015 return 0;
1016
1017 if (!s->runtime_journal)
1018 return 0;
1019
1020 (void) system_journal_open(s, true);
1021
1022 if (!s->system_journal)
1023 return 0;
1024
1025 log_debug("Flushing to /var...");
1026
1027 start = now(CLOCK_MONOTONIC);
1028
1029 r = sd_id128_get_machine(&machine);
1030 if (r < 0)
1031 return r;
1032
1033 r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
1034 if (r < 0)
1035 return log_error_errno(r, "Failed to read runtime journal: %m");
1036
1037 sd_journal_set_data_threshold(j, 0);
1038
1039 SD_JOURNAL_FOREACH(j) {
1040 Object *o = NULL;
1041 JournalFile *f;
1042
1043 f = j->current_file;
1044 assert(f && f->current_offset > 0);
1045
1046 n++;
1047
1048 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
1049 if (r < 0) {
1050 log_error_errno(r, "Can't read entry: %m");
1051 goto finish;
1052 }
1053
1054 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
1055 if (r >= 0)
1056 continue;
1057
1058 if (!shall_try_append_again(s->system_journal, r)) {
1059 log_error_errno(r, "Can't write entry: %m");
1060 goto finish;
1061 }
1062
1063 server_rotate(s);
1064 server_vacuum(s, false, false);
1065
1066 if (!s->system_journal) {
1067 log_notice("Didn't flush runtime journal since rotation of system journal wasn't successful.");
1068 r = -EIO;
1069 goto finish;
1070 }
1071
1072 log_debug("Retrying write.");
1073 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
1074 if (r < 0) {
1075 log_error_errno(r, "Can't write entry: %m");
1076 goto finish;
1077 }
1078 }
1079
1080 r = 0;
1081
1082 finish:
1083 journal_file_post_change(s->system_journal);
1084
1085 s->runtime_journal = journal_file_close(s->runtime_journal);
1086
1087 if (r >= 0)
1088 (void) rm_rf("/run/log/journal", REMOVE_ROOT);
1089
1090 sd_journal_close(j);
1091
1092 server_driver_message(s, SD_ID128_NULL,
1093 LOG_MESSAGE("Time spent on flushing to /var is %s for %u entries.",
1094 format_timespan(ts, sizeof(ts), now(CLOCK_MONOTONIC) - start, 0),
1095 n),
1096 NULL);
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 int r;
1226
1227 assert(s);
1228
1229 log_info("Received request to flush runtime journal from PID " PID_FMT, si->ssi_pid);
1230
1231 server_flush_to_var(s);
1232 server_sync(s);
1233 server_vacuum(s, false, false);
1234
1235 r = touch("/run/systemd/journal/flushed");
1236 if (r < 0)
1237 log_warning_errno(r, "Failed to touch /run/systemd/journal/flushed, ignoring: %m");
1238
1239 return 0;
1240 }
1241
1242 static int dispatch_sigusr2(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) {
1243 Server *s = userdata;
1244 int r;
1245
1246 assert(s);
1247
1248 log_info("Received request to rotate journal from PID " PID_FMT, si->ssi_pid);
1249 server_rotate(s);
1250 server_vacuum(s, true, true);
1251
1252 /* Let clients know when the most recent rotation happened. */
1253 r = write_timestamp_file_atomic("/run/systemd/journal/rotated", now(CLOCK_MONOTONIC));
1254 if (r < 0)
1255 log_warning_errno(r, "Failed to write /run/systemd/journal/rotated, ignoring: %m");
1256
1257 return 0;
1258 }
1259
1260 static int dispatch_sigterm(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) {
1261 Server *s = userdata;
1262
1263 assert(s);
1264
1265 log_received_signal(LOG_INFO, si);
1266
1267 sd_event_exit(s->event, 0);
1268 return 0;
1269 }
1270
1271 static int dispatch_sigrtmin1(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) {
1272 Server *s = userdata;
1273 int r;
1274
1275 assert(s);
1276
1277 log_debug("Received request to sync from PID " PID_FMT, si->ssi_pid);
1278
1279 server_sync(s);
1280
1281 /* Let clients know when the most recent sync happened. */
1282 r = write_timestamp_file_atomic("/run/systemd/journal/synced", now(CLOCK_MONOTONIC));
1283 if (r < 0)
1284 log_warning_errno(r, "Failed to write /run/systemd/journal/synced, ignoring: %m");
1285
1286 return 0;
1287 }
1288
1289 static int setup_signals(Server *s) {
1290 int r;
1291
1292 assert(s);
1293
1294 assert(sigprocmask_many(SIG_SETMASK, NULL, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, SIGRTMIN+1, -1) >= 0);
1295
1296 r = sd_event_add_signal(s->event, &s->sigusr1_event_source, SIGUSR1, dispatch_sigusr1, s);
1297 if (r < 0)
1298 return r;
1299
1300 r = sd_event_add_signal(s->event, &s->sigusr2_event_source, SIGUSR2, dispatch_sigusr2, s);
1301 if (r < 0)
1302 return r;
1303
1304 r = sd_event_add_signal(s->event, &s->sigterm_event_source, SIGTERM, dispatch_sigterm, s);
1305 if (r < 0)
1306 return r;
1307
1308 /* Let's process SIGTERM late, so that we flush all queued
1309 * messages to disk before we exit */
1310 r = sd_event_source_set_priority(s->sigterm_event_source, SD_EVENT_PRIORITY_NORMAL+20);
1311 if (r < 0)
1312 return r;
1313
1314 /* When journald is invoked on the terminal (when debugging),
1315 * it's useful if C-c is handled equivalent to SIGTERM. */
1316 r = sd_event_add_signal(s->event, &s->sigint_event_source, SIGINT, dispatch_sigterm, s);
1317 if (r < 0)
1318 return r;
1319
1320 r = sd_event_source_set_priority(s->sigint_event_source, SD_EVENT_PRIORITY_NORMAL+20);
1321 if (r < 0)
1322 return r;
1323
1324 /* SIGRTMIN+1 causes an immediate sync. We process this very
1325 * late, so that everything else queued at this point is
1326 * really written to disk. Clients can watch
1327 * /run/systemd/journal/synced with inotify until its mtime
1328 * changes to see when a sync happened. */
1329 r = sd_event_add_signal(s->event, &s->sigrtmin1_event_source, SIGRTMIN+1, dispatch_sigrtmin1, s);
1330 if (r < 0)
1331 return r;
1332
1333 r = sd_event_source_set_priority(s->sigrtmin1_event_source, SD_EVENT_PRIORITY_NORMAL+15);
1334 if (r < 0)
1335 return r;
1336
1337 return 0;
1338 }
1339
1340 static int server_parse_proc_cmdline(Server *s) {
1341 _cleanup_free_ char *line = NULL;
1342 const char *p;
1343 int r;
1344
1345 r = proc_cmdline(&line);
1346 if (r < 0) {
1347 log_warning_errno(r, "Failed to read /proc/cmdline, ignoring: %m");
1348 return 0;
1349 }
1350
1351 p = line;
1352 for(;;) {
1353 _cleanup_free_ char *word = NULL;
1354
1355 r = extract_first_word(&p, &word, NULL, 0);
1356 if (r < 0)
1357 return log_error_errno(r, "Failed to parse journald syntax \"%s\": %m", line);
1358
1359 if (r == 0)
1360 break;
1361
1362 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
1363 r = parse_boolean(word + 35);
1364 if (r < 0)
1365 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
1366 else
1367 s->forward_to_syslog = r;
1368 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
1369 r = parse_boolean(word + 33);
1370 if (r < 0)
1371 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
1372 else
1373 s->forward_to_kmsg = r;
1374 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
1375 r = parse_boolean(word + 36);
1376 if (r < 0)
1377 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
1378 else
1379 s->forward_to_console = r;
1380 } else if (startswith(word, "systemd.journald.forward_to_wall=")) {
1381 r = parse_boolean(word + 33);
1382 if (r < 0)
1383 log_warning("Failed to parse forward to wall switch %s. Ignoring.", word + 33);
1384 else
1385 s->forward_to_wall = r;
1386 } else if (startswith(word, "systemd.journald"))
1387 log_warning("Invalid systemd.journald parameter. Ignoring.");
1388 }
1389
1390 /* do not warn about state here, since probably systemd already did */
1391 return 0;
1392 }
1393
1394 static int server_parse_config_file(Server *s) {
1395 assert(s);
1396
1397 return config_parse_many(PKGSYSCONFDIR "/journald.conf",
1398 CONF_PATHS_NULSTR("systemd/journald.conf.d"),
1399 "Journal\0",
1400 config_item_perf_lookup, journald_gperf_lookup,
1401 false, s);
1402 }
1403
1404 static int server_dispatch_sync(sd_event_source *es, usec_t t, void *userdata) {
1405 Server *s = userdata;
1406
1407 assert(s);
1408
1409 server_sync(s);
1410 return 0;
1411 }
1412
1413 int server_schedule_sync(Server *s, int priority) {
1414 int r;
1415
1416 assert(s);
1417
1418 if (priority <= LOG_CRIT) {
1419 /* Immediately sync to disk when this is of priority CRIT, ALERT, EMERG */
1420 server_sync(s);
1421 return 0;
1422 }
1423
1424 if (s->sync_scheduled)
1425 return 0;
1426
1427 if (s->sync_interval_usec > 0) {
1428 usec_t when;
1429
1430 r = sd_event_now(s->event, CLOCK_MONOTONIC, &when);
1431 if (r < 0)
1432 return r;
1433
1434 when += s->sync_interval_usec;
1435
1436 if (!s->sync_event_source) {
1437 r = sd_event_add_time(
1438 s->event,
1439 &s->sync_event_source,
1440 CLOCK_MONOTONIC,
1441 when, 0,
1442 server_dispatch_sync, s);
1443 if (r < 0)
1444 return r;
1445
1446 r = sd_event_source_set_priority(s->sync_event_source, SD_EVENT_PRIORITY_IMPORTANT);
1447 } else {
1448 r = sd_event_source_set_time(s->sync_event_source, when);
1449 if (r < 0)
1450 return r;
1451
1452 r = sd_event_source_set_enabled(s->sync_event_source, SD_EVENT_ONESHOT);
1453 }
1454 if (r < 0)
1455 return r;
1456
1457 s->sync_scheduled = true;
1458 }
1459
1460 return 0;
1461 }
1462
1463 static int dispatch_hostname_change(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
1464 Server *s = userdata;
1465
1466 assert(s);
1467
1468 server_cache_hostname(s);
1469 return 0;
1470 }
1471
1472 static int server_open_hostname(Server *s) {
1473 int r;
1474
1475 assert(s);
1476
1477 s->hostname_fd = open("/proc/sys/kernel/hostname", O_RDONLY|O_CLOEXEC|O_NDELAY|O_NOCTTY);
1478 if (s->hostname_fd < 0)
1479 return log_error_errno(errno, "Failed to open /proc/sys/kernel/hostname: %m");
1480
1481 r = sd_event_add_io(s->event, &s->hostname_event_source, s->hostname_fd, 0, dispatch_hostname_change, s);
1482 if (r < 0) {
1483 /* kernels prior to 3.2 don't support polling this file. Ignore
1484 * the failure. */
1485 if (r == -EPERM) {
1486 log_warning_errno(r, "Failed to register hostname fd in event loop, ignoring: %m");
1487 s->hostname_fd = safe_close(s->hostname_fd);
1488 return 0;
1489 }
1490
1491 return log_error_errno(r, "Failed to register hostname fd in event loop: %m");
1492 }
1493
1494 r = sd_event_source_set_priority(s->hostname_event_source, SD_EVENT_PRIORITY_IMPORTANT-10);
1495 if (r < 0)
1496 return log_error_errno(r, "Failed to adjust priority of host name event source: %m");
1497
1498 return 0;
1499 }
1500
1501 static int dispatch_notify_event(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
1502 Server *s = userdata;
1503 int r;
1504
1505 assert(s);
1506 assert(s->notify_event_source == es);
1507 assert(s->notify_fd == fd);
1508
1509 /* The $NOTIFY_SOCKET is writable again, now send exactly one
1510 * message on it. Either it's the wtachdog event, the initial
1511 * READY=1 event or an stdout stream event. If there's nothing
1512 * to write anymore, turn our event source off. The next time
1513 * there's something to send it will be turned on again. */
1514
1515 if (!s->sent_notify_ready) {
1516 static const char p[] =
1517 "READY=1\n"
1518 "STATUS=Processing requests...";
1519 ssize_t l;
1520
1521 l = send(s->notify_fd, p, strlen(p), MSG_DONTWAIT);
1522 if (l < 0) {
1523 if (errno == EAGAIN)
1524 return 0;
1525
1526 return log_error_errno(errno, "Failed to send READY=1 notification message: %m");
1527 }
1528
1529 s->sent_notify_ready = true;
1530 log_debug("Sent READY=1 notification.");
1531
1532 } else if (s->send_watchdog) {
1533
1534 static const char p[] =
1535 "WATCHDOG=1";
1536
1537 ssize_t l;
1538
1539 l = send(s->notify_fd, p, strlen(p), MSG_DONTWAIT);
1540 if (l < 0) {
1541 if (errno == EAGAIN)
1542 return 0;
1543
1544 return log_error_errno(errno, "Failed to send WATCHDOG=1 notification message: %m");
1545 }
1546
1547 s->send_watchdog = false;
1548 log_debug("Sent WATCHDOG=1 notification.");
1549
1550 } else if (s->stdout_streams_notify_queue)
1551 /* Dispatch one stream notification event */
1552 stdout_stream_send_notify(s->stdout_streams_notify_queue);
1553
1554 /* Leave us enabled if there's still more to to do. */
1555 if (s->send_watchdog || s->stdout_streams_notify_queue)
1556 return 0;
1557
1558 /* There was nothing to do anymore, let's turn ourselves off. */
1559 r = sd_event_source_set_enabled(es, SD_EVENT_OFF);
1560 if (r < 0)
1561 return log_error_errno(r, "Failed to turn off notify event source: %m");
1562
1563 return 0;
1564 }
1565
1566 static int dispatch_watchdog(sd_event_source *es, uint64_t usec, void *userdata) {
1567 Server *s = userdata;
1568 int r;
1569
1570 assert(s);
1571
1572 s->send_watchdog = true;
1573
1574 r = sd_event_source_set_enabled(s->notify_event_source, SD_EVENT_ON);
1575 if (r < 0)
1576 log_warning_errno(r, "Failed to turn on notify event source: %m");
1577
1578 r = sd_event_source_set_time(s->watchdog_event_source, usec + s->watchdog_usec / 2);
1579 if (r < 0)
1580 return log_error_errno(r, "Failed to restart watchdog event source: %m");
1581
1582 r = sd_event_source_set_enabled(s->watchdog_event_source, SD_EVENT_ON);
1583 if (r < 0)
1584 return log_error_errno(r, "Failed to enable watchdog event source: %m");
1585
1586 return 0;
1587 }
1588
1589 static int server_connect_notify(Server *s) {
1590 union sockaddr_union sa = {
1591 .un.sun_family = AF_UNIX,
1592 };
1593 const char *e;
1594 int r;
1595
1596 assert(s);
1597 assert(s->notify_fd < 0);
1598 assert(!s->notify_event_source);
1599
1600 /*
1601 So here's the problem: we'd like to send notification
1602 messages to PID 1, but we cannot do that via sd_notify(),
1603 since that's synchronous, and we might end up blocking on
1604 it. Specifically: given that PID 1 might block on
1605 dbus-daemon during IPC, and dbus-daemon is logging to us,
1606 and might hence block on us, we might end up in a deadlock
1607 if we block on sending PID 1 notification messages -- by
1608 generating a full blocking circle. To avoid this, let's
1609 create a non-blocking socket, and connect it to the
1610 notification socket, and then wait for POLLOUT before we
1611 send anything. This should efficiently avoid any deadlocks,
1612 as we'll never block on PID 1, hence PID 1 can safely block
1613 on dbus-daemon which can safely block on us again.
1614
1615 Don't think that this issue is real? It is, see:
1616 https://github.com/systemd/systemd/issues/1505
1617 */
1618
1619 e = getenv("NOTIFY_SOCKET");
1620 if (!e)
1621 return 0;
1622
1623 if ((e[0] != '@' && e[0] != '/') || e[1] == 0) {
1624 log_error("NOTIFY_SOCKET set to an invalid value: %s", e);
1625 return -EINVAL;
1626 }
1627
1628 if (strlen(e) > sizeof(sa.un.sun_path)) {
1629 log_error("NOTIFY_SOCKET path too long: %s", e);
1630 return -EINVAL;
1631 }
1632
1633 s->notify_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1634 if (s->notify_fd < 0)
1635 return log_error_errno(errno, "Failed to create notify socket: %m");
1636
1637 (void) fd_inc_sndbuf(s->notify_fd, NOTIFY_SNDBUF_SIZE);
1638
1639 strncpy(sa.un.sun_path, e, sizeof(sa.un.sun_path));
1640 if (sa.un.sun_path[0] == '@')
1641 sa.un.sun_path[0] = 0;
1642
1643 r = connect(s->notify_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(e));
1644 if (r < 0)
1645 return log_error_errno(errno, "Failed to connect to notify socket: %m");
1646
1647 r = sd_event_add_io(s->event, &s->notify_event_source, s->notify_fd, EPOLLOUT, dispatch_notify_event, s);
1648 if (r < 0)
1649 return log_error_errno(r, "Failed to watch notification socket: %m");
1650
1651 if (sd_watchdog_enabled(false, &s->watchdog_usec) > 0) {
1652 s->send_watchdog = true;
1653
1654 r = sd_event_add_time(s->event, &s->watchdog_event_source, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + s->watchdog_usec/2, s->watchdog_usec/4, dispatch_watchdog, s);
1655 if (r < 0)
1656 return log_error_errno(r, "Failed to add watchdog time event: %m");
1657 }
1658
1659 /* This should fire pretty soon, which we'll use to send the
1660 * READY=1 event. */
1661
1662 return 0;
1663 }
1664
1665 int server_init(Server *s) {
1666 _cleanup_fdset_free_ FDSet *fds = NULL;
1667 int n, r, fd;
1668 bool no_sockets;
1669
1670 assert(s);
1671
1672 zero(*s);
1673 s->syslog_fd = s->native_fd = s->stdout_fd = s->dev_kmsg_fd = s->audit_fd = s->hostname_fd = s->notify_fd = -1;
1674 s->compress = true;
1675 s->seal = true;
1676
1677 s->watchdog_usec = USEC_INFINITY;
1678
1679 s->sync_interval_usec = DEFAULT_SYNC_INTERVAL_USEC;
1680 s->sync_scheduled = false;
1681
1682 s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
1683 s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
1684
1685 s->forward_to_wall = true;
1686
1687 s->max_file_usec = DEFAULT_MAX_FILE_USEC;
1688
1689 s->max_level_store = LOG_DEBUG;
1690 s->max_level_syslog = LOG_DEBUG;
1691 s->max_level_kmsg = LOG_NOTICE;
1692 s->max_level_console = LOG_INFO;
1693 s->max_level_wall = LOG_EMERG;
1694
1695 journal_reset_metrics(&s->system_metrics);
1696 journal_reset_metrics(&s->runtime_metrics);
1697
1698 server_parse_config_file(s);
1699 server_parse_proc_cmdline(s);
1700
1701 if (!!s->rate_limit_interval ^ !!s->rate_limit_burst) {
1702 log_debug("Setting both rate limit interval and burst from "USEC_FMT",%u to 0,0",
1703 s->rate_limit_interval, s->rate_limit_burst);
1704 s->rate_limit_interval = s->rate_limit_burst = 0;
1705 }
1706
1707 (void) mkdir_p("/run/systemd/journal", 0755);
1708
1709 s->user_journals = ordered_hashmap_new(NULL);
1710 if (!s->user_journals)
1711 return log_oom();
1712
1713 s->mmap = mmap_cache_new();
1714 if (!s->mmap)
1715 return log_oom();
1716
1717 r = sd_event_default(&s->event);
1718 if (r < 0)
1719 return log_error_errno(r, "Failed to create event loop: %m");
1720
1721 n = sd_listen_fds(true);
1722 if (n < 0)
1723 return log_error_errno(n, "Failed to read listening file descriptors from environment: %m");
1724
1725 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
1726
1727 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
1728
1729 if (s->native_fd >= 0) {
1730 log_error("Too many native sockets passed.");
1731 return -EINVAL;
1732 }
1733
1734 s->native_fd = fd;
1735
1736 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
1737
1738 if (s->stdout_fd >= 0) {
1739 log_error("Too many stdout sockets passed.");
1740 return -EINVAL;
1741 }
1742
1743 s->stdout_fd = fd;
1744
1745 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0 ||
1746 sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/dev-log", 0) > 0) {
1747
1748 if (s->syslog_fd >= 0) {
1749 log_error("Too many /dev/log sockets passed.");
1750 return -EINVAL;
1751 }
1752
1753 s->syslog_fd = fd;
1754
1755 } else if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
1756
1757 if (s->audit_fd >= 0) {
1758 log_error("Too many audit sockets passed.");
1759 return -EINVAL;
1760 }
1761
1762 s->audit_fd = fd;
1763
1764 } else {
1765
1766 if (!fds) {
1767 fds = fdset_new();
1768 if (!fds)
1769 return log_oom();
1770 }
1771
1772 r = fdset_put(fds, fd);
1773 if (r < 0)
1774 return log_oom();
1775 }
1776 }
1777
1778 /* Try to restore streams, but don't bother if this fails */
1779 (void) server_restore_streams(s, fds);
1780
1781 if (fdset_size(fds) > 0) {
1782 log_warning("%u unknown file descriptors passed, closing.", fdset_size(fds));
1783 fds = fdset_free(fds);
1784 }
1785
1786 no_sockets = s->native_fd < 0 && s->stdout_fd < 0 && s->syslog_fd < 0 && s->audit_fd < 0;
1787
1788 /* always open stdout, syslog, native, and kmsg sockets */
1789
1790 /* systemd-journald.socket: /run/systemd/journal/stdout */
1791 r = server_open_stdout_socket(s);
1792 if (r < 0)
1793 return r;
1794
1795 /* systemd-journald-dev-log.socket: /run/systemd/journal/dev-log */
1796 r = server_open_syslog_socket(s);
1797 if (r < 0)
1798 return r;
1799
1800 /* systemd-journald.socket: /run/systemd/journal/socket */
1801 r = server_open_native_socket(s);
1802 if (r < 0)
1803 return r;
1804
1805 /* /dev/ksmg */
1806 r = server_open_dev_kmsg(s);
1807 if (r < 0)
1808 return r;
1809
1810 /* Unless we got *some* sockets and not audit, open audit socket */
1811 if (s->audit_fd >= 0 || no_sockets) {
1812 r = server_open_audit(s);
1813 if (r < 0)
1814 return r;
1815 }
1816
1817 r = server_open_kernel_seqnum(s);
1818 if (r < 0)
1819 return r;
1820
1821 r = server_open_hostname(s);
1822 if (r < 0)
1823 return r;
1824
1825 r = setup_signals(s);
1826 if (r < 0)
1827 return r;
1828
1829 s->udev = udev_new();
1830 if (!s->udev)
1831 return -ENOMEM;
1832
1833 s->rate_limit = journal_rate_limit_new(s->rate_limit_interval, s->rate_limit_burst);
1834 if (!s->rate_limit)
1835 return -ENOMEM;
1836
1837 r = cg_get_root_path(&s->cgroup_root);
1838 if (r < 0)
1839 return r;
1840
1841 server_cache_hostname(s);
1842 server_cache_boot_id(s);
1843 server_cache_machine_id(s);
1844
1845 (void) server_connect_notify(s);
1846
1847 return system_journal_open(s, false);
1848 }
1849
1850 void server_maybe_append_tags(Server *s) {
1851 #ifdef HAVE_GCRYPT
1852 JournalFile *f;
1853 Iterator i;
1854 usec_t n;
1855
1856 n = now(CLOCK_REALTIME);
1857
1858 if (s->system_journal)
1859 journal_file_maybe_append_tag(s->system_journal, n);
1860
1861 ORDERED_HASHMAP_FOREACH(f, s->user_journals, i)
1862 journal_file_maybe_append_tag(f, n);
1863 #endif
1864 }
1865
1866 void server_done(Server *s) {
1867 JournalFile *f;
1868 assert(s);
1869
1870 while (s->stdout_streams)
1871 stdout_stream_free(s->stdout_streams);
1872
1873 if (s->system_journal)
1874 journal_file_close(s->system_journal);
1875
1876 if (s->runtime_journal)
1877 journal_file_close(s->runtime_journal);
1878
1879 while ((f = ordered_hashmap_steal_first(s->user_journals)))
1880 journal_file_close(f);
1881
1882 ordered_hashmap_free(s->user_journals);
1883
1884 sd_event_source_unref(s->syslog_event_source);
1885 sd_event_source_unref(s->native_event_source);
1886 sd_event_source_unref(s->stdout_event_source);
1887 sd_event_source_unref(s->dev_kmsg_event_source);
1888 sd_event_source_unref(s->audit_event_source);
1889 sd_event_source_unref(s->sync_event_source);
1890 sd_event_source_unref(s->sigusr1_event_source);
1891 sd_event_source_unref(s->sigusr2_event_source);
1892 sd_event_source_unref(s->sigterm_event_source);
1893 sd_event_source_unref(s->sigint_event_source);
1894 sd_event_source_unref(s->sigrtmin1_event_source);
1895 sd_event_source_unref(s->hostname_event_source);
1896 sd_event_source_unref(s->notify_event_source);
1897 sd_event_source_unref(s->watchdog_event_source);
1898 sd_event_unref(s->event);
1899
1900 safe_close(s->syslog_fd);
1901 safe_close(s->native_fd);
1902 safe_close(s->stdout_fd);
1903 safe_close(s->dev_kmsg_fd);
1904 safe_close(s->audit_fd);
1905 safe_close(s->hostname_fd);
1906 safe_close(s->notify_fd);
1907
1908 if (s->rate_limit)
1909 journal_rate_limit_free(s->rate_limit);
1910
1911 if (s->kernel_seqnum)
1912 munmap(s->kernel_seqnum, sizeof(uint64_t));
1913
1914 free(s->buffer);
1915 free(s->tty_path);
1916 free(s->cgroup_root);
1917 free(s->hostname_field);
1918
1919 if (s->mmap)
1920 mmap_cache_unref(s->mmap);
1921
1922 udev_unref(s->udev);
1923 }
1924
1925 static const char* const storage_table[_STORAGE_MAX] = {
1926 [STORAGE_AUTO] = "auto",
1927 [STORAGE_VOLATILE] = "volatile",
1928 [STORAGE_PERSISTENT] = "persistent",
1929 [STORAGE_NONE] = "none"
1930 };
1931
1932 DEFINE_STRING_TABLE_LOOKUP(storage, Storage);
1933 DEFINE_CONFIG_PARSE_ENUM(config_parse_storage, storage, Storage, "Failed to parse storage setting");
1934
1935 static const char* const split_mode_table[_SPLIT_MAX] = {
1936 [SPLIT_LOGIN] = "login",
1937 [SPLIT_UID] = "uid",
1938 [SPLIT_NONE] = "none",
1939 };
1940
1941 DEFINE_STRING_TABLE_LOOKUP(split_mode, SplitMode);
1942 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.