src/journal/journald.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <unistd.h>
   4
   5 #include "sd-daemon.h"
   6 #include "sd-messages.h"
   7
   8 #include "format-util.h"
   9 #include "journal-authenticate.h"
  10 #include "journald-kmsg.h"
  11 #include "journald-server.h"
  12 #include "journald-syslog.h"
  13 #include "process-util.h"
  14 #include "sigbus.h"
  15
  16 int main(int argc, char *argv[]) {
  17         Server server;
  18         int r;
  19
  20         if (argc > 1) {
  21                 log_error("This program does not take arguments.");
  22                 return EXIT_FAILURE;
  23         }
  24
  25         log_set_prohibit_ipc(true);
  26         log_set_target(LOG_TARGET_AUTO);
  27         log_set_facility(LOG_SYSLOG);
  28         log_parse_environment();
  29         log_open();
  30
  31         umask(0022);
  32
  33         sigbus_install();
  34
  35         r = server_init(&server);
  36         if (r < 0)
  37                 goto finish;
  38
  39         server_vacuum(&server, false);
  40         server_flush_to_var(&server, true);
  41         server_flush_dev_kmsg(&server);
  42
  43         log_debug("systemd-journald running as pid "PID_FMT, getpid_cached());
  44         server_driver_message(&server, 0,
  45                               "MESSAGE_ID=" SD_MESSAGE_JOURNAL_START_STR,
  46                               LOG_MESSAGE("Journal started"),
  47                               NULL);
  48
  49         /* Make sure to send the usage message *after* flushing the
  50          * journal so entries from the runtime journals are ordered
  51          * before this message. See #4190 for some details. */
  52         server_space_usage_message(&server, NULL);
  53
  54         for (;;) {
  55                 usec_t t = USEC_INFINITY, n;
  56
  57                 r = sd_event_get_state(server.event);
  58                 if (r < 0)
  59                         goto finish;
  60                 if (r == SD_EVENT_FINISHED)
  61                         break;
  62
  63                 n = now(CLOCK_REALTIME);
  64
  65                 if (server.max_retention_usec > 0 && server.oldest_file_usec > 0) {
  66
  67                         /* The retention time is reached, so let's vacuum! */
  68                         if (server.oldest_file_usec + server.max_retention_usec < n) {
  69                                 log_info("Retention time reached.");
  70                                 server_rotate(&server);
  71                                 server_vacuum(&server, false);
  72                                 continue;
  73                         }
  74
  75                         /* Calculate when to rotate the next time */
  76                         t = server.oldest_file_usec + server.max_retention_usec - n;
  77                 }
  78
  79 #if HAVE_GCRYPT
  80                 if (server.system_journal) {
  81                         usec_t u;
  82
  83                         if (journal_file_next_evolve_usec(server.system_journal, &u)) {
  84                                 if (n >= u)
  85                                         t = 0;
  86                                 else
  87                                         t = MIN(t, u - n);
  88                         }
  89                 }
  90 #endif
  91
  92                 r = sd_event_run(server.event, t);
  93                 if (r < 0) {
  94                         log_error_errno(r, "Failed to run event loop: %m");
  95                         goto finish;
  96                 }
  97
  98                 server_maybe_append_tags(&server);
  99                 server_maybe_warn_forward_syslog_missed(&server);
 100         }
 101
 102         log_debug("systemd-journald stopped as pid "PID_FMT, getpid_cached());
 103         server_driver_message(&server, 0,
 104                               "MESSAGE_ID=" SD_MESSAGE_JOURNAL_STOP_STR,
 105                               LOG_MESSAGE("Journal stopped"),
 106                               NULL);
 107
 108 finish:
 109         server_done(&server);
 110
 111         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 112 }