]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/journal/journald-server.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
honor SELinux labels, when creating and writing config files
[thirdparty/systemd.git] / src / journal / journald-server.c
CommitLineData
d025f1e4
ZJS		 1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3/***
4 This file is part of systemd.
5
6 Copyright 2011 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
22#include <sys/signalfd.h>
23#include <sys/ioctl.h>
24#include <linux/sockios.h>
25#include <sys/statvfs.h>
26#include <sys/mman.h>
27
28#include <libudev.h>
29#include <systemd/sd-journal.h>
30#include <systemd/sd-messages.h>
31#include <systemd/sd-daemon.h>
32
33#ifdef HAVE_LOGIND
34#include <systemd/sd-login.h>
35#endif
36
a5c32cff 37#include "fileio.h"
d025f1e4
ZJS		 38#include "mkdir.h"
39#include "hashmap.h"
40#include "journal-file.h"
41#include "socket-util.h"
42#include "cgroup-util.h"
43#include "list.h"
44#include "virt.h"
45#include "missing.h"
46#include "conf-parser.h"
47#include "journal-internal.h"
48#include "journal-vacuum.h"
49#include "journal-authenticate.h"
50#include "journald-server.h"
51#include "journald-rate-limit.h"
52#include "journald-kmsg.h"
53#include "journald-syslog.h"
54#include "journald-stream.h"
55#include "journald-console.h"
56#include "journald-native.h"
57
58#ifdef HAVE_ACL
59#include <sys/acl.h>
60#include <acl/libacl.h>
61#include "acl-util.h"
62#endif
63
64#ifdef HAVE_SELINUX
65#include <selinux/selinux.h>
66#endif
67
68#define USER_JOURNALS_MAX 1024
69
70#define DEFAULT_RATE_LIMIT_INTERVAL (10*USEC_PER_SEC)
71#define DEFAULT_RATE_LIMIT_BURST 200
72
73#define RECHECK_AVAILABLE_SPACE_USEC (30*USEC_PER_SEC)
74
75static const char* const storage_table[] = {
76 [STORAGE_AUTO] = "auto",
77 [STORAGE_VOLATILE] = "volatile",
78 [STORAGE_PERSISTENT] = "persistent",
79 [STORAGE_NONE] = "none"
80};
81
82DEFINE_STRING_TABLE_LOOKUP(storage, Storage);
83DEFINE_CONFIG_PARSE_ENUM(config_parse_storage, storage, Storage, "Failed to parse storage setting");
84
85static const char* const split_mode_table[] = {
86 [SPLIT_NONE] = "none",
87 [SPLIT_UID] = "uid",
88 [SPLIT_LOGIN] = "login"
89};
90
91DEFINE_STRING_TABLE_LOOKUP(split_mode, SplitMode);
92DEFINE_CONFIG_PARSE_ENUM(config_parse_split_mode, split_mode, SplitMode, "Failed to parse split mode setting");
93
94static uint64_t available_space(Server *s) {
db91ea32
ZJS		 95 char ids[33];
96 char _cleanup_free_ *p = NULL;
d025f1e4
ZJS		 97 const char *f;
98 sd_id128_t machine;
99 struct statvfs ss;
100 uint64_t sum = 0, avail = 0, ss_avail = 0;
101 int r;
db91ea32 102 DIR _cleanup_closedir_ *d = NULL;
d025f1e4
ZJS		 103 usec_t ts;
104 JournalMetrics *m;
105
106 ts = now(CLOCK_MONOTONIC);
107
108 if (s->cached_available_space_timestamp + RECHECK_AVAILABLE_SPACE_USEC > ts)
109 return s->cached_available_space;
110
111 r = sd_id128_get_machine(&machine);
112 if (r < 0)
113 return 0;
114
115 if (s->system_journal) {
116 f = "/var/log/journal/";
117 m = &s->system_metrics;
118 } else {
119 f = "/run/log/journal/";
120 m = &s->runtime_metrics;
121 }
122
123 assert(m);
124
125 p = strappend(f, sd_id128_to_string(machine, ids));
126 if (!p)
127 return 0;
128
129 d = opendir(p);
d025f1e4
ZJS		 130 if (!d)
131 return 0;
132
133 if (fstatvfs(dirfd(d), &ss) < 0)
db91ea32 134 return 0;
d025f1e4
ZJS		 135
136 for (;;) {
137 struct stat st;
138 struct dirent *de;
139 union dirent_storage buf;
140
141 r = readdir_r(d, &buf.de, &de);
142 if (r != 0)
143 break;
144
145 if (!de)
146 break;
147
148 if (!endswith(de->d_name, ".journal") &&
149 !endswith(de->d_name, ".journal~"))
150 continue;
151
152 if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
153 continue;
154
155 if (!S_ISREG(st.st_mode))
156 continue;
157
158 sum += (uint64_t) st.st_blocks * 512UL;
159 }
160
161 avail = sum >= m->max_use ? 0 : m->max_use - sum;
162
163 ss_avail = ss.f_bsize * ss.f_bavail;
164
165 ss_avail = ss_avail < m->keep_free ? 0 : ss_avail - m->keep_free;
166
167 if (ss_avail < avail)
168 avail = ss_avail;
169
170 s->cached_available_space = avail;
171 s->cached_available_space_timestamp = ts;
172
d025f1e4
ZJS		 173 return avail;
174}
175
176static void server_read_file_gid(Server *s) {
177 const char *adm = "adm";
178 int r;
179
180 assert(s);
181
182 if (s->file_gid_valid)
183 return;
184
185 r = get_group_creds(&adm, &s->file_gid);
186 if (r < 0)
187 log_warning("Failed to resolve 'adm' group: %s", strerror(-r));
188
189 /* if we couldn't read the gid, then it will be 0, but that's
190 * fine and we shouldn't try to resolve the group again, so
191 * let's just pretend it worked right-away. */
192 s->file_gid_valid = true;
193}
194
195void server_fix_perms(Server *s, JournalFile *f, uid_t uid) {
196 int r;
197#ifdef HAVE_ACL
198 acl_t acl;
199 acl_entry_t entry;
200 acl_permset_t permset;
201#endif
202
203 assert(f);
204
205 server_read_file_gid(s);
206
207 r = fchmod_and_fchown(f->fd, 0640, 0, s->file_gid);
208 if (r < 0)
209 log_warning("Failed to fix access mode/rights on %s, ignoring: %s", f->path, strerror(-r));
210
211#ifdef HAVE_ACL
212 if (uid <= 0)
213 return;
214
215 acl = acl_get_fd(f->fd);
216 if (!acl) {
217 log_warning("Failed to read ACL on %s, ignoring: %m", f->path);
218 return;
219 }
220
221 r = acl_find_uid(acl, uid, &entry);
222 if (r <= 0) {
223
224 if (acl_create_entry(&acl, &entry) < 0 ||
225 acl_set_tag_type(entry, ACL_USER) < 0 ||
226 acl_set_qualifier(entry, &uid) < 0) {
227 log_warning("Failed to patch ACL on %s, ignoring: %m", f->path);
228 goto finish;
229 }
230 }
231
232 if (acl_get_permset(entry, &permset) < 0 ||
233 acl_add_perm(permset, ACL_READ) < 0 ||
234 acl_calc_mask(&acl) < 0) {
235 log_warning("Failed to patch ACL on %s, ignoring: %m", f->path);
236 goto finish;
237 }
238
239 if (acl_set_fd(f->fd, acl) < 0)
240 log_warning("Failed to set ACL on %s, ignoring: %m", f->path);
241
242finish:
243 acl_free(acl);
244#endif
245}
246
247static JournalFile* find_journal(Server *s, uid_t uid) {
248 char *p;
249 int r;
250 JournalFile *f;
251 sd_id128_t machine;
252
253 assert(s);
254
255 /* We split up user logs only on /var, not on /run. If the
256 * runtime file is open, we write to it exclusively, in order
257 * to guarantee proper order as soon as we flush /run to
258 * /var and close the runtime file. */
259
260 if (s->runtime_journal)
261 return s->runtime_journal;
262
263 if (uid <= 0)
264 return s->system_journal;
265
266 r = sd_id128_get_machine(&machine);
267 if (r < 0)
268 return s->system_journal;
269
270 f = hashmap_get(s->user_journals, UINT32_TO_PTR(uid));
271 if (f)
272 return f;
273
274 if (asprintf(&p, "/var/log/journal/" SD_ID128_FORMAT_STR "/user-%lu.journal",
275 SD_ID128_FORMAT_VAL(machine), (unsigned long) uid) < 0)
276 return s->system_journal;
277
278 while (hashmap_size(s->user_journals) >= USER_JOURNALS_MAX) {
279 /* Too many open? Then let's close one */
280 f = hashmap_steal_first(s->user_journals);
281 assert(f);
282 journal_file_close(f);
283 }
284
285 r = journal_file_open_reliably(p, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, s->system_journal, &f);
286 free(p);
287
288 if (r < 0)
289 return s->system_journal;
290
291 server_fix_perms(s, f, uid);
292
293 r = hashmap_put(s->user_journals, UINT32_TO_PTR(uid), f);
294 if (r < 0) {
295 journal_file_close(f);
296 return s->system_journal;
297 }
298
299 return f;
300}
301
302void server_rotate(Server *s) {
303 JournalFile *f;
304 void *k;
305 Iterator i;
306 int r;
307
308 log_debug("Rotating...");
309
310 if (s->runtime_journal) {
311 r = journal_file_rotate(&s->runtime_journal, s->compress, false);
312 if (r < 0)
313 if (s->runtime_journal)
314 log_error("Failed to rotate %s: %s", s->runtime_journal->path, strerror(-r));
315 else
316 log_error("Failed to create new runtime journal: %s", strerror(-r));
317 else
318 server_fix_perms(s, s->runtime_journal, 0);
319 }
320
321 if (s->system_journal) {
322 r = journal_file_rotate(&s->system_journal, s->compress, s->seal);
323 if (r < 0)
324 if (s->system_journal)
325 log_error("Failed to rotate %s: %s", s->system_journal->path, strerror(-r));
326 else
327 log_error("Failed to create new system journal: %s", strerror(-r));
328
329 else
330 server_fix_perms(s, s->system_journal, 0);
331 }
332
333 HASHMAP_FOREACH_KEY(f, k, s->user_journals, i) {
334 r = journal_file_rotate(&f, s->compress, s->seal);
335 if (r < 0)
7d73c134 336 if (f)
d025f1e4
ZJS		 337 log_error("Failed to rotate %s: %s", f->path, strerror(-r));
338 else
339 log_error("Failed to create user journal: %s", strerror(-r));
340 else {
341 hashmap_replace(s->user_journals, k, f);
342 server_fix_perms(s, f, PTR_TO_UINT32(k));
343 }
344 }
345}
346
347void server_vacuum(Server *s) {
348 char *p;
349 char ids[33];
350 sd_id128_t machine;
351 int r;
352
353 log_debug("Vacuuming...");
354
355 s->oldest_file_usec = 0;
356
357 r = sd_id128_get_machine(&machine);
358 if (r < 0) {
359 log_error("Failed to get machine ID: %s", strerror(-r));
360 return;
361 }
362
363 sd_id128_to_string(machine, ids);
364
365 if (s->system_journal) {
366 p = strappend("/var/log/journal/", ids);
367 if (!p) {
368 log_oom();
369 return;
370 }
371
372 r = journal_directory_vacuum(p, s->system_metrics.max_use, s->system_metrics.keep_free, s->max_retention_usec, &s->oldest_file_usec);
373 if (r < 0 && r != -ENOENT)
374 log_error("Failed to vacuum %s: %s", p, strerror(-r));
375 free(p);
376 }
377
378 if (s->runtime_journal) {
379 p = strappend("/run/log/journal/", ids);
380 if (!p) {
381 log_oom();
382 return;
383 }
384
385 r = journal_directory_vacuum(p, s->runtime_metrics.max_use, s->runtime_metrics.keep_free, s->max_retention_usec, &s->oldest_file_usec);
386 if (r < 0 && r != -ENOENT)
387 log_error("Failed to vacuum %s: %s", p, strerror(-r));
388 free(p);
389 }
390
391 s->cached_available_space_timestamp = 0;
392}
393
394static char *shortened_cgroup_path(pid_t pid) {
395 int r;
db91ea32
ZJS		 396 char _cleanup_free_ *process_path = NULL, *init_path = NULL;
397 char *path;
d025f1e4
ZJS		 398
399 assert(pid > 0);
400
401 r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, pid, &process_path);
402 if (r < 0)
403 return NULL;
404
405 r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, 1, &init_path);
db91ea32 406 if (r < 0)
d025f1e4 407 return NULL;
d025f1e4
ZJS		 408
409 if (endswith(init_path, "/system"))
410 init_path[strlen(init_path) - 7] = 0;
411 else if (streq(init_path, "/"))
412 init_path[0] = 0;
413
414 if (startswith(process_path, init_path)) {
db91ea32 415 path = strdup(process_path + strlen(init_path));
d025f1e4
ZJS		 416 } else {
417 path = process_path;
418 process_path = NULL;
419 }
420
d025f1e4
ZJS		 421 return path;
422}
423
424bool shall_try_append_again(JournalFile *f, int r) {
425
426 /* -E2BIG Hit configured limit
427 -EFBIG Hit fs limit
428 -EDQUOT Quota limit hit
429 -ENOSPC Disk full
430 -EHOSTDOWN Other machine
431 -EBUSY Unclean shutdown
432 -EPROTONOSUPPORT Unsupported feature
433 -EBADMSG Corrupted
434 -ENODATA Truncated
435 -ESHUTDOWN Already archived */
436
437 if (r == -E2BIG || r == -EFBIG || r == -EDQUOT || r == -ENOSPC)
438 log_debug("%s: Allocation limit reached, rotating.", f->path);
439 else if (r == -EHOSTDOWN)
440 log_info("%s: Journal file from other machine, rotating.", f->path);
441 else if (r == -EBUSY)
442 log_info("%s: Unclean shutdown, rotating.", f->path);
443 else if (r == -EPROTONOSUPPORT)
444 log_info("%s: Unsupported feature, rotating.", f->path);
445 else if (r == -EBADMSG || r == -ENODATA || r == ESHUTDOWN)
446 log_warning("%s: Journal file corrupted, rotating.", f->path);
447 else
448 return false;
449
450 return true;
451}
452
453static void write_to_journal(Server *s, uid_t uid, struct iovec *iovec, unsigned n) {
454 JournalFile *f;
455 bool vacuumed = false;
456 int r;
457
458 assert(s);
459 assert(iovec);
460 assert(n > 0);
461
462 f = find_journal(s, uid);
463 if (!f)
464 return;
465
466 if (journal_file_rotate_suggested(f, s->max_file_usec)) {
467 log_debug("%s: Journal header limits reached or header out-of-date, rotating.", f->path);
468 server_rotate(s);
469 server_vacuum(s);
470 vacuumed = true;
471
472 f = find_journal(s, uid);
473 if (!f)
474 return;
475 }
476
477 r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL);
478 if (r >= 0)
479 return;
480
481 if (vacuumed || !shall_try_append_again(f, r)) {
482 log_error("Failed to write entry, ignoring: %s", strerror(-r));
483 return;
484 }
485
486 server_rotate(s);
487 server_vacuum(s);
488
489 f = find_journal(s, uid);
490 if (!f)
491 return;
492
493 log_debug("Retrying write.");
494 r = journal_file_append_entry(f, NULL, iovec, n, &s->seqnum, NULL, NULL);
495 if (r < 0)
496 log_error("Failed to write entry, ignoring: %s", strerror(-r));
497}
498
499static void dispatch_message_real(
500 Server *s,
501 struct iovec *iovec, unsigned n, unsigned m,
502 struct ucred *ucred,
503 struct timeval *tv,
504 const char *label, size_t label_len,
505 const char *unit_id) {
506
db91ea32 507 char _cleanup_free_ *pid = NULL, *uid = NULL, *gid = NULL,
d025f1e4
ZJS		 508 *source_time = NULL, *boot_id = NULL, *machine_id = NULL,
509 *comm = NULL, *cmdline = NULL, *hostname = NULL,
510 *audit_session = NULL, *audit_loginuid = NULL,
511 *exe = NULL, *cgroup = NULL, *session = NULL,
512 *owner_uid = NULL, *unit = NULL, *selinux_context = NULL;
513
514 char idbuf[33];
515 sd_id128_t id;
516 int r;
517 char *t;
518 uid_t loginuid = 0, realuid = 0;
759c945a
CW		 519 uid_t journal_uid;
520 bool loginuid_valid = false;
d025f1e4
ZJS		 521
522 assert(s);
523 assert(iovec);
524 assert(n > 0);
525 assert(n + N_IOVEC_META_FIELDS <= m);
526
527 if (ucred) {
528 uint32_t audit;
529#ifdef HAVE_LOGIND
530 uid_t owner;
531#endif
532
533 realuid = ucred->uid;
534
535 if (asprintf(&pid, "_PID=%lu", (unsigned long) ucred->pid) >= 0)
536 IOVEC_SET_STRING(iovec[n++], pid);
537
538 if (asprintf(&uid, "_UID=%lu", (unsigned long) ucred->uid) >= 0)
539 IOVEC_SET_STRING(iovec[n++], uid);
540
541 if (asprintf(&gid, "_GID=%lu", (unsigned long) ucred->gid) >= 0)
542 IOVEC_SET_STRING(iovec[n++], gid);
543
544 r = get_process_comm(ucred->pid, &t);
545 if (r >= 0) {
546 comm = strappend("_COMM=", t);
547 free(t);
548
549 if (comm)
550 IOVEC_SET_STRING(iovec[n++], comm);
551 }
552
553 r = get_process_exe(ucred->pid, &t);
554 if (r >= 0) {
555 exe = strappend("_EXE=", t);
556 free(t);
557
558 if (exe)
559 IOVEC_SET_STRING(iovec[n++], exe);
560 }
561
9bdbc2e2 562 r = get_process_cmdline(ucred->pid, 0, false, &t);
d025f1e4
ZJS		 563 if (r >= 0) {
564 cmdline = strappend("_CMDLINE=", t);
565 free(t);
566
567 if (cmdline)
568 IOVEC_SET_STRING(iovec[n++], cmdline);
569 }
570
571 r = audit_session_from_pid(ucred->pid, &audit);
572 if (r >= 0)
573 if (asprintf(&audit_session, "_AUDIT_SESSION=%lu", (unsigned long) audit) >= 0)
574 IOVEC_SET_STRING(iovec[n++], audit_session);
575
576 r = audit_loginuid_from_pid(ucred->pid, &loginuid);
759c945a
CW		 577 if (r >= 0) {
578 loginuid_valid = true;
d025f1e4
ZJS		 579 if (asprintf(&audit_loginuid, "_AUDIT_LOGINUID=%lu", (unsigned long) loginuid) >= 0)
580 IOVEC_SET_STRING(iovec[n++], audit_loginuid);
759c945a 581 }
d025f1e4
ZJS		 582
583 t = shortened_cgroup_path(ucred->pid);
584 if (t) {
585 cgroup = strappend("_SYSTEMD_CGROUP=", t);
586 free(t);
587
588 if (cgroup)
589 IOVEC_SET_STRING(iovec[n++], cgroup);
590 }
591
592#ifdef HAVE_LOGIND
593 if (sd_pid_get_session(ucred->pid, &t) >= 0) {
594 session = strappend("_SYSTEMD_SESSION=", t);
595 free(t);
596
597 if (session)
598 IOVEC_SET_STRING(iovec[n++], session);
599 }
600
601 if (sd_pid_get_owner_uid(ucred->uid, &owner) >= 0)
602 if (asprintf(&owner_uid, "_SYSTEMD_OWNER_UID=%lu", (unsigned long) owner) >= 0)
603 IOVEC_SET_STRING(iovec[n++], owner_uid);
604#endif
605
606 if (cg_pid_get_unit(ucred->pid, &t) >= 0) {
607 unit = strappend("_SYSTEMD_UNIT=", t);
608 free(t);
ef1673d1
MT		 609 } else if (cg_pid_get_user_unit(ucred->pid, &t) >= 0) {
610 unit = strappend("_SYSTEMD_USER_UNIT=", t);
611 free(t);
612 } else if (unit_id) {
613 if (session)
614 unit = strappend("_SYSTEMD_USER_UNIT=", unit_id);
615 else
616 unit = strappend("_SYSTEMD_UNIT=", unit_id);
617 }
d025f1e4
ZJS		 618
619 if (unit)
620 IOVEC_SET_STRING(iovec[n++], unit);
621
622#ifdef HAVE_SELINUX
623 if (label) {
624 selinux_context = malloc(sizeof("_SELINUX_CONTEXT=") + label_len);
625 if (selinux_context) {
626 memcpy(selinux_context, "_SELINUX_CONTEXT=", sizeof("_SELINUX_CONTEXT=")-1);
627 memcpy(selinux_context+sizeof("_SELINUX_CONTEXT=")-1, label, label_len);
628 selinux_context[sizeof("_SELINUX_CONTEXT=")-1+label_len] = 0;
629 IOVEC_SET_STRING(iovec[n++], selinux_context);
630 }
631 } else {
632 security_context_t con;
633
634 if (getpidcon(ucred->pid, &con) >= 0) {
635 selinux_context = strappend("_SELINUX_CONTEXT=", con);
636 if (selinux_context)
637 IOVEC_SET_STRING(iovec[n++], selinux_context);
638
639 freecon(con);
640 }
641 }
642#endif
643 }
644
645 if (tv) {
646 if (asprintf(&source_time, "_SOURCE_REALTIME_TIMESTAMP=%llu",
647 (unsigned long long) timeval_load(tv)) >= 0)
648 IOVEC_SET_STRING(iovec[n++], source_time);
649 }
650
651 /* Note that strictly speaking storing the boot id here is
652 * redundant since the entry includes this in-line
653 * anyway. However, we need this indexed, too. */
654 r = sd_id128_get_boot(&id);
655 if (r >= 0)
656 if (asprintf(&boot_id, "_BOOT_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
657 IOVEC_SET_STRING(iovec[n++], boot_id);
658
659 r = sd_id128_get_machine(&id);
660 if (r >= 0)
661 if (asprintf(&machine_id, "_MACHINE_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
662 IOVEC_SET_STRING(iovec[n++], machine_id);
663
664 t = gethostname_malloc();
665 if (t) {
666 hostname = strappend("_HOSTNAME=", t);
667 free(t);
668 if (hostname)
669 IOVEC_SET_STRING(iovec[n++], hostname);
670 }
671
672 assert(n <= m);
673
759c945a
CW		 674 if (s->split_mode == SPLIT_NONE)
675 journal_uid = 0;
676 else if (s->split_mode == SPLIT_UID || realuid == 0 || !loginuid_valid)
677 journal_uid = realuid;
678 else
679 journal_uid = loginuid;
680
681 write_to_journal(s, journal_uid, iovec, n);
d025f1e4
ZJS		 682}
683
684void server_driver_message(Server *s, sd_id128_t message_id, const char *format, ...) {
685 char mid[11 + 32 + 1];
686 char buffer[16 + LINE_MAX + 1];
687 struct iovec iovec[N_IOVEC_META_FIELDS + 4];
688 int n = 0;
689 va_list ap;
690 struct ucred ucred;
691
692 assert(s);
693 assert(format);
694
695 IOVEC_SET_STRING(iovec[n++], "PRIORITY=6");
696 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=driver");
697
698 memcpy(buffer, "MESSAGE=", 8);
699 va_start(ap, format);
700 vsnprintf(buffer + 8, sizeof(buffer) - 8, format, ap);
701 va_end(ap);
702 char_array_0(buffer);
703 IOVEC_SET_STRING(iovec[n++], buffer);
704
705 if (!sd_id128_equal(message_id, SD_ID128_NULL)) {
706 snprintf(mid, sizeof(mid), MESSAGE_ID(message_id));
707 char_array_0(mid);
708 IOVEC_SET_STRING(iovec[n++], mid);
709 }
710
711 zero(ucred);
712 ucred.pid = getpid();
713 ucred.uid = getuid();
714 ucred.gid = getgid();
715
716 dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL);
717}
718
719void server_dispatch_message(
720 Server *s,
721 struct iovec *iovec, unsigned n, unsigned m,
722 struct ucred *ucred,
723 struct timeval *tv,
724 const char *label, size_t label_len,
725 const char *unit_id,
726 int priority) {
727
728 int rl;
db91ea32
ZJS		 729 char _cleanup_free_ *path = NULL;
730 char *c;
d025f1e4
ZJS		 731
732 assert(s);
733 assert(iovec || n == 0);
734
735 if (n == 0)
736 return;
737
738 if (LOG_PRI(priority) > s->max_level_store)
739 return;
740
741 if (!ucred)
742 goto finish;
743
744 path = shortened_cgroup_path(ucred->pid);
745 if (!path)
746 goto finish;
747
748 /* example: /user/lennart/3/foobar
749 * /system/dbus.service/foobar
750 *
751 * So let's cut of everything past the third /, since that is
752 * where user directories start */
753
754 c = strchr(path, '/');
755 if (c) {
756 c = strchr(c+1, '/');
757 if (c) {
758 c = strchr(c+1, '/');
759 if (c)
760 *c = 0;
761 }
762 }
763
db91ea32
ZJS		 764 rl = journal_rate_limit_test(s->rate_limit, path,
765 priority & LOG_PRIMASK, available_space(s));
d025f1e4 766
db91ea32 767 if (rl == 0)
d025f1e4 768 return;
d025f1e4
ZJS		 769
770 /* Write a suppression message if we suppressed something */
771 if (rl > 1)
db91ea32
ZJS		 772 server_driver_message(s, SD_MESSAGE_JOURNAL_DROPPED,
773 "Suppressed %u messages from %s", rl - 1, path);
d025f1e4
ZJS		 774
775finish:
776 dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id);
777}
778
779
780static int system_journal_open(Server *s) {
781 int r;
782 char *fn;
783 sd_id128_t machine;
784 char ids[33];
785
786 r = sd_id128_get_machine(&machine);
787 if (r < 0)
788 return r;
789
790 sd_id128_to_string(machine, ids);
791
792 if (!s->system_journal &&
793 (s->storage == STORAGE_PERSISTENT || s->storage == STORAGE_AUTO) &&
794 access("/run/systemd/journal/flushed", F_OK) >= 0) {
795
796 /* If in auto mode: first try to create the machine
797 * path, but not the prefix.
798 *
799 * If in persistent mode: create /var/log/journal and
800 * the machine path */
801
802 if (s->storage == STORAGE_PERSISTENT)
803 (void) mkdir("/var/log/journal/", 0755);
804
805 fn = strappend("/var/log/journal/", ids);
806 if (!fn)
807 return -ENOMEM;
808
809 (void) mkdir(fn, 0755);
810 free(fn);
811
812 fn = strjoin("/var/log/journal/", ids, "/system.journal", NULL);
813 if (!fn)
814 return -ENOMEM;
815
816 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, NULL, &s->system_journal);
817 free(fn);
818
819 if (r >= 0) {
820 char fb[FORMAT_BYTES_MAX];
821
822 server_fix_perms(s, s->system_journal, 0);
823 server_driver_message(s, SD_ID128_NULL, "Allowing system journal files to grow to %s.",
824 format_bytes(fb, sizeof(fb), s->system_metrics.max_use));
825
826 } else if (r < 0) {
827
828 if (r != -ENOENT && r != -EROFS)
829 log_warning("Failed to open system journal: %s", strerror(-r));
830
831 r = 0;
832 }
833 }
834
835 if (!s->runtime_journal &&
836 (s->storage != STORAGE_NONE)) {
837
838 fn = strjoin("/run/log/journal/", ids, "/system.journal", NULL);
839 if (!fn)
840 return -ENOMEM;
841
842 if (s->system_journal) {
843
844 /* Try to open the runtime journal, but only
845 * if it already exists, so that we can flush
846 * it into the system journal */
847
848 r = journal_file_open(fn, O_RDWR, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
849 free(fn);
850
851 if (r < 0) {
852 if (r != -ENOENT)
853 log_warning("Failed to open runtime journal: %s", strerror(-r));
854
855 r = 0;
856 }
857
858 } else {
859
860 /* OK, we really need the runtime journal, so create
861 * it if necessary. */
862
863 (void) mkdir_parents(fn, 0755);
864 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
865 free(fn);
866
867 if (r < 0) {
868 log_error("Failed to open runtime journal: %s", strerror(-r));
869 return r;
870 }
871 }
872
873 if (s->runtime_journal) {
874 char fb[FORMAT_BYTES_MAX];
875
876 server_fix_perms(s, s->runtime_journal, 0);
877 server_driver_message(s, SD_ID128_NULL, "Allowing runtime journal files to grow to %s.",
878 format_bytes(fb, sizeof(fb), s->runtime_metrics.max_use));
879 }
880 }
881
882 return r;
883}
884
885int server_flush_to_var(Server *s) {
886 int r;
887 sd_id128_t machine;
888 sd_journal *j = NULL;
889
890 assert(s);
891
892 if (s->storage != STORAGE_AUTO &&
893 s->storage != STORAGE_PERSISTENT)
894 return 0;
895
896 if (!s->runtime_journal)
897 return 0;
898
899 system_journal_open(s);
900
901 if (!s->system_journal)
902 return 0;
903
904 log_debug("Flushing to /var...");
905
906 r = sd_id128_get_machine(&machine);
907 if (r < 0) {
908 log_error("Failed to get machine id: %s", strerror(-r));
909 return r;
910 }
911
912 r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
913 if (r < 0) {
914 log_error("Failed to read runtime journal: %s", strerror(-r));
915 return r;
916 }
917
93b73b06
LP		 918 sd_journal_set_data_threshold(j, 0);
919
d025f1e4
ZJS		 920 SD_JOURNAL_FOREACH(j) {
921 Object *o = NULL;
922 JournalFile *f;
923
924 f = j->current_file;
925 assert(f && f->current_offset > 0);
926
927 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
928 if (r < 0) {
929 log_error("Can't read entry: %s", strerror(-r));
930 goto finish;
931 }
932
933 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
934 if (r >= 0)
935 continue;
936
937 if (!shall_try_append_again(s->system_journal, r)) {
938 log_error("Can't write entry: %s", strerror(-r));
939 goto finish;
940 }
941
942 server_rotate(s);
943 server_vacuum(s);
944
945 log_debug("Retrying write.");
946 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
947 if (r < 0) {
948 log_error("Can't write entry: %s", strerror(-r));
949 goto finish;
950 }
951 }
952
953finish:
954 journal_file_post_change(s->system_journal);
955
956 journal_file_close(s->runtime_journal);
957 s->runtime_journal = NULL;
958
959 if (r >= 0)
960 rm_rf("/run/log/journal", false, true, false);
961
962 if (j)
963 sd_journal_close(j);
964
965 return r;
966}
967
968int process_event(Server *s, struct epoll_event *ev) {
969 assert(s);
970 assert(ev);
971
972 if (ev->data.fd == s->signal_fd) {
973 struct signalfd_siginfo sfsi;
974 ssize_t n;
975
976 if (ev->events != EPOLLIN) {
977 log_error("Got invalid event from epoll.");
978 return -EIO;
979 }
980
981 n = read(s->signal_fd, &sfsi, sizeof(sfsi));
982 if (n != sizeof(sfsi)) {
983
984 if (n >= 0)
985 return -EIO;
986
987 if (errno == EINTR || errno == EAGAIN)
988 return 1;
989
990 return -errno;
991 }
992
993 log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo));
994
995 if (sfsi.ssi_signo == SIGUSR1) {
996 touch("/run/systemd/journal/flushed");
997 server_flush_to_var(s);
998 return 1;
999 }
1000
1001 if (sfsi.ssi_signo == SIGUSR2) {
1002 server_rotate(s);
1003 server_vacuum(s);
1004 return 1;
1005 }
1006
1007 return 0;
1008
1009 } else if (ev->data.fd == s->dev_kmsg_fd) {
1010 int r;
1011
1012 if (ev->events != EPOLLIN) {
1013 log_error("Got invalid event from epoll.");
1014 return -EIO;
1015 }
1016
1017 r = server_read_dev_kmsg(s);
1018 if (r < 0)
1019 return r;
1020
1021 return 1;
1022
1023 } else if (ev->data.fd == s->native_fd ||
1024 ev->data.fd == s->syslog_fd) {
1025
1026 if (ev->events != EPOLLIN) {
1027 log_error("Got invalid event from epoll.");
1028 return -EIO;
1029 }
1030
1031 for (;;) {
1032 struct msghdr msghdr;
1033 struct iovec iovec;
1034 struct ucred *ucred = NULL;
1035 struct timeval *tv = NULL;
1036 struct cmsghdr *cmsg;
1037 char *label = NULL;
1038 size_t label_len = 0;
1039 union {
1040 struct cmsghdr cmsghdr;
1041
1042 /* We use NAME_MAX space for the
1043 * SELinux label here. The kernel
1044 * currently enforces no limit, but
1045 * according to suggestions from the
1046 * SELinux people this will change and
1047 * it will probably be identical to
1048 * NAME_MAX. For now we use that, but
1049 * this should be updated one day when
1050 * the final limit is known.*/
1051 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1052 CMSG_SPACE(sizeof(struct timeval)) +
1053 CMSG_SPACE(sizeof(int)) + /* fd */
1054 CMSG_SPACE(NAME_MAX)]; /* selinux label */
1055 } control;
1056 ssize_t n;
1057 int v;
1058 int *fds = NULL;
1059 unsigned n_fds = 0;
1060
1061 if (ioctl(ev->data.fd, SIOCINQ, &v) < 0) {
1062 log_error("SIOCINQ failed: %m");
1063 return -errno;
1064 }
1065
1066 if (s->buffer_size < (size_t) v) {
1067 void *b;
1068 size_t l;
1069
1070 l = MAX(LINE_MAX + (size_t) v, s->buffer_size * 2);
1071 b = realloc(s->buffer, l+1);
1072
1073 if (!b) {
1074 log_error("Couldn't increase buffer.");
1075 return -ENOMEM;
1076 }
1077
1078 s->buffer_size = l;
1079 s->buffer = b;
1080 }
1081
1082 zero(iovec);
1083 iovec.iov_base = s->buffer;
1084 iovec.iov_len = s->buffer_size;
1085
1086 zero(control);
1087 zero(msghdr);
1088 msghdr.msg_iov = &iovec;
1089 msghdr.msg_iovlen = 1;
1090 msghdr.msg_control = &control;
1091 msghdr.msg_controllen = sizeof(control);
1092
1093 n = recvmsg(ev->data.fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1094 if (n < 0) {
1095
1096 if (errno == EINTR || errno == EAGAIN)
1097 return 1;
1098
1099 log_error("recvmsg() failed: %m");
1100 return -errno;
1101 }
1102
1103 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1104
1105 if (cmsg->cmsg_level == SOL_SOCKET &&
1106 cmsg->cmsg_type == SCM_CREDENTIALS &&
1107 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
1108 ucred = (struct ucred*) CMSG_DATA(cmsg);
1109 else if (cmsg->cmsg_level == SOL_SOCKET &&
1110 cmsg->cmsg_type == SCM_SECURITY) {
1111 label = (char*) CMSG_DATA(cmsg);
1112 label_len = cmsg->cmsg_len - CMSG_LEN(0);
1113 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1114 cmsg->cmsg_type == SO_TIMESTAMP &&
1115 cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
1116 tv = (struct timeval*) CMSG_DATA(cmsg);
1117 else if (cmsg->cmsg_level == SOL_SOCKET &&
1118 cmsg->cmsg_type == SCM_RIGHTS) {
1119 fds = (int*) CMSG_DATA(cmsg);
1120 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1121 }
1122 }
1123
1124 if (ev->data.fd == s->syslog_fd) {
1125 char *e;
1126
1127 if (n > 0 && n_fds == 0) {
1128 e = memchr(s->buffer, '\n', n);
1129 if (e)
1130 *e = 0;
1131 else
1132 s->buffer[n] = 0;
1133
1134 server_process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);
1135 } else if (n_fds > 0)
1136 log_warning("Got file descriptors via syslog socket. Ignoring.");
1137
1138 } else {
1139 if (n > 0 && n_fds == 0)
1140 server_process_native_message(s, s->buffer, n, ucred, tv, label, label_len);
1141 else if (n == 0 && n_fds == 1)
1142 server_process_native_file(s, fds[0], ucred, tv, label, label_len);
1143 else if (n_fds > 0)
1144 log_warning("Got too many file descriptors via native socket. Ignoring.");
1145 }
1146
1147 close_many(fds, n_fds);
1148 }
1149
1150 return 1;
1151
1152 } else if (ev->data.fd == s->stdout_fd) {
1153
1154 if (ev->events != EPOLLIN) {
1155 log_error("Got invalid event from epoll.");
1156 return -EIO;
1157 }
1158
1159 stdout_stream_new(s);
1160 return 1;
1161
1162 } else {
1163 StdoutStream *stream;
1164
1165 if ((ev->events|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
1166 log_error("Got invalid event from epoll.");
1167 return -EIO;
1168 }
1169
1170 /* If it is none of the well-known fds, it must be an
1171 * stdout stream fd. Note that this is a bit ugly here
1172 * (since we rely that none of the well-known fds
1173 * could be interpreted as pointer), but nonetheless
1174 * safe, since the well-known fds would never get an
1175 * fd > 4096, i.e. beyond the first memory page */
1176
1177 stream = ev->data.ptr;
1178
1179 if (stdout_stream_process(stream) <= 0)
1180 stdout_stream_free(stream);
1181
1182 return 1;
1183 }
1184
1185 log_error("Unknown event.");
1186 return 0;
1187}
1188
1189static int open_signalfd(Server *s) {
1190 sigset_t mask;
1191 struct epoll_event ev;
1192
1193 assert(s);
1194
1195 assert_se(sigemptyset(&mask) == 0);
1196 sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
1197 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
1198
1199 s->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
1200 if (s->signal_fd < 0) {
1201 log_error("signalfd(): %m");
1202 return -errno;
1203 }
1204
1205 zero(ev);
1206 ev.events = EPOLLIN;
1207 ev.data.fd = s->signal_fd;
1208
1209 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->signal_fd, &ev) < 0) {
1210 log_error("epoll_ctl(): %m");
1211 return -errno;
1212 }
1213
1214 return 0;
1215}
1216
1217static int server_parse_proc_cmdline(Server *s) {
db91ea32
ZJS		 1218 char _cleanup_free_ *line = NULL;
1219 char *w, *state;
d025f1e4
ZJS		 1220 int r;
1221 size_t l;
1222
1223 if (detect_container(NULL) > 0)
1224 return 0;
1225
1226 r = read_one_line_file("/proc/cmdline", &line);
1227 if (r < 0) {
1228 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
1229 return 0;
1230 }
1231
1232 FOREACH_WORD_QUOTED(w, l, line, state) {
db91ea32 1233 char _cleanup_free_ *word;
d025f1e4
ZJS		 1234
1235 word = strndup(w, l);
db91ea32
ZJS		 1236 if (!word)
1237 return -ENOMEM;
d025f1e4
ZJS		 1238
1239 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
1240 r = parse_boolean(word + 35);
1241 if (r < 0)
1242 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
1243 else
1244 s->forward_to_syslog = r;
1245 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
1246 r = parse_boolean(word + 33);
1247 if (r < 0)
1248 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
1249 else
1250 s->forward_to_kmsg = r;
1251 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
1252 r = parse_boolean(word + 36);
1253 if (r < 0)
1254 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
1255 else
1256 s->forward_to_console = r;
1257 } else if (startswith(word, "systemd.journald"))
1258 log_warning("Invalid systemd.journald parameter. Ignoring.");
d025f1e4
ZJS		 1259 }
1260
db91ea32 1261 return 0;
d025f1e4
ZJS		 1262}
1263
1264static int server_parse_config_file(Server *s) {
db91ea32
ZJS		 1265 static const char *fn = "/etc/systemd/journald.conf";
1266 FILE _cleanup_fclose_ *f = NULL;
d025f1e4
ZJS		 1267 int r;
1268
1269 assert(s);
1270
d025f1e4
ZJS		 1271 f = fopen(fn, "re");
1272 if (!f) {
1273 if (errno == ENOENT)
1274 return 0;
1275
1276 log_warning("Failed to open configuration file %s: %m", fn);
1277 return -errno;
1278 }
1279
db91ea32
ZJS		 1280 r = config_parse(fn, f, "Journal\0", config_item_perf_lookup,
1281 (void*) journald_gperf_lookup, false, s);
d025f1e4
ZJS		 1282 if (r < 0)
1283 log_warning("Failed to parse configuration file: %s", strerror(-r));
1284
d025f1e4
ZJS		 1285 return r;
1286}
1287
1288int server_init(Server *s) {
1289 int n, r, fd;
1290
1291 assert(s);
1292
1293 zero(*s);
1294 s->syslog_fd = s->native_fd = s->stdout_fd = s->signal_fd = s->epoll_fd = s->dev_kmsg_fd = -1;
1295 s->compress = true;
1296 s->seal = true;
1297
1298 s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
1299 s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
1300
1301 s->forward_to_syslog = true;
1302
1303 s->max_level_store = LOG_DEBUG;
1304 s->max_level_syslog = LOG_DEBUG;
1305 s->max_level_kmsg = LOG_NOTICE;
1306 s->max_level_console = LOG_INFO;
1307
1308 memset(&s->system_metrics, 0xFF, sizeof(s->system_metrics));
1309 memset(&s->runtime_metrics, 0xFF, sizeof(s->runtime_metrics));
1310
1311 server_parse_config_file(s);
1312 server_parse_proc_cmdline(s);
1313
1314 mkdir_p("/run/systemd/journal", 0755);
1315
1316 s->user_journals = hashmap_new(trivial_hash_func, trivial_compare_func);
1317 if (!s->user_journals)
1318 return log_oom();
1319
1320 s->mmap = mmap_cache_new();
1321 if (!s->mmap)
1322 return log_oom();
1323
1324 s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1325 if (s->epoll_fd < 0) {
1326 log_error("Failed to create epoll object: %m");
1327 return -errno;
1328 }
1329
1330 n = sd_listen_fds(true);
1331 if (n < 0) {
1332 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
1333 return n;
1334 }
1335
1336 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
1337
1338 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
1339
1340 if (s->native_fd >= 0) {
1341 log_error("Too many native sockets passed.");
1342 return -EINVAL;
1343 }
1344
1345 s->native_fd = fd;
1346
1347 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
1348
1349 if (s->stdout_fd >= 0) {
1350 log_error("Too many stdout sockets passed.");
1351 return -EINVAL;
1352 }
1353
1354 s->stdout_fd = fd;
1355
1356 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0) {
1357
1358 if (s->syslog_fd >= 0) {
1359 log_error("Too many /dev/log sockets passed.");
1360 return -EINVAL;
1361 }
1362
1363 s->syslog_fd = fd;
1364
1365 } else {
1366 log_error("Unknown socket passed.");
1367 return -EINVAL;
1368 }
1369 }
1370
1371 r = server_open_syslog_socket(s);
1372 if (r < 0)
1373 return r;
1374
1375 r = server_open_native_socket(s);
1376 if (r < 0)
1377 return r;
1378
1379 r = server_open_stdout_socket(s);
1380 if (r < 0)
1381 return r;
1382
1383 r = server_open_dev_kmsg(s);
1384 if (r < 0)
1385 return r;
1386
1387 r = server_open_kernel_seqnum(s);
1388 if (r < 0)
1389 return r;
1390
1391 r = open_signalfd(s);
1392 if (r < 0)
1393 return r;
1394
1395 s->udev = udev_new();
1396 if (!s->udev)
1397 return -ENOMEM;
1398
1399 s->rate_limit = journal_rate_limit_new(s->rate_limit_interval, s->rate_limit_burst);
1400 if (!s->rate_limit)
1401 return -ENOMEM;
1402
1403 r = system_journal_open(s);
1404 if (r < 0)
1405 return r;
1406
1407 return 0;
1408}
1409
1410void server_maybe_append_tags(Server *s) {
1411#ifdef HAVE_GCRYPT
1412 JournalFile *f;
1413 Iterator i;
1414 usec_t n;
1415
1416 n = now(CLOCK_REALTIME);
1417
1418 if (s->system_journal)
1419 journal_file_maybe_append_tag(s->system_journal, n);
1420
1421 HASHMAP_FOREACH(f, s->user_journals, i)
1422 journal_file_maybe_append_tag(f, n);
1423#endif
1424}
1425
1426void server_done(Server *s) {
1427 JournalFile *f;
1428 assert(s);
1429
1430 while (s->stdout_streams)
1431 stdout_stream_free(s->stdout_streams);
1432
1433 if (s->system_journal)
1434 journal_file_close(s->system_journal);
1435
1436 if (s->runtime_journal)
1437 journal_file_close(s->runtime_journal);
1438
1439 while ((f = hashmap_steal_first(s->user_journals)))
1440 journal_file_close(f);
1441
1442 hashmap_free(s->user_journals);
1443
1444 if (s->epoll_fd >= 0)
1445 close_nointr_nofail(s->epoll_fd);
1446
1447 if (s->signal_fd >= 0)
1448 close_nointr_nofail(s->signal_fd);
1449
1450 if (s->syslog_fd >= 0)
1451 close_nointr_nofail(s->syslog_fd);
1452
1453 if (s->native_fd >= 0)
1454 close_nointr_nofail(s->native_fd);
1455
1456 if (s->stdout_fd >= 0)
1457 close_nointr_nofail(s->stdout_fd);
1458
1459 if (s->dev_kmsg_fd >= 0)
1460 close_nointr_nofail(s->dev_kmsg_fd);
1461
1462 if (s->rate_limit)
1463 journal_rate_limit_free(s->rate_limit);
1464
1465 if (s->kernel_seqnum)
1466 munmap(s->kernel_seqnum, sizeof(uint64_t));
1467
1468 free(s->buffer);
1469 free(s->tty_path);
1470
1471 if (s->mmap)
1472 mmap_cache_unref(s->mmap);
1473
1474 if (s->udev)
1475 udev_unref(s->udev);
1476}
Unnamed repository; edit this file 'description' to name the repository.