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