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