src/journal/journald-server.c

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