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