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