src/journal/journald-server.c

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