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