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