src/journal/journald-server.c

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