]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/journal/journald-server.c
projects / thirdparty / systemd.git / blob
? search:


c1ec0fad32f4ea23e407b159473c0b85dd1a3c7e
[thirdparty/systemd.git] / src / journal / journald-server.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2011 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <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
37 #include "fileio.h"
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
75 static const char* const storage_table[] = {
76 [STORAGE_AUTO] = "auto",
77 [STORAGE_VOLATILE] = "volatile",
78 [STORAGE_PERSISTENT] = "persistent",
79 [STORAGE_NONE] = "none"
80 };
81
82 DEFINE_STRING_TABLE_LOOKUP(storage, Storage);
83 DEFINE_CONFIG_PARSE_ENUM(config_parse_storage, storage, Storage, "Failed to parse storage setting");
84
85 static const char* const split_mode_table[] = {
86 [SPLIT_NONE] = "none",
87 [SPLIT_UID] = "uid",
88 [SPLIT_LOGIN] = "login"
89 };
90
91 DEFINE_STRING_TABLE_LOOKUP(split_mode, SplitMode);
92 DEFINE_CONFIG_PARSE_ENUM(config_parse_split_mode, split_mode, SplitMode, "Failed to parse split mode setting");
93
94 static uint64_t available_space(Server *s) {
95 char ids[33];
96 char _cleanup_free_ *p = NULL;
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;
102 DIR _cleanup_closedir_ *d = NULL;
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);
130 if (!d)
131 return 0;
132
133 if (fstatvfs(dirfd(d), &ss) < 0)
134 return 0;
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
173 return avail;
174 }
175
176 static 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
195 void 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
242 finish:
243 acl_free(acl);
244 #endif
245 }
246
247 static 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
302 void 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)
336 if (f)
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
347 void 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
394 static char *shortened_cgroup_path(pid_t pid) {
395 int r;
396 char _cleanup_free_ *process_path = NULL, *init_path = NULL;
397 char *path;
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);
406 if (r < 0)
407 return NULL;
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)) {
415 path = strdup(process_path + strlen(init_path));
416 } else {
417 path = process_path;
418 process_path = NULL;
419 }
420
421 return path;
422 }
423
424 bool 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
453 static 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
499 static 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
507 char _cleanup_free_ *pid = NULL, *uid = NULL, *gid = NULL,
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 realuid = 0, owner = 0, journal_uid;
519 bool owner_valid = false;
520
521 assert(s);
522 assert(iovec);
523 assert(n > 0);
524 assert(n + N_IOVEC_META_FIELDS <= m);
525
526 if (ucred) {
527 uint32_t audit;
528 uid_t loginuid;
529
530 realuid = ucred->uid;
531
532 if (asprintf(&pid, "_PID=%lu", (unsigned long) ucred->pid) >= 0)
533 IOVEC_SET_STRING(iovec[n++], pid);
534
535 if (asprintf(&uid, "_UID=%lu", (unsigned long) ucred->uid) >= 0)
536 IOVEC_SET_STRING(iovec[n++], uid);
537
538 if (asprintf(&gid, "_GID=%lu", (unsigned long) ucred->gid) >= 0)
539 IOVEC_SET_STRING(iovec[n++], gid);
540
541 r = get_process_comm(ucred->pid, &t);
542 if (r >= 0) {
543 comm = strappend("_COMM=", t);
544 free(t);
545
546 if (comm)
547 IOVEC_SET_STRING(iovec[n++], comm);
548 }
549
550 r = get_process_exe(ucred->pid, &t);
551 if (r >= 0) {
552 exe = strappend("_EXE=", t);
553 free(t);
554
555 if (exe)
556 IOVEC_SET_STRING(iovec[n++], exe);
557 }
558
559 r = get_process_cmdline(ucred->pid, 0, false, &t);
560 if (r >= 0) {
561 cmdline = strappend("_CMDLINE=", t);
562 free(t);
563
564 if (cmdline)
565 IOVEC_SET_STRING(iovec[n++], cmdline);
566 }
567
568 r = audit_session_from_pid(ucred->pid, &audit);
569 if (r >= 0)
570 if (asprintf(&audit_session, "_AUDIT_SESSION=%lu", (unsigned long) audit) >= 0)
571 IOVEC_SET_STRING(iovec[n++], audit_session);
572
573 r = audit_loginuid_from_pid(ucred->pid, &loginuid);
574 if (r >= 0)
575 if (asprintf(&audit_loginuid, "_AUDIT_LOGINUID=%lu", (unsigned long) loginuid) >= 0)
576 IOVEC_SET_STRING(iovec[n++], audit_loginuid);
577
578 t = shortened_cgroup_path(ucred->pid);
579 if (t) {
580 cgroup = strappend("_SYSTEMD_CGROUP=", t);
581 free(t);
582
583 if (cgroup)
584 IOVEC_SET_STRING(iovec[n++], cgroup);
585 }
586
587 #ifdef HAVE_LOGIND
588 if (sd_pid_get_session(ucred->pid, &t) >= 0) {
589 session = strappend("_SYSTEMD_SESSION=", t);
590 free(t);
591
592 if (session)
593 IOVEC_SET_STRING(iovec[n++], session);
594 }
595
596 if (sd_pid_get_owner_uid(ucred->uid, &owner) >= 0) {
597 owner_valid = true;
598 if (asprintf(&owner_uid, "_SYSTEMD_OWNER_UID=%lu", (unsigned long) owner) >= 0)
599 IOVEC_SET_STRING(iovec[n++], owner_uid);
600 }
601 #endif
602
603 if (cg_pid_get_unit(ucred->pid, &t) >= 0) {
604 unit = strappend("_SYSTEMD_UNIT=", t);
605 free(t);
606 } else if (cg_pid_get_user_unit(ucred->pid, &t) >= 0) {
607 unit = strappend("_SYSTEMD_USER_UNIT=", t);
608 free(t);
609 } else if (unit_id) {
610 if (session)
611 unit = strappend("_SYSTEMD_USER_UNIT=", unit_id);
612 else
613 unit = strappend("_SYSTEMD_UNIT=", unit_id);
614 }
615
616 if (unit)
617 IOVEC_SET_STRING(iovec[n++], unit);
618
619 #ifdef HAVE_SELINUX
620 if (label) {
621 selinux_context = malloc(sizeof("_SELINUX_CONTEXT=") + label_len);
622 if (selinux_context) {
623 memcpy(selinux_context, "_SELINUX_CONTEXT=", sizeof("_SELINUX_CONTEXT=")-1);
624 memcpy(selinux_context+sizeof("_SELINUX_CONTEXT=")-1, label, label_len);
625 selinux_context[sizeof("_SELINUX_CONTEXT=")-1+label_len] = 0;
626 IOVEC_SET_STRING(iovec[n++], selinux_context);
627 }
628 } else {
629 security_context_t con;
630
631 if (getpidcon(ucred->pid, &con) >= 0) {
632 selinux_context = strappend("_SELINUX_CONTEXT=", con);
633 if (selinux_context)
634 IOVEC_SET_STRING(iovec[n++], selinux_context);
635
636 freecon(con);
637 }
638 }
639 #endif
640 }
641
642 if (tv) {
643 if (asprintf(&source_time, "_SOURCE_REALTIME_TIMESTAMP=%llu",
644 (unsigned long long) timeval_load(tv)) >= 0)
645 IOVEC_SET_STRING(iovec[n++], source_time);
646 }
647
648 /* Note that strictly speaking storing the boot id here is
649 * redundant since the entry includes this in-line
650 * anyway. However, we need this indexed, too. */
651 r = sd_id128_get_boot(&id);
652 if (r >= 0)
653 if (asprintf(&boot_id, "_BOOT_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
654 IOVEC_SET_STRING(iovec[n++], boot_id);
655
656 r = sd_id128_get_machine(&id);
657 if (r >= 0)
658 if (asprintf(&machine_id, "_MACHINE_ID=%s", sd_id128_to_string(id, idbuf)) >= 0)
659 IOVEC_SET_STRING(iovec[n++], machine_id);
660
661 t = gethostname_malloc();
662 if (t) {
663 hostname = strappend("_HOSTNAME=", t);
664 free(t);
665 if (hostname)
666 IOVEC_SET_STRING(iovec[n++], hostname);
667 }
668
669 assert(n <= m);
670
671 if (s->split_mode == SPLIT_UID && realuid > 0)
672 /* Split up strictly by any UID */
673 journal_uid = realuid;
674 else if (s->split_mode == SPLIT_LOGIN && realuid > 0 && owner_valid && owner > 0)
675 /* Split up by login UIDs, this avoids creation of
676 * individual journals for system UIDs. We do this
677 * only if the realuid is not root, in order not to
678 * accidentally leak privileged information to the
679 * user that is logged by a privileged process that is
680 * part of an unprivileged session.*/
681 journal_uid = owner;
682 else
683 journal_uid = 0;
684
685 write_to_journal(s, journal_uid, iovec, n);
686 }
687
688 void server_driver_message(Server *s, sd_id128_t message_id, const char *format, ...) {
689 char mid[11 + 32 + 1];
690 char buffer[16 + LINE_MAX + 1];
691 struct iovec iovec[N_IOVEC_META_FIELDS + 4];
692 int n = 0;
693 va_list ap;
694 struct ucred ucred;
695
696 assert(s);
697 assert(format);
698
699 IOVEC_SET_STRING(iovec[n++], "PRIORITY=6");
700 IOVEC_SET_STRING(iovec[n++], "_TRANSPORT=driver");
701
702 memcpy(buffer, "MESSAGE=", 8);
703 va_start(ap, format);
704 vsnprintf(buffer + 8, sizeof(buffer) - 8, format, ap);
705 va_end(ap);
706 char_array_0(buffer);
707 IOVEC_SET_STRING(iovec[n++], buffer);
708
709 if (!sd_id128_equal(message_id, SD_ID128_NULL)) {
710 snprintf(mid, sizeof(mid), MESSAGE_ID(message_id));
711 char_array_0(mid);
712 IOVEC_SET_STRING(iovec[n++], mid);
713 }
714
715 zero(ucred);
716 ucred.pid = getpid();
717 ucred.uid = getuid();
718 ucred.gid = getgid();
719
720 dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL);
721 }
722
723 void server_dispatch_message(
724 Server *s,
725 struct iovec *iovec, unsigned n, unsigned m,
726 struct ucred *ucred,
727 struct timeval *tv,
728 const char *label, size_t label_len,
729 const char *unit_id,
730 int priority) {
731
732 int rl;
733 char _cleanup_free_ *path = NULL;
734 char *c;
735
736 assert(s);
737 assert(iovec || n == 0);
738
739 if (n == 0)
740 return;
741
742 if (LOG_PRI(priority) > s->max_level_store)
743 return;
744
745 if (!ucred)
746 goto finish;
747
748 path = shortened_cgroup_path(ucred->pid);
749 if (!path)
750 goto finish;
751
752 /* example: /user/lennart/3/foobar
753 * /system/dbus.service/foobar
754 *
755 * So let's cut of everything past the third /, since that is
756 * where user directories start */
757
758 c = strchr(path, '/');
759 if (c) {
760 c = strchr(c+1, '/');
761 if (c) {
762 c = strchr(c+1, '/');
763 if (c)
764 *c = 0;
765 }
766 }
767
768 rl = journal_rate_limit_test(s->rate_limit, path,
769 priority & LOG_PRIMASK, available_space(s));
770
771 if (rl == 0)
772 return;
773
774 /* Write a suppression message if we suppressed something */
775 if (rl > 1)
776 server_driver_message(s, SD_MESSAGE_JOURNAL_DROPPED,
777 "Suppressed %u messages from %s", rl - 1, path);
778
779 finish:
780 dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id);
781 }
782
783
784 static int system_journal_open(Server *s) {
785 int r;
786 char *fn;
787 sd_id128_t machine;
788 char ids[33];
789
790 r = sd_id128_get_machine(&machine);
791 if (r < 0)
792 return r;
793
794 sd_id128_to_string(machine, ids);
795
796 if (!s->system_journal &&
797 (s->storage == STORAGE_PERSISTENT || s->storage == STORAGE_AUTO) &&
798 access("/run/systemd/journal/flushed", F_OK) >= 0) {
799
800 /* If in auto mode: first try to create the machine
801 * path, but not the prefix.
802 *
803 * If in persistent mode: create /var/log/journal and
804 * the machine path */
805
806 if (s->storage == STORAGE_PERSISTENT)
807 (void) mkdir("/var/log/journal/", 0755);
808
809 fn = strappend("/var/log/journal/", ids);
810 if (!fn)
811 return -ENOMEM;
812
813 (void) mkdir(fn, 0755);
814 free(fn);
815
816 fn = strjoin("/var/log/journal/", ids, "/system.journal", NULL);
817 if (!fn)
818 return -ENOMEM;
819
820 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, NULL, &s->system_journal);
821 free(fn);
822
823 if (r >= 0) {
824 char fb[FORMAT_BYTES_MAX];
825
826 server_fix_perms(s, s->system_journal, 0);
827 server_driver_message(s, SD_ID128_NULL, "Allowing system journal files to grow to %s.",
828 format_bytes(fb, sizeof(fb), s->system_metrics.max_use));
829
830 } else if (r < 0) {
831
832 if (r != -ENOENT && r != -EROFS)
833 log_warning("Failed to open system journal: %s", strerror(-r));
834
835 r = 0;
836 }
837 }
838
839 if (!s->runtime_journal &&
840 (s->storage != STORAGE_NONE)) {
841
842 fn = strjoin("/run/log/journal/", ids, "/system.journal", NULL);
843 if (!fn)
844 return -ENOMEM;
845
846 if (s->system_journal) {
847
848 /* Try to open the runtime journal, but only
849 * if it already exists, so that we can flush
850 * it into the system journal */
851
852 r = journal_file_open(fn, O_RDWR, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
853 free(fn);
854
855 if (r < 0) {
856 if (r != -ENOENT)
857 log_warning("Failed to open runtime journal: %s", strerror(-r));
858
859 r = 0;
860 }
861
862 } else {
863
864 /* OK, we really need the runtime journal, so create
865 * it if necessary. */
866
867 (void) mkdir_parents(fn, 0755);
868 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
869 free(fn);
870
871 if (r < 0) {
872 log_error("Failed to open runtime journal: %s", strerror(-r));
873 return r;
874 }
875 }
876
877 if (s->runtime_journal) {
878 char fb[FORMAT_BYTES_MAX];
879
880 server_fix_perms(s, s->runtime_journal, 0);
881 server_driver_message(s, SD_ID128_NULL, "Allowing runtime journal files to grow to %s.",
882 format_bytes(fb, sizeof(fb), s->runtime_metrics.max_use));
883 }
884 }
885
886 return r;
887 }
888
889 int server_flush_to_var(Server *s) {
890 int r;
891 sd_id128_t machine;
892 sd_journal *j = NULL;
893
894 assert(s);
895
896 if (s->storage != STORAGE_AUTO &&
897 s->storage != STORAGE_PERSISTENT)
898 return 0;
899
900 if (!s->runtime_journal)
901 return 0;
902
903 system_journal_open(s);
904
905 if (!s->system_journal)
906 return 0;
907
908 log_debug("Flushing to /var...");
909
910 r = sd_id128_get_machine(&machine);
911 if (r < 0) {
912 log_error("Failed to get machine id: %s", strerror(-r));
913 return r;
914 }
915
916 r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
917 if (r < 0) {
918 log_error("Failed to read runtime journal: %s", strerror(-r));
919 return r;
920 }
921
922 sd_journal_set_data_threshold(j, 0);
923
924 SD_JOURNAL_FOREACH(j) {
925 Object *o = NULL;
926 JournalFile *f;
927
928 f = j->current_file;
929 assert(f && f->current_offset > 0);
930
931 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
932 if (r < 0) {
933 log_error("Can't read entry: %s", strerror(-r));
934 goto finish;
935 }
936
937 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
938 if (r >= 0)
939 continue;
940
941 if (!shall_try_append_again(s->system_journal, r)) {
942 log_error("Can't write entry: %s", strerror(-r));
943 goto finish;
944 }
945
946 server_rotate(s);
947 server_vacuum(s);
948
949 log_debug("Retrying write.");
950 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
951 if (r < 0) {
952 log_error("Can't write entry: %s", strerror(-r));
953 goto finish;
954 }
955 }
956
957 finish:
958 journal_file_post_change(s->system_journal);
959
960 journal_file_close(s->runtime_journal);
961 s->runtime_journal = NULL;
962
963 if (r >= 0)
964 rm_rf("/run/log/journal", false, true, false);
965
966 if (j)
967 sd_journal_close(j);
968
969 return r;
970 }
971
972 int process_event(Server *s, struct epoll_event *ev) {
973 assert(s);
974 assert(ev);
975
976 if (ev->data.fd == s->signal_fd) {
977 struct signalfd_siginfo sfsi;
978 ssize_t n;
979
980 if (ev->events != EPOLLIN) {
981 log_error("Got invalid event from epoll.");
982 return -EIO;
983 }
984
985 n = read(s->signal_fd, &sfsi, sizeof(sfsi));
986 if (n != sizeof(sfsi)) {
987
988 if (n >= 0)
989 return -EIO;
990
991 if (errno == EINTR || errno == EAGAIN)
992 return 1;
993
994 return -errno;
995 }
996
997 log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo));
998
999 if (sfsi.ssi_signo == SIGUSR1) {
1000 touch("/run/systemd/journal/flushed");
1001 server_flush_to_var(s);
1002 return 1;
1003 }
1004
1005 if (sfsi.ssi_signo == SIGUSR2) {
1006 server_rotate(s);
1007 server_vacuum(s);
1008 return 1;
1009 }
1010
1011 return 0;
1012
1013 } else if (ev->data.fd == s->dev_kmsg_fd) {
1014 int r;
1015
1016 if (ev->events != EPOLLIN) {
1017 log_error("Got invalid event from epoll.");
1018 return -EIO;
1019 }
1020
1021 r = server_read_dev_kmsg(s);
1022 if (r < 0)
1023 return r;
1024
1025 return 1;
1026
1027 } else if (ev->data.fd == s->native_fd ||
1028 ev->data.fd == s->syslog_fd) {
1029
1030 if (ev->events != EPOLLIN) {
1031 log_error("Got invalid event from epoll.");
1032 return -EIO;
1033 }
1034
1035 for (;;) {
1036 struct msghdr msghdr;
1037 struct iovec iovec;
1038 struct ucred *ucred = NULL;
1039 struct timeval *tv = NULL;
1040 struct cmsghdr *cmsg;
1041 char *label = NULL;
1042 size_t label_len = 0;
1043 union {
1044 struct cmsghdr cmsghdr;
1045
1046 /* We use NAME_MAX space for the
1047 * SELinux label here. The kernel
1048 * currently enforces no limit, but
1049 * according to suggestions from the
1050 * SELinux people this will change and
1051 * it will probably be identical to
1052 * NAME_MAX. For now we use that, but
1053 * this should be updated one day when
1054 * the final limit is known.*/
1055 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1056 CMSG_SPACE(sizeof(struct timeval)) +
1057 CMSG_SPACE(sizeof(int)) + /* fd */
1058 CMSG_SPACE(NAME_MAX)]; /* selinux label */
1059 } control;
1060 ssize_t n;
1061 int v;
1062 int *fds = NULL;
1063 unsigned n_fds = 0;
1064
1065 if (ioctl(ev->data.fd, SIOCINQ, &v) < 0) {
1066 log_error("SIOCINQ failed: %m");
1067 return -errno;
1068 }
1069
1070 if (s->buffer_size < (size_t) v) {
1071 void *b;
1072 size_t l;
1073
1074 l = MAX(LINE_MAX + (size_t) v, s->buffer_size * 2);
1075 b = realloc(s->buffer, l+1);
1076
1077 if (!b) {
1078 log_error("Couldn't increase buffer.");
1079 return -ENOMEM;
1080 }
1081
1082 s->buffer_size = l;
1083 s->buffer = b;
1084 }
1085
1086 zero(iovec);
1087 iovec.iov_base = s->buffer;
1088 iovec.iov_len = s->buffer_size;
1089
1090 zero(control);
1091 zero(msghdr);
1092 msghdr.msg_iov = &iovec;
1093 msghdr.msg_iovlen = 1;
1094 msghdr.msg_control = &control;
1095 msghdr.msg_controllen = sizeof(control);
1096
1097 n = recvmsg(ev->data.fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1098 if (n < 0) {
1099
1100 if (errno == EINTR || errno == EAGAIN)
1101 return 1;
1102
1103 log_error("recvmsg() failed: %m");
1104 return -errno;
1105 }
1106
1107 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1108
1109 if (cmsg->cmsg_level == SOL_SOCKET &&
1110 cmsg->cmsg_type == SCM_CREDENTIALS &&
1111 cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
1112 ucred = (struct ucred*) CMSG_DATA(cmsg);
1113 else if (cmsg->cmsg_level == SOL_SOCKET &&
1114 cmsg->cmsg_type == SCM_SECURITY) {
1115 label = (char*) CMSG_DATA(cmsg);
1116 label_len = cmsg->cmsg_len - CMSG_LEN(0);
1117 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1118 cmsg->cmsg_type == SO_TIMESTAMP &&
1119 cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
1120 tv = (struct timeval*) CMSG_DATA(cmsg);
1121 else if (cmsg->cmsg_level == SOL_SOCKET &&
1122 cmsg->cmsg_type == SCM_RIGHTS) {
1123 fds = (int*) CMSG_DATA(cmsg);
1124 n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1125 }
1126 }
1127
1128 if (ev->data.fd == s->syslog_fd) {
1129 char *e;
1130
1131 if (n > 0 && n_fds == 0) {
1132 e = memchr(s->buffer, '\n', n);
1133 if (e)
1134 *e = 0;
1135 else
1136 s->buffer[n] = 0;
1137
1138 server_process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);
1139 } else if (n_fds > 0)
1140 log_warning("Got file descriptors via syslog socket. Ignoring.");
1141
1142 } else {
1143 if (n > 0 && n_fds == 0)
1144 server_process_native_message(s, s->buffer, n, ucred, tv, label, label_len);
1145 else if (n == 0 && n_fds == 1)
1146 server_process_native_file(s, fds[0], ucred, tv, label, label_len);
1147 else if (n_fds > 0)
1148 log_warning("Got too many file descriptors via native socket. Ignoring.");
1149 }
1150
1151 close_many(fds, n_fds);
1152 }
1153
1154 return 1;
1155
1156 } else if (ev->data.fd == s->stdout_fd) {
1157
1158 if (ev->events != EPOLLIN) {
1159 log_error("Got invalid event from epoll.");
1160 return -EIO;
1161 }
1162
1163 stdout_stream_new(s);
1164 return 1;
1165
1166 } else {
1167 StdoutStream *stream;
1168
1169 if ((ev->events|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
1170 log_error("Got invalid event from epoll.");
1171 return -EIO;
1172 }
1173
1174 /* If it is none of the well-known fds, it must be an
1175 * stdout stream fd. Note that this is a bit ugly here
1176 * (since we rely that none of the well-known fds
1177 * could be interpreted as pointer), but nonetheless
1178 * safe, since the well-known fds would never get an
1179 * fd > 4096, i.e. beyond the first memory page */
1180
1181 stream = ev->data.ptr;
1182
1183 if (stdout_stream_process(stream) <= 0)
1184 stdout_stream_free(stream);
1185
1186 return 1;
1187 }
1188
1189 log_error("Unknown event.");
1190 return 0;
1191 }
1192
1193 static int open_signalfd(Server *s) {
1194 sigset_t mask;
1195 struct epoll_event ev;
1196
1197 assert(s);
1198
1199 assert_se(sigemptyset(&mask) == 0);
1200 sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
1201 assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
1202
1203 s->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
1204 if (s->signal_fd < 0) {
1205 log_error("signalfd(): %m");
1206 return -errno;
1207 }
1208
1209 zero(ev);
1210 ev.events = EPOLLIN;
1211 ev.data.fd = s->signal_fd;
1212
1213 if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->signal_fd, &ev) < 0) {
1214 log_error("epoll_ctl(): %m");
1215 return -errno;
1216 }
1217
1218 return 0;
1219 }
1220
1221 static int server_parse_proc_cmdline(Server *s) {
1222 char _cleanup_free_ *line = NULL;
1223 char *w, *state;
1224 int r;
1225 size_t l;
1226
1227 if (detect_container(NULL) > 0)
1228 return 0;
1229
1230 r = read_one_line_file("/proc/cmdline", &line);
1231 if (r < 0) {
1232 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
1233 return 0;
1234 }
1235
1236 FOREACH_WORD_QUOTED(w, l, line, state) {
1237 char _cleanup_free_ *word;
1238
1239 word = strndup(w, l);
1240 if (!word)
1241 return -ENOMEM;
1242
1243 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
1244 r = parse_boolean(word + 35);
1245 if (r < 0)
1246 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
1247 else
1248 s->forward_to_syslog = r;
1249 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
1250 r = parse_boolean(word + 33);
1251 if (r < 0)
1252 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
1253 else
1254 s->forward_to_kmsg = r;
1255 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
1256 r = parse_boolean(word + 36);
1257 if (r < 0)
1258 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
1259 else
1260 s->forward_to_console = r;
1261 } else if (startswith(word, "systemd.journald"))
1262 log_warning("Invalid systemd.journald parameter. Ignoring.");
1263 }
1264
1265 return 0;
1266 }
1267
1268 static int server_parse_config_file(Server *s) {
1269 static const char *fn = "/etc/systemd/journald.conf";
1270 FILE _cleanup_fclose_ *f = NULL;
1271 int r;
1272
1273 assert(s);
1274
1275 f = fopen(fn, "re");
1276 if (!f) {
1277 if (errno == ENOENT)
1278 return 0;
1279
1280 log_warning("Failed to open configuration file %s: %m", fn);
1281 return -errno;
1282 }
1283
1284 r = config_parse(fn, f, "Journal\0", config_item_perf_lookup,
1285 (void*) journald_gperf_lookup, false, s);
1286 if (r < 0)
1287 log_warning("Failed to parse configuration file: %s", strerror(-r));
1288
1289 return r;
1290 }
1291
1292 int server_init(Server *s) {
1293 int n, r, fd;
1294
1295 assert(s);
1296
1297 zero(*s);
1298 s->syslog_fd = s->native_fd = s->stdout_fd = s->signal_fd = s->epoll_fd = s->dev_kmsg_fd = -1;
1299 s->compress = true;
1300 s->seal = true;
1301
1302 s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
1303 s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
1304
1305 s->forward_to_syslog = true;
1306
1307 s->max_level_store = LOG_DEBUG;
1308 s->max_level_syslog = LOG_DEBUG;
1309 s->max_level_kmsg = LOG_NOTICE;
1310 s->max_level_console = LOG_INFO;
1311
1312 memset(&s->system_metrics, 0xFF, sizeof(s->system_metrics));
1313 memset(&s->runtime_metrics, 0xFF, sizeof(s->runtime_metrics));
1314
1315 server_parse_config_file(s);
1316 server_parse_proc_cmdline(s);
1317 if (!!s->rate_limit_interval ^ !!s->rate_limit_burst) {
1318 log_debug("Setting both rate limit interval and burst from %llu,%u to 0,0",
1319 (long long unsigned) s->rate_limit_interval,
1320 s->rate_limit_burst);
1321 s->rate_limit_interval = s->rate_limit_burst = 0;
1322 }
1323
1324 mkdir_p("/run/systemd/journal", 0755);
1325
1326 s->user_journals = hashmap_new(trivial_hash_func, trivial_compare_func);
1327 if (!s->user_journals)
1328 return log_oom();
1329
1330 s->mmap = mmap_cache_new();
1331 if (!s->mmap)
1332 return log_oom();
1333
1334 s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1335 if (s->epoll_fd < 0) {
1336 log_error("Failed to create epoll object: %m");
1337 return -errno;
1338 }
1339
1340 n = sd_listen_fds(true);
1341 if (n < 0) {
1342 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
1343 return n;
1344 }
1345
1346 for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
1347
1348 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
1349
1350 if (s->native_fd >= 0) {
1351 log_error("Too many native sockets passed.");
1352 return -EINVAL;
1353 }
1354
1355 s->native_fd = fd;
1356
1357 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
1358
1359 if (s->stdout_fd >= 0) {
1360 log_error("Too many stdout sockets passed.");
1361 return -EINVAL;
1362 }
1363
1364 s->stdout_fd = fd;
1365
1366 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0) {
1367
1368 if (s->syslog_fd >= 0) {
1369 log_error("Too many /dev/log sockets passed.");
1370 return -EINVAL;
1371 }
1372
1373 s->syslog_fd = fd;
1374
1375 } else {
1376 log_error("Unknown socket passed.");
1377 return -EINVAL;
1378 }
1379 }
1380
1381 r = server_open_syslog_socket(s);
1382 if (r < 0)
1383 return r;
1384
1385 r = server_open_native_socket(s);
1386 if (r < 0)
1387 return r;
1388
1389 r = server_open_stdout_socket(s);
1390 if (r < 0)
1391 return r;
1392
1393 r = server_open_dev_kmsg(s);
1394 if (r < 0)
1395 return r;
1396
1397 r = server_open_kernel_seqnum(s);
1398 if (r < 0)
1399 return r;
1400
1401 r = open_signalfd(s);
1402 if (r < 0)
1403 return r;
1404
1405 s->udev = udev_new();
1406 if (!s->udev)
1407 return -ENOMEM;
1408
1409 s->rate_limit = journal_rate_limit_new(s->rate_limit_interval,
1410 s->rate_limit_burst);
1411 if (!s->rate_limit)
1412 return -ENOMEM;
1413
1414 r = system_journal_open(s);
1415 if (r < 0)
1416 return r;
1417
1418 return 0;
1419 }
1420
1421 void server_maybe_append_tags(Server *s) {
1422 #ifdef HAVE_GCRYPT
1423 JournalFile *f;
1424 Iterator i;
1425 usec_t n;
1426
1427 n = now(CLOCK_REALTIME);
1428
1429 if (s->system_journal)
1430 journal_file_maybe_append_tag(s->system_journal, n);
1431
1432 HASHMAP_FOREACH(f, s->user_journals, i)
1433 journal_file_maybe_append_tag(f, n);
1434 #endif
1435 }
1436
1437 void server_done(Server *s) {
1438 JournalFile *f;
1439 assert(s);
1440
1441 while (s->stdout_streams)
1442 stdout_stream_free(s->stdout_streams);
1443
1444 if (s->system_journal)
1445 journal_file_close(s->system_journal);
1446
1447 if (s->runtime_journal)
1448 journal_file_close(s->runtime_journal);
1449
1450 while ((f = hashmap_steal_first(s->user_journals)))
1451 journal_file_close(f);
1452
1453 hashmap_free(s->user_journals);
1454
1455 if (s->epoll_fd >= 0)
1456 close_nointr_nofail(s->epoll_fd);
1457
1458 if (s->signal_fd >= 0)
1459 close_nointr_nofail(s->signal_fd);
1460
1461 if (s->syslog_fd >= 0)
1462 close_nointr_nofail(s->syslog_fd);
1463
1464 if (s->native_fd >= 0)
1465 close_nointr_nofail(s->native_fd);
1466
1467 if (s->stdout_fd >= 0)
1468 close_nointr_nofail(s->stdout_fd);
1469
1470 if (s->dev_kmsg_fd >= 0)
1471 close_nointr_nofail(s->dev_kmsg_fd);
1472
1473 if (s->rate_limit)
1474 journal_rate_limit_free(s->rate_limit);
1475
1476 if (s->kernel_seqnum)
1477 munmap(s->kernel_seqnum, sizeof(uint64_t));
1478
1479 free(s->buffer);
1480 free(s->tty_path);
1481
1482 if (s->mmap)
1483 mmap_cache_unref(s->mmap);
1484
1485 if (s->udev)
1486 udev_unref(s->udev);
1487 }
Unnamed repository; edit this file 'description' to name the repository.