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
 921         if (!s->runtime_journal &&
 922             (s->storage != STORAGE_NONE)) {
 923
 924                 fn = strjoin("/run/log/journal/", ids, "/system.journal", NULL);
 925                 if (!fn)
 926                         return -ENOMEM;
 927
 928                 if (s->system_journal) {
 929
 930                         /* Try to open the runtime journal, but only
 931                          * if it already exists, so that we can flush
 932                          * it into the system journal */
 933
 934                         r = journal_file_open(fn, O_RDWR, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
 935                         free(fn);
 936
 937                         if (r < 0) {
 938                                 if (r != -ENOENT)
 939                                         log_warning("Failed to open runtime journal: %s", strerror(-r));
 940
 941                                 r = 0;
 942                         }
 943
 944                 } else {
 945
 946                         /* OK, we really need the runtime journal, so create
 947                          * it if necessary. */
 948
 949                         (void) mkdir_parents(fn, 0755);
 950                         r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
 951                         free(fn);
 952
 953                         if (r < 0) {
 954                                 log_error("Failed to open runtime journal: %s", strerror(-r));
 955                                 return r;
 956                         }
 957                 }
 958
 959                 if (s->runtime_journal)
 960                         server_fix_perms(s, s->runtime_journal, 0);
 961         }
 962
 963         available_space(s, true);
 964
 965         return r;
 966 }
 967
 968 int server_flush_to_var(Server *s) {
 969         int r;
 970         sd_id128_t machine;
 971         sd_journal *j = NULL;
 972
 973         assert(s);
 974
 975         if (s->storage != STORAGE_AUTO &&
 976             s->storage != STORAGE_PERSISTENT)
 977                 return 0;
 978
 979         if (!s->runtime_journal)
 980                 return 0;
 981
 982         system_journal_open(s);
 983
 984         if (!s->system_journal)
 985                 return 0;
 986
 987         log_debug("Flushing to /var...");
 988
 989         r = sd_id128_get_machine(&machine);
 990         if (r < 0) {
 991                 log_error("Failed to get machine id: %s", strerror(-r));
 992                 return r;
 993         }
 994
 995         r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
 996         if (r < 0) {
 997                 log_error("Failed to read runtime journal: %s", strerror(-r));
 998                 return r;
 999         }
1000
1001         sd_journal_set_data_threshold(j, 0);
1002
1003         SD_JOURNAL_FOREACH(j) {
1004                 Object *o = NULL;
1005                 JournalFile *f;
1006
1007                 f = j->current_file;
1008                 assert(f && f->current_offset > 0);
1009
1010                 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
1011                 if (r < 0) {
1012                         log_error("Can't read entry: %s", strerror(-r));
1013                         goto finish;
1014                 }
1015
1016                 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
1017                 if (r >= 0)
1018                         continue;
1019
1020                 if (!shall_try_append_again(s->system_journal, r)) {
1021                         log_error("Can't write entry: %s", strerror(-r));
1022                         goto finish;
1023                 }
1024
1025                 server_rotate(s);
1026                 server_vacuum(s);
1027
1028                 if (!s->system_journal) {
1029                         log_notice("Didn't flush runtime journal since rotation of system journal wasn't successful.");
1030                         r = -EIO;
1031                         goto finish;
1032                 }
1033
1034                 log_debug("Retrying write.");
1035                 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
1036                 if (r < 0) {
1037                         log_error("Can't write entry: %s", strerror(-r));
1038                         goto finish;
1039                 }
1040         }
1041
1042 finish:
1043         journal_file_post_change(s->system_journal);
1044
1045         journal_file_close(s->runtime_journal);
1046         s->runtime_journal = NULL;
1047
1048         if (r >= 0)
1049                 rm_rf("/run/log/journal", false, true, false);
1050
1051         sd_journal_close(j);
1052
1053         return r;
1054 }
1055
1056 int process_event(Server *s, struct epoll_event *ev) {
1057         assert(s);
1058         assert(ev);
1059
1060         if (ev->data.fd == s->signal_fd) {
1061                 struct signalfd_siginfo sfsi;
1062                 ssize_t n;
1063
1064                 if (ev->events != EPOLLIN) {
1065                         log_error("Got invalid event from epoll.");
1066                         return -EIO;
1067                 }
1068
1069                 n = read(s->signal_fd, &sfsi, sizeof(sfsi));
1070                 if (n != sizeof(sfsi)) {
1071
1072                         if (n >= 0)
1073                                 return -EIO;
1074
1075                         if (errno == EINTR || errno == EAGAIN)
1076                                 return 1;
1077
1078                         return -errno;
1079                 }
1080
1081                 if (sfsi.ssi_signo == SIGUSR1) {
1082                         touch("/run/systemd/journal/flushed");
1083                         server_flush_to_var(s);
1084                         server_sync(s);
1085                         return 1;
1086                 }
1087
1088                 if (sfsi.ssi_signo == SIGUSR2) {
1089                         server_rotate(s);
1090                         server_vacuum(s);
1091                         return 1;
1092                 }
1093
1094                 log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo));
1095
1096                 return 0;
1097
1098         } else if (ev->data.fd == s->sync_timer_fd) {
1099                 int r;
1100                 uint64_t t;
1101
1102                 log_debug("Got sync request from epoll.");
1103
1104                 r = read(ev->data.fd, (void *)&t, sizeof(t));
1105                 if (r < 0)
1106                         return 0;
1107
1108                 server_sync(s);
1109                 return 1;
1110
1111         } else if (ev->data.fd == s->dev_kmsg_fd) {
1112                 int r;
1113
1114                 if (ev->events != EPOLLIN) {
1115                         log_error("Got invalid event from epoll.");
1116                         return -EIO;
1117                 }
1118
1119                 r = server_read_dev_kmsg(s);
1120                 if (r < 0)
1121                         return r;
1122
1123                 return 1;
1124
1125         } else if (ev->data.fd == s->native_fd ||
1126                    ev->data.fd == s->syslog_fd) {
1127
1128                 if (ev->events != EPOLLIN) {
1129                         log_error("Got invalid event from epoll.");
1130                         return -EIO;
1131                 }
1132
1133                 for (;;) {
1134                         struct msghdr msghdr;
1135                         struct iovec iovec;
1136                         struct ucred *ucred = NULL;
1137                         struct timeval *tv = NULL;
1138                         struct cmsghdr *cmsg;
1139                         char *label = NULL;
1140                         size_t label_len = 0;
1141                         union {
1142                                 struct cmsghdr cmsghdr;
1143
1144                                 /* We use NAME_MAX space for the
1145                                  * SELinux label here. The kernel
1146                                  * currently enforces no limit, but
1147                                  * according to suggestions from the
1148                                  * SELinux people this will change and
1149                                  * it will probably be identical to
1150                                  * NAME_MAX. For now we use that, but
1151                                  * this should be updated one day when
1152                                  * the final limit is known.*/
1153                                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1154                                             CMSG_SPACE(sizeof(struct timeval)) +
1155                                             CMSG_SPACE(sizeof(int)) + /* fd */
1156                                             CMSG_SPACE(NAME_MAX)]; /* selinux label */
1157                         } control;
1158                         ssize_t n;
1159                         int v;
1160                         int *fds = NULL;
1161                         unsigned n_fds = 0;
1162
1163                         if (ioctl(ev->data.fd, SIOCINQ, &v) < 0) {
1164                                 log_error("SIOCINQ failed: %m");
1165                                 return -errno;
1166                         }
1167
1168                         if (s->buffer_size < (size_t) v) {
1169                                 void *b;
1170                                 size_t l;
1171
1172                                 l = MAX(LINE_MAX + (size_t) v, s->buffer_size * 2);
1173                                 b = realloc(s->buffer, l+1);
1174
1175                                 if (!b) {
1176                                         log_error("Couldn't increase buffer.");
1177                                         return -ENOMEM;
1178                                 }
1179
1180                                 s->buffer_size = l;
1181                                 s->buffer = b;
1182                         }
1183
1184                         zero(iovec);
1185                         iovec.iov_base = s->buffer;
1186                         iovec.iov_len = s->buffer_size;
1187
1188                         zero(control);
1189                         zero(msghdr);
1190                         msghdr.msg_iov = &iovec;
1191                         msghdr.msg_iovlen = 1;
1192                         msghdr.msg_control = &control;
1193                         msghdr.msg_controllen = sizeof(control);
1194
1195                         n = recvmsg(ev->data.fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1196                         if (n < 0) {
1197
1198                                 if (errno == EINTR || errno == EAGAIN)
1199                                         return 1;
1200
1201                                 log_error("recvmsg() failed: %m");
1202                                 return -errno;
1203                         }
1204
1205                         for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1206
1207                                 if (cmsg->cmsg_level == SOL_SOCKET &&
1208                                     cmsg->cmsg_type == SCM_CREDENTIALS &&
1209                                     cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
1210                                         ucred = (struct ucred*) CMSG_DATA(cmsg);
1211                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
1212                                          cmsg->cmsg_type == SCM_SECURITY) {
1213                                         label = (char*) CMSG_DATA(cmsg);
1214                                         label_len = cmsg->cmsg_len - CMSG_LEN(0);
1215                                 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1216                                            cmsg->cmsg_type == SO_TIMESTAMP &&
1217                                            cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
1218                                         tv = (struct timeval*) CMSG_DATA(cmsg);
1219                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
1220                                          cmsg->cmsg_type == SCM_RIGHTS) {
1221                                         fds = (int*) CMSG_DATA(cmsg);
1222                                         n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1223                                 }
1224                         }
1225
1226                         if (ev->data.fd == s->syslog_fd) {
1227                                 char *e;
1228
1229                                 if (n > 0 && n_fds == 0) {
1230                                         e = memchr(s->buffer, '\n', n);
1231                                         if (e)
1232                                                 *e = 0;
1233                                         else
1234                                                 s->buffer[n] = 0;
1235
1236                                         server_process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);
1237                                 } else if (n_fds > 0)
1238                                         log_warning("Got file descriptors via syslog socket. Ignoring.");
1239
1240                         } else {
1241                                 if (n > 0 && n_fds == 0)
1242                                         server_process_native_message(s, s->buffer, n, ucred, tv, label, label_len);
1243                                 else if (n == 0 && n_fds == 1)
1244                                         server_process_native_file(s, fds[0], ucred, tv, label, label_len);
1245                                 else if (n_fds > 0)
1246                                         log_warning("Got too many file descriptors via native socket. Ignoring.");
1247                         }
1248
1249                         close_many(fds, n_fds);
1250                 }
1251
1252                 return 1;
1253
1254         } else if (ev->data.fd == s->stdout_fd) {
1255
1256                 if (ev->events != EPOLLIN) {
1257                         log_error("Got invalid event from epoll.");
1258                         return -EIO;
1259                 }
1260
1261                 stdout_stream_new(s);
1262                 return 1;
1263
1264         } else {
1265                 StdoutStream *stream;
1266
1267                 if ((ev->events|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
1268                         log_error("Got invalid event from epoll.");
1269                         return -EIO;
1270                 }
1271
1272                 /* If it is none of the well-known fds, it must be an
1273                  * stdout stream fd. Note that this is a bit ugly here
1274                  * (since we rely that none of the well-known fds
1275                  * could be interpreted as pointer), but nonetheless
1276                  * safe, since the well-known fds would never get an
1277                  * fd > 4096, i.e. beyond the first memory page */
1278
1279                 stream = ev->data.ptr;
1280
1281                 if (stdout_stream_process(stream) <= 0)
1282                         stdout_stream_free(stream);
1283
1284                 return 1;
1285         }
1286
1287         log_error("Unknown event.");
1288         return 0;
1289 }
1290
1291 static int open_signalfd(Server *s) {
1292         sigset_t mask;
1293         struct epoll_event ev;
1294
1295         assert(s);
1296
1297         assert_se(sigemptyset(&mask) == 0);
1298         sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
1299         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
1300
1301         s->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
1302         if (s->signal_fd < 0) {
1303                 log_error("signalfd(): %m");
1304                 return -errno;
1305         }
1306
1307         zero(ev);
1308         ev.events = EPOLLIN;
1309         ev.data.fd = s->signal_fd;
1310
1311         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->signal_fd, &ev) < 0) {
1312                 log_error("epoll_ctl(): %m");
1313                 return -errno;
1314         }
1315
1316         return 0;
1317 }
1318
1319 static int server_parse_proc_cmdline(Server *s) {
1320         _cleanup_free_ char *line = NULL;
1321         char *w, *state;
1322         int r;
1323         size_t l;
1324
1325         if (detect_container(NULL) > 0)
1326                 return 0;
1327
1328         r = read_one_line_file("/proc/cmdline", &line);
1329         if (r < 0) {
1330                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
1331                 return 0;
1332         }
1333
1334         FOREACH_WORD_QUOTED(w, l, line, state) {
1335                 _cleanup_free_ char *word;
1336
1337                 word = strndup(w, l);
1338                 if (!word)
1339                         return -ENOMEM;
1340
1341                 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
1342                         r = parse_boolean(word + 35);
1343                         if (r < 0)
1344                                 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
1345                         else
1346                                 s->forward_to_syslog = r;
1347                 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
1348                         r = parse_boolean(word + 33);
1349                         if (r < 0)
1350                                 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
1351                         else
1352                                 s->forward_to_kmsg = r;
1353                 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
1354                         r = parse_boolean(word + 36);
1355                         if (r < 0)
1356                                 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
1357                         else
1358                                 s->forward_to_console = r;
1359                 } else if (startswith(word, "systemd.journald"))
1360                         log_warning("Invalid systemd.journald parameter. Ignoring.");
1361         }
1362
1363         return 0;
1364 }
1365
1366 static int server_parse_config_file(Server *s) {
1367         static const char fn[] = "/etc/systemd/journald.conf";
1368         _cleanup_fclose_ FILE *f = NULL;
1369         int r;
1370
1371         assert(s);
1372
1373         f = fopen(fn, "re");
1374         if (!f) {
1375                 if (errno == ENOENT)
1376                         return 0;
1377
1378                 log_warning("Failed to open configuration file %s: %m", fn);
1379                 return -errno;
1380         }
1381
1382         r = config_parse(NULL, fn, f, "Journal\0", config_item_perf_lookup,
1383                          (void*) journald_gperf_lookup, false, false, s);
1384         if (r < 0)
1385                 log_warning("Failed to parse configuration file: %s", strerror(-r));
1386
1387         return r;
1388 }
1389
1390 static int server_open_sync_timer(Server *s) {
1391         int r;
1392         struct epoll_event ev;
1393
1394         assert(s);
1395
1396         s->sync_timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
1397         if (s->sync_timer_fd < 0)
1398                 return -errno;
1399
1400         zero(ev);
1401         ev.events = EPOLLIN;
1402         ev.data.fd = s->sync_timer_fd;
1403
1404         r = epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->sync_timer_fd, &ev);
1405         if (r < 0) {
1406                 log_error("Failed to add idle timer fd to epoll object: %m");
1407                 return -errno;
1408         }
1409
1410         return 0;
1411 }
1412
1413 int server_schedule_sync(Server *s) {
1414         int r;
1415
1416         assert(s);
1417
1418         if (s->sync_scheduled)
1419                 return 0;
1420
1421         if (s->sync_interval_usec) {
1422                 struct itimerspec sync_timer_enable = {};
1423
1424                 timespec_store(&sync_timer_enable.it_value, s->sync_interval_usec);
1425
1426                 r = timerfd_settime(s->sync_timer_fd, 0, &sync_timer_enable, NULL);
1427                 if (r < 0)
1428                         return -errno;
1429         }
1430
1431         s->sync_scheduled = true;
1432
1433         return 0;
1434 }
1435
1436 int server_init(Server *s) {
1437         int n, r, fd;
1438
1439         assert(s);
1440
1441         zero(*s);
1442         s->sync_timer_fd = s->syslog_fd = s->native_fd = s->stdout_fd =
1443                 s->signal_fd = s->epoll_fd = s->dev_kmsg_fd = -1;
1444         s->compress = true;
1445         s->seal = true;
1446
1447         s->sync_interval_usec = DEFAULT_SYNC_INTERVAL_USEC;
1448         s->sync_scheduled = false;
1449
1450         s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
1451         s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
1452
1453         s->forward_to_syslog = true;
1454
1455         s->max_level_store = LOG_DEBUG;
1456         s->max_level_syslog = LOG_DEBUG;
1457         s->max_level_kmsg = LOG_NOTICE;
1458         s->max_level_console = LOG_INFO;
1459
1460         memset(&s->system_metrics, 0xFF, sizeof(s->system_metrics));
1461         memset(&s->runtime_metrics, 0xFF, sizeof(s->runtime_metrics));
1462
1463         server_parse_config_file(s);
1464         server_parse_proc_cmdline(s);
1465         if (!!s->rate_limit_interval ^ !!s->rate_limit_burst) {
1466                 log_debug("Setting both rate limit interval and burst from %llu,%u to 0,0",
1467                           (long long unsigned) s->rate_limit_interval,
1468                           s->rate_limit_burst);
1469                 s->rate_limit_interval = s->rate_limit_burst = 0;
1470         }
1471
1472         mkdir_p("/run/systemd/journal", 0755);
1473
1474         s->user_journals = hashmap_new(trivial_hash_func, trivial_compare_func);
1475         if (!s->user_journals)
1476                 return log_oom();
1477
1478         s->mmap = mmap_cache_new();
1479         if (!s->mmap)
1480                 return log_oom();
1481
1482         s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1483         if (s->epoll_fd < 0) {
1484                 log_error("Failed to create epoll object: %m");
1485                 return -errno;
1486         }
1487
1488         n = sd_listen_fds(true);
1489         if (n < 0) {
1490                 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
1491                 return n;
1492         }
1493
1494         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
1495
1496                 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
1497
1498                         if (s->native_fd >= 0) {
1499                                 log_error("Too many native sockets passed.");
1500                                 return -EINVAL;
1501                         }
1502
1503                         s->native_fd = fd;
1504
1505                 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
1506
1507                         if (s->stdout_fd >= 0) {
1508                                 log_error("Too many stdout sockets passed.");
1509                                 return -EINVAL;
1510                         }
1511
1512                         s->stdout_fd = fd;
1513
1514                 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0) {
1515
1516                         if (s->syslog_fd >= 0) {
1517                                 log_error("Too many /dev/log sockets passed.");
1518                                 return -EINVAL;
1519                         }
1520
1521                         s->syslog_fd = fd;
1522
1523                 } else {
1524                         log_error("Unknown socket passed.");
1525                         return -EINVAL;
1526                 }
1527         }
1528
1529         r = server_open_syslog_socket(s);
1530         if (r < 0)
1531                 return r;
1532
1533         r = server_open_native_socket(s);
1534         if (r < 0)
1535                 return r;
1536
1537         r = server_open_stdout_socket(s);
1538         if (r < 0)
1539                 return r;
1540
1541         r = server_open_dev_kmsg(s);
1542         if (r < 0)
1543                 return r;
1544
1545         r = server_open_kernel_seqnum(s);
1546         if (r < 0)
1547                 return r;
1548
1549         r = server_open_sync_timer(s);
1550         if (r < 0)
1551                 return r;
1552
1553         r = open_signalfd(s);
1554         if (r < 0)
1555                 return r;
1556
1557         s->udev = udev_new();
1558         if (!s->udev)
1559                 return -ENOMEM;
1560
1561         s->rate_limit = journal_rate_limit_new(s->rate_limit_interval,
1562                                                s->rate_limit_burst);
1563         if (!s->rate_limit)
1564                 return -ENOMEM;
1565
1566         r = system_journal_open(s);
1567         if (r < 0)
1568                 return r;
1569
1570         return 0;
1571 }
1572
1573 void server_maybe_append_tags(Server *s) {
1574 #ifdef HAVE_GCRYPT
1575         JournalFile *f;
1576         Iterator i;
1577         usec_t n;
1578
1579         n = now(CLOCK_REALTIME);
1580
1581         if (s->system_journal)
1582                 journal_file_maybe_append_tag(s->system_journal, n);
1583
1584         HASHMAP_FOREACH(f, s->user_journals, i)
1585                 journal_file_maybe_append_tag(f, n);
1586 #endif
1587 }
1588
1589 void server_done(Server *s) {
1590         JournalFile *f;
1591         assert(s);
1592
1593         while (s->stdout_streams)
1594                 stdout_stream_free(s->stdout_streams);
1595
1596         if (s->system_journal)
1597                 journal_file_close(s->system_journal);
1598
1599         if (s->runtime_journal)
1600                 journal_file_close(s->runtime_journal);
1601
1602         while ((f = hashmap_steal_first(s->user_journals)))
1603                 journal_file_close(f);
1604
1605         hashmap_free(s->user_journals);
1606
1607         if (s->epoll_fd >= 0)
1608                 close_nointr_nofail(s->epoll_fd);
1609
1610         if (s->signal_fd >= 0)
1611                 close_nointr_nofail(s->signal_fd);
1612
1613         if (s->syslog_fd >= 0)
1614                 close_nointr_nofail(s->syslog_fd);
1615
1616         if (s->native_fd >= 0)
1617                 close_nointr_nofail(s->native_fd);
1618
1619         if (s->stdout_fd >= 0)
1620                 close_nointr_nofail(s->stdout_fd);
1621
1622         if (s->dev_kmsg_fd >= 0)
1623                 close_nointr_nofail(s->dev_kmsg_fd);
1624
1625         if (s->sync_timer_fd >= 0)
1626                 close_nointr_nofail(s->sync_timer_fd);
1627
1628         if (s->rate_limit)
1629                 journal_rate_limit_free(s->rate_limit);
1630
1631         if (s->kernel_seqnum)
1632                 munmap(s->kernel_seqnum, sizeof(uint64_t));
1633
1634         free(s->buffer);
1635         free(s->tty_path);
1636
1637         if (s->mmap)
1638                 mmap_cache_unref(s->mmap);
1639
1640         if (s->udev)
1641                 udev_unref(s->udev);
1642 }