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         if (!sd_id128_equal(message_id, SD_ID128_NULL)) {
 718                 snprintf(mid, sizeof(mid), "MESSAGE_ID=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(message_id));
 719                 char_array_0(mid);
 720                 IOVEC_SET_STRING(iovec[n++], mid);
 721         }
 722
 723         zero(ucred);
 724         ucred.pid = getpid();
 725         ucred.uid = getuid();
 726         ucred.gid = getgid();
 727
 728         dispatch_message_real(s, iovec, n, ELEMENTSOF(iovec), &ucred, NULL, NULL, 0, NULL);
 729 }
 730
 731 void server_dispatch_message(
 732                 Server *s,
 733                 struct iovec *iovec, unsigned n, unsigned m,
 734                 struct ucred *ucred,
 735                 struct timeval *tv,
 736                 const char *label, size_t label_len,
 737                 const char *unit_id,
 738                 int priority) {
 739
 740         int rl;
 741         char *path = NULL, *c;
 742
 743         assert(s);
 744         assert(iovec || n == 0);
 745
 746         if (n == 0)
 747                 return;
 748
 749         if (LOG_PRI(priority) > s->max_level_store)
 750                 return;
 751
 752         if (!ucred)
 753                 goto finish;
 754
 755         path = shortened_cgroup_path(ucred->pid);
 756         if (!path)
 757                 goto finish;
 758
 759         /* example: /user/lennart/3/foobar
 760          *          /system/dbus.service/foobar
 761          *
 762          * So let's cut of everything past the third /, since that is
 763          * wher user directories start */
 764
 765         c = strchr(path, '/');
 766         if (c) {
 767                 c = strchr(c+1, '/');
 768                 if (c) {
 769                         c = strchr(c+1, '/');
 770                         if (c)
 771                                 *c = 0;
 772                 }
 773         }
 774
 775         rl = journal_rate_limit_test(s->rate_limit, path, priority & LOG_PRIMASK, available_space(s));
 776
 777         if (rl == 0) {
 778                 free(path);
 779                 return;
 780         }
 781
 782         /* Write a suppression message if we suppressed something */
 783         if (rl > 1)
 784                 server_driver_message(s, SD_MESSAGE_JOURNAL_DROPPED, "Suppressed %u messages from %s", rl - 1, path);
 785
 786         free(path);
 787
 788 finish:
 789         dispatch_message_real(s, iovec, n, m, ucred, tv, label, label_len, unit_id);
 790 }
 791
 792
 793 static int system_journal_open(Server *s) {
 794         int r;
 795         char *fn;
 796         sd_id128_t machine;
 797         char ids[33];
 798
 799         r = sd_id128_get_machine(&machine);
 800         if (r < 0)
 801                 return r;
 802
 803         sd_id128_to_string(machine, ids);
 804
 805         if (!s->system_journal &&
 806             (s->storage == STORAGE_PERSISTENT || s->storage == STORAGE_AUTO) &&
 807             access("/run/systemd/journal/flushed", F_OK) >= 0) {
 808
 809                 /* If in auto mode: first try to create the machine
 810                  * path, but not the prefix.
 811                  *
 812                  * If in persistent mode: create /var/log/journal and
 813                  * the machine path */
 814
 815                 if (s->storage == STORAGE_PERSISTENT)
 816                         (void) mkdir("/var/log/journal/", 0755);
 817
 818                 fn = strappend("/var/log/journal/", ids);
 819                 if (!fn)
 820                         return -ENOMEM;
 821
 822                 (void) mkdir(fn, 0755);
 823                 free(fn);
 824
 825                 fn = strjoin("/var/log/journal/", ids, "/system.journal", NULL);
 826                 if (!fn)
 827                         return -ENOMEM;
 828
 829                 r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, s->seal, &s->system_metrics, s->mmap, NULL, &s->system_journal);
 830                 free(fn);
 831
 832                 if (r >= 0) {
 833                         char fb[FORMAT_BYTES_MAX];
 834
 835                         server_fix_perms(s, s->system_journal, 0);
 836                         server_driver_message(s, SD_ID128_NULL, "Allowing system journal files to grow to %s.",
 837                                               format_bytes(fb, sizeof(fb), s->system_metrics.max_use));
 838
 839                 } else if (r < 0) {
 840
 841                         if (r != -ENOENT && r != -EROFS)
 842                                 log_warning("Failed to open system journal: %s", strerror(-r));
 843
 844                         r = 0;
 845                 }
 846         }
 847
 848         if (!s->runtime_journal &&
 849             (s->storage != STORAGE_NONE)) {
 850
 851                 fn = strjoin("/run/log/journal/", ids, "/system.journal", NULL);
 852                 if (!fn)
 853                         return -ENOMEM;
 854
 855                 if (s->system_journal) {
 856
 857                         /* Try to open the runtime journal, but only
 858                          * if it already exists, so that we can flush
 859                          * it into the system journal */
 860
 861                         r = journal_file_open(fn, O_RDWR, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
 862                         free(fn);
 863
 864                         if (r < 0) {
 865                                 if (r != -ENOENT)
 866                                         log_warning("Failed to open runtime journal: %s", strerror(-r));
 867
 868                                 r = 0;
 869                         }
 870
 871                 } else {
 872
 873                         /* OK, we really need the runtime journal, so create
 874                          * it if necessary. */
 875
 876                         (void) mkdir_parents(fn, 0755);
 877                         r = journal_file_open_reliably(fn, O_RDWR|O_CREAT, 0640, s->compress, false, &s->runtime_metrics, s->mmap, NULL, &s->runtime_journal);
 878                         free(fn);
 879
 880                         if (r < 0) {
 881                                 log_error("Failed to open runtime journal: %s", strerror(-r));
 882                                 return r;
 883                         }
 884                 }
 885
 886                 if (s->runtime_journal) {
 887                         char fb[FORMAT_BYTES_MAX];
 888
 889                         server_fix_perms(s, s->runtime_journal, 0);
 890                         server_driver_message(s, SD_ID128_NULL, "Allowing runtime journal files to grow to %s.",
 891                                               format_bytes(fb, sizeof(fb), s->runtime_metrics.max_use));
 892                 }
 893         }
 894
 895         return r;
 896 }
 897
 898 static int server_flush_to_var(Server *s) {
 899         int r;
 900         sd_id128_t machine;
 901         sd_journal *j = NULL;
 902
 903         assert(s);
 904
 905         if (s->storage != STORAGE_AUTO &&
 906             s->storage != STORAGE_PERSISTENT)
 907                 return 0;
 908
 909         if (!s->runtime_journal)
 910                 return 0;
 911
 912         system_journal_open(s);
 913
 914         if (!s->system_journal)
 915                 return 0;
 916
 917         log_debug("Flushing to /var...");
 918
 919         r = sd_id128_get_machine(&machine);
 920         if (r < 0) {
 921                 log_error("Failed to get machine id: %s", strerror(-r));
 922                 return r;
 923         }
 924
 925         r = sd_journal_open(&j, SD_JOURNAL_RUNTIME_ONLY);
 926         if (r < 0) {
 927                 log_error("Failed to read runtime journal: %s", strerror(-r));
 928                 return r;
 929         }
 930
 931         SD_JOURNAL_FOREACH(j) {
 932                 Object *o = NULL;
 933                 JournalFile *f;
 934
 935                 f = j->current_file;
 936                 assert(f && f->current_offset > 0);
 937
 938                 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
 939                 if (r < 0) {
 940                         log_error("Can't read entry: %s", strerror(-r));
 941                         goto finish;
 942                 }
 943
 944                 r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
 945                 if (r == -E2BIG) {
 946                         log_debug("Allocation limit reached.");
 947
 948                         journal_file_post_change(s->system_journal);
 949                         server_rotate(s);
 950                         server_vacuum(s);
 951
 952                         r = journal_file_copy_entry(f, s->system_journal, o, f->current_offset, NULL, NULL, NULL);
 953                 }
 954
 955                 if (r < 0) {
 956                         log_error("Can't write entry: %s", strerror(-r));
 957                         goto finish;
 958                 }
 959         }
 960
 961 finish:
 962         journal_file_post_change(s->system_journal);
 963
 964         journal_file_close(s->runtime_journal);
 965         s->runtime_journal = NULL;
 966
 967         if (r >= 0)
 968                 rm_rf("/run/log/journal", false, true, false);
 969
 970         if (j)
 971                 sd_journal_close(j);
 972
 973         return r;
 974 }
 975
 976 static int process_event(Server *s, struct epoll_event *ev) {
 977         assert(s);
 978         assert(ev);
 979
 980         if (ev->data.fd == s->signal_fd) {
 981                 struct signalfd_siginfo sfsi;
 982                 ssize_t n;
 983
 984                 if (ev->events != EPOLLIN) {
 985                         log_error("Got invalid event from epoll.");
 986                         return -EIO;
 987                 }
 988
 989                 n = read(s->signal_fd, &sfsi, sizeof(sfsi));
 990                 if (n != sizeof(sfsi)) {
 991
 992                         if (n >= 0)
 993                                 return -EIO;
 994
 995                         if (errno == EINTR || errno == EAGAIN)
 996                                 return 1;
 997
 998                         return -errno;
 999                 }
1000
1001                 log_info("Received SIG%s", signal_to_string(sfsi.ssi_signo));
1002
1003                 if (sfsi.ssi_signo == SIGUSR1) {
1004                         touch("/run/systemd/journal/flushed");
1005                         server_flush_to_var(s);
1006                         return 1;
1007                 }
1008
1009                 if (sfsi.ssi_signo == SIGUSR2) {
1010                         server_rotate(s);
1011                         server_vacuum(s);
1012                         return 1;
1013                 }
1014
1015                 return 0;
1016
1017         } else if (ev->data.fd == s->dev_kmsg_fd) {
1018                 int r;
1019
1020                 if (ev->events != EPOLLIN) {
1021                         log_error("Got invalid event from epoll.");
1022                         return -EIO;
1023                 }
1024
1025                 r = server_read_dev_kmsg(s);
1026                 if (r < 0)
1027                         return r;
1028
1029                 return 1;
1030
1031         } else if (ev->data.fd == s->native_fd ||
1032                    ev->data.fd == s->syslog_fd) {
1033
1034                 if (ev->events != EPOLLIN) {
1035                         log_error("Got invalid event from epoll.");
1036                         return -EIO;
1037                 }
1038
1039                 for (;;) {
1040                         struct msghdr msghdr;
1041                         struct iovec iovec;
1042                         struct ucred *ucred = NULL;
1043                         struct timeval *tv = NULL;
1044                         struct cmsghdr *cmsg;
1045                         char *label = NULL;
1046                         size_t label_len = 0;
1047                         union {
1048                                 struct cmsghdr cmsghdr;
1049
1050                                 /* We use NAME_MAX space for the
1051                                  * SELinux label here. The kernel
1052                                  * currently enforces no limit, but
1053                                  * according to suggestions from the
1054                                  * SELinux people this will change and
1055                                  * it will probably be identical to
1056                                  * NAME_MAX. For now we use that, but
1057                                  * this should be updated one day when
1058                                  * the final limit is known.*/
1059                                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1060                                             CMSG_SPACE(sizeof(struct timeval)) +
1061                                             CMSG_SPACE(sizeof(int)) + /* fd */
1062                                             CMSG_SPACE(NAME_MAX)]; /* selinux label */
1063                         } control;
1064                         ssize_t n;
1065                         int v;
1066                         int *fds = NULL;
1067                         unsigned n_fds = 0;
1068
1069                         if (ioctl(ev->data.fd, SIOCINQ, &v) < 0) {
1070                                 log_error("SIOCINQ failed: %m");
1071                                 return -errno;
1072                         }
1073
1074                         if (s->buffer_size < (size_t) v) {
1075                                 void *b;
1076                                 size_t l;
1077
1078                                 l = MAX(LINE_MAX + (size_t) v, s->buffer_size * 2);
1079                                 b = realloc(s->buffer, l+1);
1080
1081                                 if (!b) {
1082                                         log_error("Couldn't increase buffer.");
1083                                         return -ENOMEM;
1084                                 }
1085
1086                                 s->buffer_size = l;
1087                                 s->buffer = b;
1088                         }
1089
1090                         zero(iovec);
1091                         iovec.iov_base = s->buffer;
1092                         iovec.iov_len = s->buffer_size;
1093
1094                         zero(control);
1095                         zero(msghdr);
1096                         msghdr.msg_iov = &iovec;
1097                         msghdr.msg_iovlen = 1;
1098                         msghdr.msg_control = &control;
1099                         msghdr.msg_controllen = sizeof(control);
1100
1101                         n = recvmsg(ev->data.fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC);
1102                         if (n < 0) {
1103
1104                                 if (errno == EINTR || errno == EAGAIN)
1105                                         return 1;
1106
1107                                 log_error("recvmsg() failed: %m");
1108                                 return -errno;
1109                         }
1110
1111                         for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
1112
1113                                 if (cmsg->cmsg_level == SOL_SOCKET &&
1114                                     cmsg->cmsg_type == SCM_CREDENTIALS &&
1115                                     cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred)))
1116                                         ucred = (struct ucred*) CMSG_DATA(cmsg);
1117                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
1118                                          cmsg->cmsg_type == SCM_SECURITY) {
1119                                         label = (char*) CMSG_DATA(cmsg);
1120                                         label_len = cmsg->cmsg_len - CMSG_LEN(0);
1121                                 } else if (cmsg->cmsg_level == SOL_SOCKET &&
1122                                          cmsg->cmsg_type == SO_TIMESTAMP &&
1123                                          cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval)))
1124                                         tv = (struct timeval*) CMSG_DATA(cmsg);
1125                                 else if (cmsg->cmsg_level == SOL_SOCKET &&
1126                                          cmsg->cmsg_type == SCM_RIGHTS) {
1127                                         fds = (int*) CMSG_DATA(cmsg);
1128                                         n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1129                                 }
1130                         }
1131
1132                         if (ev->data.fd == s->syslog_fd) {
1133                                 char *e;
1134
1135                                 if (n > 0 && n_fds == 0) {
1136                                         e = memchr(s->buffer, '\n', n);
1137                                         if (e)
1138                                                 *e = 0;
1139                                         else
1140                                                 s->buffer[n] = 0;
1141
1142                                         server_process_syslog_message(s, strstrip(s->buffer), ucred, tv, label, label_len);
1143                                 } else if (n_fds > 0)
1144                                         log_warning("Got file descriptors via syslog socket. Ignoring.");
1145
1146                         } else {
1147                                 if (n > 0 && n_fds == 0)
1148                                         server_process_native_message(s, s->buffer, n, ucred, tv, label, label_len);
1149                                 else if (n == 0 && n_fds == 1)
1150                                         server_process_native_file(s, fds[0], ucred, tv, label, label_len);
1151                                 else if (n_fds > 0)
1152                                         log_warning("Got too many file descriptors via native socket. Ignoring.");
1153                         }
1154
1155                         close_many(fds, n_fds);
1156                 }
1157
1158                 return 1;
1159
1160         } else if (ev->data.fd == s->stdout_fd) {
1161
1162                 if (ev->events != EPOLLIN) {
1163                         log_error("Got invalid event from epoll.");
1164                         return -EIO;
1165                 }
1166
1167                 stdout_stream_new(s);
1168                 return 1;
1169
1170         } else {
1171                 StdoutStream *stream;
1172
1173                 if ((ev->events|EPOLLIN|EPOLLHUP) != (EPOLLIN|EPOLLHUP)) {
1174                         log_error("Got invalid event from epoll.");
1175                         return -EIO;
1176                 }
1177
1178                 /* If it is none of the well-known fds, it must be an
1179                  * stdout stream fd. Note that this is a bit ugly here
1180                  * (since we rely that none of the well-known fds
1181                  * could be interpreted as pointer), but nonetheless
1182                  * safe, since the well-known fds would never get an
1183                  * fd > 4096, i.e. beyond the first memory page */
1184
1185                 stream = ev->data.ptr;
1186
1187                 if (stdout_stream_process(stream) <= 0)
1188                         stdout_stream_free(stream);
1189
1190                 return 1;
1191         }
1192
1193         log_error("Unknown event.");
1194         return 0;
1195 }
1196
1197 static int open_signalfd(Server *s) {
1198         sigset_t mask;
1199         struct epoll_event ev;
1200
1201         assert(s);
1202
1203         assert_se(sigemptyset(&mask) == 0);
1204         sigset_add_many(&mask, SIGINT, SIGTERM, SIGUSR1, SIGUSR2, -1);
1205         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
1206
1207         s->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
1208         if (s->signal_fd < 0) {
1209                 log_error("signalfd(): %m");
1210                 return -errno;
1211         }
1212
1213         zero(ev);
1214         ev.events = EPOLLIN;
1215         ev.data.fd = s->signal_fd;
1216
1217         if (epoll_ctl(s->epoll_fd, EPOLL_CTL_ADD, s->signal_fd, &ev) < 0) {
1218                 log_error("epoll_ctl(): %m");
1219                 return -errno;
1220         }
1221
1222         return 0;
1223 }
1224
1225 static int server_parse_proc_cmdline(Server *s) {
1226         char *line, *w, *state;
1227         int r;
1228         size_t l;
1229
1230         if (detect_container(NULL) > 0)
1231                 return 0;
1232
1233         r = read_one_line_file("/proc/cmdline", &line);
1234         if (r < 0) {
1235                 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
1236                 return 0;
1237         }
1238
1239         FOREACH_WORD_QUOTED(w, l, line, state) {
1240                 char *word;
1241
1242                 word = strndup(w, l);
1243                 if (!word) {
1244                         r = -ENOMEM;
1245                         goto finish;
1246                 }
1247
1248                 if (startswith(word, "systemd.journald.forward_to_syslog=")) {
1249                         r = parse_boolean(word + 35);
1250                         if (r < 0)
1251                                 log_warning("Failed to parse forward to syslog switch %s. Ignoring.", word + 35);
1252                         else
1253                                 s->forward_to_syslog = r;
1254                 } else if (startswith(word, "systemd.journald.forward_to_kmsg=")) {
1255                         r = parse_boolean(word + 33);
1256                         if (r < 0)
1257                                 log_warning("Failed to parse forward to kmsg switch %s. Ignoring.", word + 33);
1258                         else
1259                                 s->forward_to_kmsg = r;
1260                 } else if (startswith(word, "systemd.journald.forward_to_console=")) {
1261                         r = parse_boolean(word + 36);
1262                         if (r < 0)
1263                                 log_warning("Failed to parse forward to console switch %s. Ignoring.", word + 36);
1264                         else
1265                                 s->forward_to_console = r;
1266                 } else if (startswith(word, "systemd.journald"))
1267                         log_warning("Invalid systemd.journald parameter. Ignoring.");
1268
1269                 free(word);
1270         }
1271
1272         r = 0;
1273
1274 finish:
1275         free(line);
1276         return r;
1277 }
1278
1279 static int server_parse_config_file(Server *s) {
1280         FILE *f;
1281         const char *fn;
1282         int r;
1283
1284         assert(s);
1285
1286         fn = "/etc/systemd/journald.conf";
1287         f = fopen(fn, "re");
1288         if (!f) {
1289                 if (errno == ENOENT)
1290                         return 0;
1291
1292                 log_warning("Failed to open configuration file %s: %m", fn);
1293                 return -errno;
1294         }
1295
1296         r = config_parse(fn, f, "Journal\0", config_item_perf_lookup, (void*) journald_gperf_lookup, false, s);
1297         if (r < 0)
1298                 log_warning("Failed to parse configuration file: %s", strerror(-r));
1299
1300         fclose(f);
1301
1302         return r;
1303 }
1304
1305 static int server_init(Server *s) {
1306         int n, r, fd;
1307
1308         assert(s);
1309
1310         zero(*s);
1311         s->syslog_fd = s->native_fd = s->stdout_fd = s->signal_fd = s->epoll_fd = s->dev_kmsg_fd = -1;
1312         s->compress = true;
1313         s->seal = true;
1314
1315         s->rate_limit_interval = DEFAULT_RATE_LIMIT_INTERVAL;
1316         s->rate_limit_burst = DEFAULT_RATE_LIMIT_BURST;
1317
1318         s->forward_to_syslog = true;
1319
1320         s->max_level_store = LOG_DEBUG;
1321         s->max_level_syslog = LOG_DEBUG;
1322         s->max_level_kmsg = LOG_NOTICE;
1323         s->max_level_console = LOG_INFO;
1324
1325         memset(&s->system_metrics, 0xFF, sizeof(s->system_metrics));
1326         memset(&s->runtime_metrics, 0xFF, sizeof(s->runtime_metrics));
1327
1328         server_parse_config_file(s);
1329         server_parse_proc_cmdline(s);
1330
1331         mkdir_p("/run/systemd/journal", 0755);
1332
1333         s->user_journals = hashmap_new(trivial_hash_func, trivial_compare_func);
1334         if (!s->user_journals)
1335                 return log_oom();
1336
1337         s->mmap = mmap_cache_new();
1338         if (!s->mmap)
1339                 return log_oom();
1340
1341         s->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1342         if (s->epoll_fd < 0) {
1343                 log_error("Failed to create epoll object: %m");
1344                 return -errno;
1345         }
1346
1347         n = sd_listen_fds(true);
1348         if (n < 0) {
1349                 log_error("Failed to read listening file descriptors from environment: %s", strerror(-n));
1350                 return n;
1351         }
1352
1353         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++) {
1354
1355                 if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/run/systemd/journal/socket", 0) > 0) {
1356
1357                         if (s->native_fd >= 0) {
1358                                 log_error("Too many native sockets passed.");
1359                                 return -EINVAL;
1360                         }
1361
1362                         s->native_fd = fd;
1363
1364                 } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, "/run/systemd/journal/stdout", 0) > 0) {
1365
1366                         if (s->stdout_fd >= 0) {
1367                                 log_error("Too many stdout sockets passed.");
1368                                 return -EINVAL;
1369                         }
1370
1371                         s->stdout_fd = fd;
1372
1373                 } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, "/dev/log", 0) > 0) {
1374
1375                         if (s->syslog_fd >= 0) {
1376                                 log_error("Too many /dev/log sockets passed.");
1377                                 return -EINVAL;
1378                         }
1379
1380                         s->syslog_fd = fd;
1381
1382                 } else {
1383                         log_error("Unknown socket passed.");
1384                         return -EINVAL;
1385                 }
1386         }
1387
1388         r = server_open_syslog_socket(s);
1389         if (r < 0)
1390                 return r;
1391
1392         r = server_open_native_socket(s);
1393         if (r < 0)
1394                 return r;
1395
1396         r = server_open_stdout_socket(s);
1397         if (r < 0)
1398                 return r;
1399
1400         r = server_open_dev_kmsg(s);
1401         if (r < 0)
1402                 return r;
1403
1404         r = server_open_kernel_seqnum(s);
1405         if (r < 0)
1406                 return r;
1407
1408         r = open_signalfd(s);
1409         if (r < 0)
1410                 return r;
1411
1412         s->udev = udev_new();
1413         if (!s->udev)
1414                 return -ENOMEM;
1415
1416         s->rate_limit = journal_rate_limit_new(s->rate_limit_interval, s->rate_limit_burst);
1417         if (!s->rate_limit)
1418                 return -ENOMEM;
1419
1420         r = system_journal_open(s);
1421         if (r < 0)
1422                 return r;
1423
1424         return 0;
1425 }
1426
1427 static void server_maybe_append_tags(Server *s) {
1428 #ifdef HAVE_GCRYPT
1429         JournalFile *f;
1430         Iterator i;
1431         usec_t n;
1432
1433         n = now(CLOCK_REALTIME);
1434
1435         if (s->system_journal)
1436                 journal_file_maybe_append_tag(s->system_journal, n);
1437
1438         HASHMAP_FOREACH(f, s->user_journals, i)
1439                 journal_file_maybe_append_tag(f, n);
1440 #endif
1441 }
1442
1443 static void server_done(Server *s) {
1444         JournalFile *f;
1445         assert(s);
1446
1447         while (s->stdout_streams)
1448                 stdout_stream_free(s->stdout_streams);
1449
1450         if (s->system_journal)
1451                 journal_file_close(s->system_journal);
1452
1453         if (s->runtime_journal)
1454                 journal_file_close(s->runtime_journal);
1455
1456         while ((f = hashmap_steal_first(s->user_journals)))
1457                 journal_file_close(f);
1458
1459         hashmap_free(s->user_journals);
1460
1461         if (s->epoll_fd >= 0)
1462                 close_nointr_nofail(s->epoll_fd);
1463
1464         if (s->signal_fd >= 0)
1465                 close_nointr_nofail(s->signal_fd);
1466
1467         if (s->syslog_fd >= 0)
1468                 close_nointr_nofail(s->syslog_fd);
1469
1470         if (s->native_fd >= 0)
1471                 close_nointr_nofail(s->native_fd);
1472
1473         if (s->stdout_fd >= 0)
1474                 close_nointr_nofail(s->stdout_fd);
1475
1476         if (s->dev_kmsg_fd >= 0)
1477                 close_nointr_nofail(s->dev_kmsg_fd);
1478
1479         if (s->rate_limit)
1480                 journal_rate_limit_free(s->rate_limit);
1481
1482         if (s->kernel_seqnum)
1483                 munmap(s->kernel_seqnum, sizeof(uint64_t));
1484
1485         free(s->buffer);
1486         free(s->tty_path);
1487
1488         if (s->mmap)
1489                 mmap_cache_unref(s->mmap);
1490
1491         if (s->udev)
1492                 udev_unref(s->udev);
1493 }
1494
1495 int main(int argc, char *argv[]) {
1496         Server server;
1497         int r;
1498
1499         /* if (getppid() != 1) { */
1500         /*         log_error("This program should be invoked by init only."); */
1501         /*         return EXIT_FAILURE; */
1502         /* } */
1503
1504         if (argc > 1) {
1505                 log_error("This program does not take arguments.");
1506                 return EXIT_FAILURE;
1507         }
1508
1509         log_set_target(LOG_TARGET_SAFE);
1510         log_set_facility(LOG_SYSLOG);
1511         log_parse_environment();
1512         log_open();
1513
1514         umask(0022);
1515
1516         r = server_init(&server);
1517         if (r < 0)
1518                 goto finish;
1519
1520         server_vacuum(&server);
1521         server_flush_to_var(&server);
1522         server_flush_dev_kmsg(&server);
1523
1524         log_debug("systemd-journald running as pid %lu", (unsigned long) getpid());
1525         server_driver_message(&server, SD_MESSAGE_JOURNAL_START, "Journal started");
1526
1527         sd_notify(false,
1528                   "READY=1\n"
1529                   "STATUS=Processing requests...");
1530
1531         for (;;) {
1532                 struct epoll_event event;
1533                 int t;
1534
1535 #ifdef HAVE_GCRYPT
1536                 usec_t u;
1537
1538                 if (server.system_journal &&
1539                     journal_file_next_evolve_usec(server.system_journal, &u)) {
1540                         usec_t n;
1541
1542                         n = now(CLOCK_REALTIME);
1543
1544                         if (n >= u)
1545                                 t = 0;
1546                         else
1547                                 t = (int) ((u - n + USEC_PER_MSEC - 1) / USEC_PER_MSEC);
1548                 } else
1549 #endif
1550                         t = -1;
1551
1552                 r = epoll_wait(server.epoll_fd, &event, 1, t);
1553                 if (r < 0) {
1554
1555                         if (errno == EINTR)
1556                                 continue;
1557
1558                         log_error("epoll_wait() failed: %m");
1559                         r = -errno;
1560                         goto finish;
1561                 }
1562
1563                 if (r > 0) {
1564                         r = process_event(&server, &event);
1565                         if (r < 0)
1566                                 goto finish;
1567                         else if (r == 0)
1568                                 break;
1569                 }
1570
1571                 server_maybe_append_tags(&server);
1572                 server_maybe_warn_forward_syslog_missed(&server);
1573         }
1574
1575         log_debug("systemd-journald stopped as pid %lu", (unsigned long) getpid());
1576         server_driver_message(&server, SD_MESSAGE_JOURNAL_STOP, "Journal stopped");
1577
1578 finish:
1579         sd_notify(false,
1580                   "STATUS=Shutting down...");
1581
1582         server_done(&server);
1583
1584         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1585 }