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