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         zero(ucred);
 744         ucred.pid = getpid();
 745         ucred.uid = getuid();
 746         ucred.gid = getgid();
 747
 748         dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL);
 749 }
 750
 751 void server_dispatch_message(
 752                 Server *s,
 753                 struct iovec *iovec, unsigned n, unsigned m,
 754                 struct ucred *ucred,
 755                 struct timeval *tv,
 756                 const char *label, size_t label_len,
 757                 const char *unit_id,
 758                 int priority) {
 759
 760         int rl;
 761         char _cleanup_free_ *path = NULL;
 762         char *c;
 763
 764         assert(s);
 765         assert(iovec || n == 0);
 766
 767         if (n == 0)
 768                 return;
 769
 770         if (LOG_PRI(priority) > s->max_level_store)
 771                 return;
 772
 773         if (!ucred)
 774                 goto finish;
 775
 776         path = shortened_cgroup_path(ucred->pid);
 777         if (!path)
 778                 goto finish;
 779
 780         /* example: /user/lennart/3/foobar
 781          *          /system/dbus.service/foobar
 782          *
 783          * So let's cut of everything past the third /, since that is
 784          * where user directories start */
 785
 786         c = strchr(path, '/');
 787         if (c) {
 788                 c = strchr(c+1, '/');
 789                 if (c) {
 790                         c = strchr(c+1, '/');
 791                         if (c)
 792                                 *c = 0;
 793                 }
 794         }
 795
 796         rl = journal_rate_limit_test(s->rate_limit, path,
 797                                      priority & LOG_PRIMASK, available_space(s));
 798
 799         if (rl == 0)
 800                 return;
 801
 802         /* Write a suppression message if we suppressed something */
 803         if (rl > 1)
 804                 server_driver_message(s, SD_MESSAGE_JOURNAL_DROPPED,
 805                                       "Suppressed %u messages from %s", rl - 1, path);
 806
 807 finish:
 808         dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id);
 809 }
 810
 811
 812 static int system_journal_open(Server *s) {
 813         int r;
 814         char *fn;
 815         sd_id128_t machine;
 816         char ids[33];
 817
 818         r = sd_id128_get_machine(&machine);
 819         if (r < 0)
 820                 return r;
 821
 822         sd_id128_to_string(machine, ids);
 823
 824         if (!s->system_journal &&
 825             (s->storage == STORAGE_PERSISTENT || s->storage == STORAGE_AUTO) &&
 826             access("/run/systemd/journal/flushed", F_OK) >= 0) {
 827
 828                 /* If in auto mode: first try to create the machine
 829                  * path, but not the prefix.
 830                  *
 831                  * If in persistent mode: create /var/log/journal and
 832                  * the machine path */
 833
 834                 if (s->storage == STORAGE_PERSISTENT)
 835                         (void) mkdir("/var/log/journal/", 0755);
 836
 837                 fn = strappend("/var/log/journal/", ids);
 838                 if (!fn)
 839                         return -ENOMEM;
 840
 841                 (void) mkdir(fn, 0755);
 842                 free(fn);
 843
 844                 fn = strjoin("/var/log/journal/", ids, "/system.journal", NULL);
 845                 if (!fn)
 846                         return -ENOMEM;
 847
 848                 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, NULL, &s->system_journal);
 849                 free(fn);
 850
 851                 if (r >= 0) {
 852                         char fb[FORMAT_BYTES_MAX];
 853
 854                         server_fix_perms(s, s->system_journal, 0);
 855                         server_driver_message(s, SD_ID128_NULL, "Allowing system journal files to grow to %s.",
 856                                               format_bytes(fb, sizeof(fb), s->system_metrics.max_use));
 857
 858                 } else if (r < 0) {
 859
 860                         if (r != -ENOENT && r != -EROFS)
 861                                 log_warning("Failed to open system journal: %s", strerror(-r));
 862
 863                         r = 0;
 864                 }
 865         }
 866
 867         if (!s->runtime_journal &&
 868             (s->storage != STORAGE_NONE)) {
 869
 870                 fn = strjoin("/run/log/journal/", ids, "/system.journal", NULL);
 871                 if (!fn)
 872                         return -ENOMEM;
 873
 874                 if (s->system_journal) {
 875
 876                         /* Try to open the runtime journal, but only
 877                          * if it already exists, so that we can flush
 878                          * it into the system journal */
 879
 880                         r = journal_file_open(fn, O_RDWR, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
 881                         free(fn);
 882
 883                         if (r < 0) {
 884                                 if (r != -ENOENT)
 885                                         log_warning("Failed to open runtime journal: %s", strerror(-r));
 886
 887                                 r = 0;
 888                         }
 889
 890                 } else {
 891
 892                         /* OK, we really need the runtime journal, so create
 893                          * it if necessary. */
 894
 895                         (void) mkdir_parents(fn, 0755);
 896                         r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
 897                         free(fn);
 898
 899                         if (r < 0) {
 900                                 log_error("Failed to open runtime journal: %s", strerror(-r));
 901                                 return r;
 902                         }
 903                 }
 904
 905                 if (s->runtime_journal) {
 906                         char fb[FORMAT_BYTES_MAX];
 907
 908                         server_fix_perms(s, s->runtime_journal, 0);
 909                         server_driver_message(s, SD_ID128_NULL, "Allowing runtime journal files to grow to %s.",
 910                                               format_bytes(fb, sizeof(fb), s->runtime_metrics.max_use));
 911                 }
 912         }
 913
 914         return r;
 915 }
 916
 917 int server_flush_to_var(Server *s) {
 918         int r;
 919         sd_id128_t machine;
 920         sd_journal *j = NULL;
 921
 922         assert(s);
 923
 924         if (s->storage != STORAGE_AUTO &&
 925             s->storage != STORAGE_PERSISTENT)
 926                 return 0;
 927
 928         if (!s->runtime_journal)
 929                 return 0;
 930
 931         system_journal_open(s);
 932
 933         if (!s->system_journal)
 934                 return 0;
 935
 936         log_debug("Flushing to /var...");
 937
 938         r = sd_id128_get_machine(&machine);
 939         if (r < 0) {
 940                 log_error("Failed to get machine id: %s", strerror(-r));
 941                 return r;
 942         }
 943
 944         r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
 945         if (r < 0) {
 946                 log_error("Failed to read runtime journal: %s", strerror(-r));
 947                 return r;
 948         }
 949
 950         sd_journal_set_data_threshold(j, 0);
 951
 952         SD_JOURNAL_FOREACH(j) {
 953                 Object *o = NULL;
 954                 JournalFile *f;
 955
 956                 f = j->current_file;
 957                 assert(f && f->current_offset > 0);
 958
 959                 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
 960                 if (r < 0) {
 961                         log_error("Can't read entry: %s", strerror(-r));
 962                         goto finish;
 963                 }
 964
 965                 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
 966                 if (r >= 0)
 967                         continue;
 968
 969                 if (!shall_try_append_again(s->system_journal, r)) {
 970                         log_error("Can't write entry: %s", strerror(-r));
 971                         goto finish;
 972                 }
 973
 974                 server_rotate(s);
 975                 server_vacuum(s);
 976
 977                 log_debug("Retrying write.");
 978                 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
 979                 if (r < 0) {
 980                         log_error("Can't write entry: %s", strerror(-r));
 981                         goto finish;
 982                 }
 983         }
 984
 985 finish:
 986         journal_file_post_change(s->system_journal);
 987
 988         journal_file_close(s->runtime_journal);
 989         s->runtime_journal = NULL;
 990
 991         if (r >= 0)
 992                 rm_rf("/run/log/journal", false, true, false);
 993
 994         sd_journal_close(j);
 995
 996         return r;
 997 }
 998
 999 int process_event(Server *s, struct epoll_event *ev) {
1000         assert(s);
1001         assert(ev);
1002
1003         if (ev->data.fd == s->signal_fd) {
1004                 struct signalfd_siginfo sfsi;
1005                 ssize_t n;
1006
1007                 if (ev->events != EPOLLIN) {
1008                         log_error("Got invalid event from epoll.");
1009                         return -EIO;
1010                 }
1011
1012                 n = read(s->signal_fd, &sfsi, sizeof(sfsi));
1013                 if (n != sizeof(sfsi)) {
1014
1015                         if (n >= 0)
1016                                 return -EIO;
1017
1018                         if (errno == EINTR || errno == EAGAIN)
1019                                 return 1;
1020
1021                         return -errno;
1022                 }
1023
1024                 if (sfsi.ssi_signo == SIGUSR1) {
1025                         touch("/run/systemd/journal/flushed");
1026                         server_flush_to_var(s);
1027                         server_sync(s);
1028                         return 1;
1029                 }
1030
1031                 if (sfsi.ssi_signo == SIGUSR2) {
1032                         server_rotate(s);
1033                         server_vacuum(s);
1034                         return 1;
1035                 }
1036
1037                 log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo));
1038
1039                 return 0;
1040
1041         } else if (ev->data.fd == s->sync_timer_fd) {
1042                 int r;
1043                 uint64_t t;
1044
1045                 log_debug("Got sync request from epoll.");
1046
1047                 r = read(ev->data.fd, (void *)&t, sizeof(t));
1048                 if (r < 0)
1049                         return 0;
1050
1051                 server_sync(s);
1052                 return 1;
1053
1054         } else if (ev->data.fd == s->dev_kmsg_fd) {
1055                 int r;
1056
1057                 if (ev->events != EPOLLIN) {
1058                         log_error("Got invalid event from epoll.");
1059                         return -EIO;
1060                 }
1061
1062                 r = server_read_dev_kmsg(s);
1063                 if (r < 0)
1064                         return r;
1065
1066                 return 1;
1067
1068         } else if (ev->data.fd == s->native_fd ||
1069                    ev->data.fd == s->syslog_fd) {
1070
1071                 if (ev->events != EPOLLIN) {
1072                         log_error("Got invalid event from epoll.");
1073                         return -EIO;
1074                 }
1075
1076                 for (;;) {
1077                         struct msghdr msghdr;
1078                         struct iovec iovec;
1079                         struct ucred *ucred = NULL;
1080                         struct timeval *tv = NULL;
1081                         struct cmsghdr *cmsg;
1082                         char *label = NULL;
1083                         size_t label_len = 0;
1084                         union {
1085                                 struct cmsghdr cmsghdr;
1086
1087                                 /* We use NAME_MAX space for the
1088                                  * SELinux label here. The kernel
1089                                  * currently enforces no limit, but
1090                                  * according to suggestions from the
1091                                  * SELinux people this will change and
1092                                  * it will probably be identical to
1093                                  * NAME_MAX. For now we use that, but
1094                                  * this should be updated one day when
1095                                  * the final limit is known.*/
1096                                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1097                                             CMSG_SPACE(sizeof(struct timeval)) +
1098                                             CMSG_SPACE(sizeof(int)) + /* fd */
1099                                             CMSG_SPACE(NAME_MAX)]; /* selinux label */
1100                         } control;
1101                         ssize_t n;
1102                         int v;
1103                         int *fds = NULL;
1104                         unsigned n_fds = 0;
1105
1106                         if (ioctl(ev->data.fd, SIOCINQ, &v) < 0) {
1107                                 log_error("SIOCINQ failed: %m");
1108                                 return -errno;
1109                         }
1110
1111                         if (s->buffer_size < (size_t) v) {
1112                                 void *b;
1113                                 size_t l;
1114
1115                                 l = MAX(LINE_MAX + (size_t) v, s->buffer_size * 2);
1116                                 b = realloc(s->buffer, l+1);
1117
1118                                 if (!b) {
1119                                         log_error("Couldn't increase buffer.");
1120                                         return -ENOMEM;
1121                                 }
1122
1123                                 s->buffer_size = l;
1124                                 s->buffer = b;
1125                         }
1126
1127                         zero(iovec);
1128                         iovec.iov_base = s->buffer;
1129                         iovec.iov_len = s->buffer_size;
1130
1131                         zero(control);
1132                         zero(msghdr);
1133                         msghdr.msg_iov = &iovec;
1134                         msghdr.msg_iovlen = 1;
1135                         msghdr.msg_control = &control;
1136                         msghdr.msg_controllen = sizeof(control);
1137
1138                         n = recvmsg(ev->data.fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1139                         if (n < 0) {
1140
1141                                 if (errno == EINTR || errno == EAGAIN)
1142                                         return 1;
1143
1144                                 log_error("recvmsg() failed: %m");
1145                                 return -errno;
1146                         }
1147
1148                         for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1149
1150                                 if (cmsg->cmsg_level == SOL_SOCKET &&
1151                                     cmsg->cmsg_type == SCM_CREDENTIALS &&
1152                                     cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
1153                                         ucred = (struct ucred*) CMSG_DATA(cmsg);
1154                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
1155                                          cmsg->cmsg_type == SCM_SECURITY) {
1156                                         label = (char*) CMSG_DATA(cmsg);
1157                                         label_len = cmsg->cmsg_len - CMSG_LEN(0);
1158                                 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1159                                          cmsg->cmsg_type == SO_TIMESTAMP &&
1160                                          cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
1161                                         tv = (struct timeval*) CMSG_DATA(cmsg);
1162                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
1163                                          cmsg->cmsg_type == SCM_RIGHTS) {
1164                                         fds = (int*) CMSG_DATA(cmsg);
1165                                         n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1166                                 }
1167                         }
1168
1169                         if (ev->data.fd == s->syslog_fd) {
1170                                 char *e;
1171
1172                                 if (n > 0 && n_fds == 0) {
1173                                         e = memchr(s->buffer, '\n', n);
1174                                         if (e)
1175                                                 *e = 0;
1176                                         else
1177                                                 s->buffer[n] = 0;
1178
1179                                         server_process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);
1180                                 } else if (n_fds > 0)
1181                                         log_warning("Got file descriptors via syslog socket. Ignoring.");
1182
1183                         } else {
1184                                 if (n > 0 && n_fds == 0)
1185                                         server_process_native_message(s, s->buffer, n, ucred, tv, label, label_len);
1186                                 else if (n == 0 && n_fds == 1)
1187                                         server_process_native_file(s, fds[0], ucred, tv, label, label_len);
1188                                 else if (n_fds > 0)
1189                                         log_warning("Got too many file descriptors via native socket. Ignoring.");
1190                         }
1191
1192                         close_many(fds, n_fds);
1193                 }
1194
1195                 return 1;
1196
1197         } else if (ev->data.fd == s->stdout_fd) {
1198
1199                 if (ev->events != EPOLLIN) {
1200                         log_error("Got invalid event from epoll.");
1201                         return -EIO;
1202                 }
1203
1204                 stdout_stream_new(s);
1205                 return 1;
1206
1207         } else {
1208                 StdoutStream *stream;
1209
1210                 if ((ev->events|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
1211                         log_error("Got invalid event from epoll.");
1212                         return -EIO;
1213                 }
1214
1215                 /* If it is none of the well-known fds, it must be an
1216                  * stdout stream fd. Note that this is a bit ugly here
1217                  * (since we rely that none of the well-known fds
1218                  * could be interpreted as pointer), but nonetheless
1219                  * safe, since the well-known fds would never get an
1220                  * fd > 4096, i.e. beyond the first memory page */
1221
1222                 stream = ev->data.ptr;
1223
1224                 if (stdout_stream_process(stream) <= 0)
1225                         stdout_stream_free(stream);
1226
1227                 return 1;
1228         }
1229
1230         log_error("Unknown event.");
1231         return 0;
1232 }
1233
1234 static int open_signalfd(Server *s) {
1235         sigset_t mask;
1236         struct epoll_event ev;
1237
1238         assert(s);
1239
1240         assert_se(sigemptyset(&mask) == 0);
1241         sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
1242         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
1243
1244         s->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
1245         if (s->signal_fd < 0) {
1246                 log_error("signalfd(): %m");
1247                 return -errno;
1248         }
1249
1250         zero(ev);
1251         ev.events = EPOLLIN;
1252         ev.data.fd = s->signal_fd;
1253
1254         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->signal_fd, &ev) < 0) {
1255                 log_error("epoll_ctl(): %m");
1256                 return -errno;
1257         }
1258
1259         return 0;
1260 }
1261
1262 static int server_parse_proc_cmdline(Server *s) {
1263         char _cleanup_free_ *line = NULL;
1264         char *w, *state;
1265         int r;
1266         size_t l;
1267
1268         if (detect_container(NULL) > 0)
1269                 return 0;
1270
1271         r = read_one_line_file("/proc/cmdline", &line);
1272         if (r < 0) {
1273                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
1274                 return 0;
1275         }
1276
1277         FOREACH_WORD_QUOTED(w, l, line, state) {
1278                 char _cleanup_free_ *word;
1279
1280                 word = strndup(w, l);
1281                 if (!word)
1282                         return -ENOMEM;
1283
1284                 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
1285                         r = parse_boolean(word + 35);
1286                         if (r < 0)
1287                                 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
1288                         else
1289                                 s->forward_to_syslog = r;
1290                 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
1291                         r = parse_boolean(word + 33);
1292                         if (r < 0)
1293                                 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
1294                         else
1295                                 s->forward_to_kmsg = r;
1296                 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
1297                         r = parse_boolean(word + 36);
1298                         if (r < 0)
1299                                 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
1300                         else
1301                                 s->forward_to_console = r;
1302                 } else if (startswith(word, "systemd.journald"))
1303                         log_warning("Invalid systemd.journald parameter. Ignoring.");
1304         }
1305
1306         return 0;
1307 }
1308
1309 static int server_parse_config_file(Server *s) {
1310         static const char *fn = "/etc/systemd/journald.conf";
1311         FILE _cleanup_fclose_ *f = NULL;
1312         int r;
1313
1314         assert(s);
1315
1316         f = fopen(fn, "re");
1317         if (!f) {
1318                 if (errno == ENOENT)
1319                         return 0;
1320
1321                 log_warning("Failed to open configuration file %s: %m", fn);
1322                 return -errno;
1323         }
1324
1325         r = config_parse(fn, f, "Journal\0", config_item_perf_lookup,
1326                          (void*) journald_gperf_lookup, false, s);
1327         if (r < 0)
1328                 log_warning("Failed to parse configuration file: %s", strerror(-r));
1329
1330         return r;
1331 }
1332
1333 static int server_open_sync_timer(Server *s) {
1334         int r;
1335         struct epoll_event ev;
1336
1337         assert(s);
1338
1339         s->sync_timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
1340         if (s->sync_timer_fd < 0)
1341                 return -errno;
1342
1343         zero(ev);
1344         ev.events = EPOLLIN;
1345         ev.data.fd = s->sync_timer_fd;
1346
1347         r = epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->sync_timer_fd, &ev);
1348         if (r < 0) {
1349                 log_error("Failed to add idle timer fd to epoll object: %m");
1350                 return -errno;
1351         }
1352
1353         return 0;
1354 }
1355
1356 int server_schedule_sync(Server *s) {
1357         int r;
1358
1359         struct itimerspec sync_timer_enable;
1360
1361         assert(s);
1362
1363         if (s->sync_scheduled)
1364                 return 0;
1365
1366         if (s->sync_interval_usec) {
1367                 zero(sync_timer_enable);
1368                 sync_timer_enable.it_value.tv_sec = s->sync_interval_usec / USEC_PER_SEC;
1369                 sync_timer_enable.it_value.tv_nsec = s->sync_interval_usec % MSEC_PER_SEC;
1370
1371                 r = timerfd_settime(s->sync_timer_fd, 0, &sync_timer_enable, NULL);
1372                 if (r < 0)
1373                         return -errno;
1374         }
1375
1376         s->sync_scheduled = true;
1377
1378         return 0;
1379 }
1380
1381 int server_init(Server *s) {
1382         int n, r, fd;
1383
1384         assert(s);
1385
1386         zero(*s);
1387         s->sync_timer_fd = s->syslog_fd = s->native_fd = s->stdout_fd =
1388             s->signal_fd = s->epoll_fd = s->dev_kmsg_fd = -1;
1389         s->compress = true;
1390         s->seal = true;
1391
1392         s->sync_interval_usec = DEFAULT_SYNC_INTERVAL_USEC;
1393         s->sync_scheduled = false;
1394
1395         s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
1396         s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
1397
1398         s->forward_to_syslog = true;
1399
1400         s->max_level_store = LOG_DEBUG;
1401         s->max_level_syslog = LOG_DEBUG;
1402         s->max_level_kmsg = LOG_NOTICE;
1403         s->max_level_console = LOG_INFO;
1404
1405         memset(&s->system_metrics, 0xFF, sizeof(s->system_metrics));
1406         memset(&s->runtime_metrics, 0xFF, sizeof(s->runtime_metrics));
1407
1408         server_parse_config_file(s);
1409         server_parse_proc_cmdline(s);
1410         if (!!s->rate_limit_interval ^ !!s->rate_limit_burst) {
1411                 log_debug("Setting both rate limit interval and burst from %llu,%u to 0,0",
1412                           (long long unsigned) s->rate_limit_interval,
1413                           s->rate_limit_burst);
1414                 s->rate_limit_interval = s->rate_limit_burst = 0;
1415         }
1416
1417         mkdir_p("/run/systemd/journal", 0755);
1418
1419         s->user_journals = hashmap_new(trivial_hash_func, trivial_compare_func);
1420         if (!s->user_journals)
1421                 return log_oom();
1422
1423         s->mmap = mmap_cache_new();
1424         if (!s->mmap)
1425                 return log_oom();
1426
1427         s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1428         if (s->epoll_fd < 0) {
1429                 log_error("Failed to create epoll object: %m");
1430                 return -errno;
1431         }
1432
1433         n = sd_listen_fds(true);
1434         if (n < 0) {
1435                 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
1436                 return n;
1437         }
1438
1439         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
1440
1441                 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
1442
1443                         if (s->native_fd >= 0) {
1444                                 log_error("Too many native sockets passed.");
1445                                 return -EINVAL;
1446                         }
1447
1448                         s->native_fd = fd;
1449
1450                 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
1451
1452                         if (s->stdout_fd >= 0) {
1453                                 log_error("Too many stdout sockets passed.");
1454                                 return -EINVAL;
1455                         }
1456
1457                         s->stdout_fd = fd;
1458
1459                 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0) {
1460
1461                         if (s->syslog_fd >= 0) {
1462                                 log_error("Too many /dev/log sockets passed.");
1463                                 return -EINVAL;
1464                         }
1465
1466                         s->syslog_fd = fd;
1467
1468                 } else {
1469                         log_error("Unknown socket passed.");
1470                         return -EINVAL;
1471                 }
1472         }
1473
1474         r = server_open_syslog_socket(s);
1475         if (r < 0)
1476                 return r;
1477
1478         r = server_open_native_socket(s);
1479         if (r < 0)
1480                 return r;
1481
1482         r = server_open_stdout_socket(s);
1483         if (r < 0)
1484                 return r;
1485
1486         r = server_open_dev_kmsg(s);
1487         if (r < 0)
1488                 return r;
1489
1490         r = server_open_kernel_seqnum(s);
1491         if (r < 0)
1492                 return r;
1493
1494         r = server_open_sync_timer(s);
1495         if (r < 0)
1496                 return r;
1497
1498         r = open_signalfd(s);
1499         if (r < 0)
1500                 return r;
1501
1502         s->udev = udev_new();
1503         if (!s->udev)
1504                 return -ENOMEM;
1505
1506         s->rate_limit = journal_rate_limit_new(s->rate_limit_interval,
1507                                                s->rate_limit_burst);
1508         if (!s->rate_limit)
1509                 return -ENOMEM;
1510
1511         r = system_journal_open(s);
1512         if (r < 0)
1513                 return r;
1514
1515         return 0;
1516 }
1517
1518 void server_maybe_append_tags(Server *s) {
1519 #ifdef HAVE_GCRYPT
1520         JournalFile *f;
1521         Iterator i;
1522         usec_t n;
1523
1524         n = now(CLOCK_REALTIME);
1525
1526         if (s->system_journal)
1527                 journal_file_maybe_append_tag(s->system_journal, n);
1528
1529         HASHMAP_FOREACH(f, s->user_journals, i)
1530                 journal_file_maybe_append_tag(f, n);
1531 #endif
1532 }
1533
1534 void server_done(Server *s) {
1535         JournalFile *f;
1536         assert(s);
1537
1538         while (s->stdout_streams)
1539                 stdout_stream_free(s->stdout_streams);
1540
1541         if (s->system_journal)
1542                 journal_file_close(s->system_journal);
1543
1544         if (s->runtime_journal)
1545                 journal_file_close(s->runtime_journal);
1546
1547         while ((f = hashmap_steal_first(s->user_journals)))
1548                 journal_file_close(f);
1549
1550         hashmap_free(s->user_journals);
1551
1552         if (s->epoll_fd >= 0)
1553                 close_nointr_nofail(s->epoll_fd);
1554
1555         if (s->signal_fd >= 0)
1556                 close_nointr_nofail(s->signal_fd);
1557
1558         if (s->syslog_fd >= 0)
1559                 close_nointr_nofail(s->syslog_fd);
1560
1561         if (s->native_fd >= 0)
1562                 close_nointr_nofail(s->native_fd);
1563
1564         if (s->stdout_fd >= 0)
1565                 close_nointr_nofail(s->stdout_fd);
1566
1567         if (s->dev_kmsg_fd >= 0)
1568                 close_nointr_nofail(s->dev_kmsg_fd);
1569
1570         if (s->sync_timer_fd >= 0)
1571                 close_nointr_nofail(s->sync_timer_fd);
1572
1573         if (s->rate_limit)
1574                 journal_rate_limit_free(s->rate_limit);
1575
1576         if (s->kernel_seqnum)
1577                 munmap(s->kernel_seqnum, sizeof(uint64_t));
1578
1579         free(s->buffer);
1580         free(s->tty_path);
1581
1582         if (s->mmap)
1583                 mmap_cache_unref(s->mmap);
1584
1585         if (s->udev)
1586                 udev_unref(s->udev);
1587 }