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