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