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