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