src/journal/journald-server.c

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