HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/journal/journald-manager.c

101,383 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: a0fc0d8c9bae282356d0744068ab54f859896e0c

Lines 2001–2634 of 2,634

        if (r < 0)
                log_warning_errno(r, "Failed to turn on notify event source: %m");
 
        r = sd_event_source_set_time(m->watchdog_event_source, usec + m->watchdog_usec / 2);
        if (r < 0)
                return log_error_errno(r, "Failed to restart watchdog event source: %m");
 
        r = sd_event_source_set_enabled(m->watchdog_event_source, SD_EVENT_ON);
        if (r < 0)
                return log_error_errno(r, "Failed to enable watchdog event source: %m");
 
        return 0;
}
 
static int manager_connect_notify(Manager *m) {
        union sockaddr_union sa;
        socklen_t sa_len;
        const char *e;
        int r;
 
        assert(m);
        assert(m->notify_fd < 0);
        assert(!m->notify_event_source);
 
        /*
         * So here's the problem: we'd like to send notification messages to PID 1, but we cannot do that via
         * sd_notify(), since that's synchronous, and we might end up blocking on it. Specifically: given
         * that PID 1 might block on dbus-daemon during IPC, and dbus-daemon is logging to us, and might
         * hence block on us, we might end up in a deadlock if we block on sending PID 1 notification
         * messages — by generating a full blocking circle. To avoid this, let's create a non-blocking
         * socket, and connect it to the notification socket, and then wait for POLLOUT before we send
         * anything. This should efficiently avoid any deadlocks, as we'll never block on PID 1, hence PID 1
         * can safely block on dbus-daemon which can safely block on us again.
         *
         * Don't think that this issue is real? It is, see: https://github.com/systemd/systemd/issues/1505
         */
 
        e = getenv("NOTIFY_SOCKET");
        if (!e)
                return 0;
 
        r = sockaddr_un_set_path(&sa.un, e);
        if (r < 0)
                return log_error_errno(r, "NOTIFY_SOCKET set to invalid value '%s': %m", e);
        sa_len = r;
 
        m->notify_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
        if (m->notify_fd < 0)
                return log_error_errno(errno, "Failed to create notify socket: %m");
 
        (void) fd_inc_sndbuf(m->notify_fd, NOTIFY_SNDBUF_SIZE);
 
        r = connect(m->notify_fd, &sa.sa, sa_len);
        if (r < 0)
                return log_error_errno(errno, "Failed to connect to notify socket: %m");
 
        r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLOUT, dispatch_notify_event, m);
        if (r < 0)
                return log_error_errno(r, "Failed to watch notification socket: %m");
 
        if (sd_watchdog_enabled(false, &m->watchdog_usec) > 0) {
                m->send_watchdog = true;
 
                r = sd_event_add_time_relative(m->event, &m->watchdog_event_source, CLOCK_MONOTONIC, m->watchdog_usec/2, m->watchdog_usec/4, dispatch_watchdog, m);
                if (r < 0)
                        return log_error_errno(r, "Failed to add watchdog time event: %m");
        }
 
        /* This should fire pretty soon, which we'll use to send the READY=1 event. */
 
        return 0;
}
 
int manager_map_seqnum_file(
                Manager *m,
                const char *fname,
                size_t size,
                void **ret) {
 
        _cleanup_free_ char *fn = NULL;
        _cleanup_close_ int fd = -EBADF;
        uint64_t *p;
        int r;
 
        assert(m);
        assert(fname);
        assert(size > 0);
        assert(ret);
 
        fn = path_join(m->runtime_directory, fname);
        if (!fn)
                return -ENOMEM;
 
        fd = open(fn, O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0644);
        if (fd < 0)
                return -errno;
 
        r = posix_fallocate_loop(fd, 0, size);
        if (r < 0)
                return r;
 
        p = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
        if (p == MAP_FAILED)
                return -errno;
 
        *ret = p;
        return 0;
}
 
void manager_unmap_seqnum_file(void *p, size_t size) {
        assert(size > 0);
 
        if (!p)
                return;
 
        assert_se(munmap(p, size) >= 0);
}
 
int manager_unlink_seqnum_file(Manager *m, const char *fname) {
        assert(m);
        assert(fname);
 
        _cleanup_free_ char *fn = path_join(m->runtime_directory, fname);
        if (!fn)
                return log_oom();
 
        if (unlink(fn) < 0 && errno != ENOENT)
                return log_warning_errno(errno, "Failed to remove '%s': %m", fname);
 
        return 0;
}
 
static bool manager_is_idle(Manager *m) {
        assert(m);
 
        /* The manager for the main namespace is never idle */
        if (!m->namespace)
                return false;
 
        /* If a retention maximum is set larger than the idle time we need to be running to enforce it, hence
         * turn off the idle logic. */
        if (m->config.max_retention_usec > IDLE_TIMEOUT_USEC)
                return false;
 
        /* We aren't idle if we have a varlink client */
        if (sd_varlink_server_current_connections(m->varlink_server) > 0)
                return false;
 
        /* If we have stdout streams we aren't idle */
        if (m->n_stdout_streams > 0)
                return false;
 
        return true;
}
 
static int manager_idle_handler(sd_event_source *source, uint64_t usec, void *userdata) {
        Manager *m = ASSERT_PTR(userdata);
 
        assert(source);
 
        log_debug("Manager is idle, exiting.");
        sd_event_exit(m->event, 0);
        return 0;
}
 
int manager_start_or_stop_idle_timer(Manager *m) {
        _cleanup_(sd_event_source_unrefp) sd_event_source *source = NULL;
        int r;
 
        assert(m);
 
        if (sd_event_get_state(m->event) == SD_EVENT_FINISHED ||
            !manager_is_idle(m)) {
                m->idle_event_source = sd_event_source_disable_unref(m->idle_event_source);
                return 0;
        }
 
        if (m->idle_event_source)
                return 1;
 
        r = sd_event_add_time_relative(m->event, &source, CLOCK_MONOTONIC, IDLE_TIMEOUT_USEC, 0, manager_idle_handler, m);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate idle timer: %m");
 
        r = sd_event_source_set_priority(source, SD_EVENT_PRIORITY_IDLE);
        if (r < 0)
                return log_error_errno(r, "Failed to set idle timer priority: %m");
 
        (void) sd_event_source_set_description(source, "idle-timer");
 
        m->idle_event_source = TAKE_PTR(source);
        return 1;
}
 
static int manager_refresh_idle_timer(Manager *m) {
        int r;
 
        assert(m);
 
        if (!m->idle_event_source)
                return 0;
 
        r = sd_event_source_set_time_relative(m->idle_event_source, IDLE_TIMEOUT_USEC);
        if (r < 0)
                return log_error_errno(r, "Failed to refresh idle timer: %m");
 
        return 1;
}
 
int manager_set_namespace(Manager *m, const char *namespace) {
        assert(m);
 
        if (!namespace)
                return 0;
 
        if (!log_namespace_name_valid(namespace))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Specified namespace name not valid, refusing: %s", namespace);
 
        m->namespace = strdup(namespace);
        if (!m->namespace)
                return log_oom();
 
        m->namespace_field = strjoin("_NAMESPACE=", namespace);
        if (!m->namespace_field)
                return log_oom();
 
        return 1;
}
 
static int manager_memory_pressure(sd_event_source *es, void *userdata) {
        Manager *m = ASSERT_PTR(userdata);
 
        log_info("Under memory pressure, flushing caches.");
 
        /* Flushed the cached info we might have about client processes */
        client_context_flush_regular(m);
 
        /* Let's also close all user files (but keep the system/runtime one open) */
        for (;;) {
                JournalFile *first = ordered_hashmap_steal_first(m->user_journals);
 
                if (!first)
                        break;
 
                (void) journal_file_offline_close(first);
        }
 
        sd_event_trim_memory();
 
        return 0;
}
 
static int manager_setup_memory_pressure(Manager *m) {
        int r;
 
        assert(m);
 
        r = sd_event_add_memory_pressure(m->event, NULL, manager_memory_pressure, m);
        if (r < 0)
                log_full_errno(ERRNO_IS_NOT_SUPPORTED(r) || ERRNO_IS_PRIVILEGE(r) || (r == -EHOSTDOWN) ? LOG_DEBUG : LOG_NOTICE, r,
                               "Failed to install memory pressure event source, ignoring: %m");
 
        return 0;
}
 
void manager_reopen_journals(Manager *m, const JournalConfig *old) {
        assert(m);
 
        if (m->config.storage == old->storage &&
            m->config.compress.enabled == old->compress.enabled &&
            m->config.compress.threshold_bytes == old->compress.threshold_bytes &&
            m->config.seal == old->seal &&
            m->config.sync_interval_usec == old->sync_interval_usec &&
            journal_metrics_equal(&m->config.system_storage_metrics, &old->system_storage_metrics) &&
            journal_metrics_equal(&m->config.runtime_storage_metrics, &old->runtime_storage_metrics))
                return; /* no-op */
 
        /* Explicitly close the runtime journal to make it reopened later by manager_system_journal_open().
         * But only when volatile (or no) storage is requested. If auto or persistent storage is requested,
         * we may need to flush the runtime journal to the persistent storage, it will done through
         * manager_system_journal_open(). Hence, we should not touch the runtime journal here in that case. */
        if (IN_SET(m->config.storage, STORAGE_VOLATILE, STORAGE_NONE))
                m->runtime_journal = journal_file_offline_close(m->runtime_journal);
 
        /* Close other journals unconditionally to make the new settings applied. */
        m->system_journal = journal_file_offline_close(m->system_journal);
        ordered_hashmap_clear(m->user_journals);
        set_clear(m->deferred_closes);
 
        (void) manager_system_journal_open(m, /* flush_requested= */ false, /* relinquish_requested= */ false);
 
        /* To make the storage related settings applied, vacuum the storage. */
        cache_space_invalidate(&m->system_storage.space);
        cache_space_invalidate(&m->runtime_storage.space);
        manager_vacuum(m, /* verbose= */ false);
}
 
int manager_new(Manager **ret) {
        _cleanup_(manager_freep) Manager *m = NULL;
 
        assert(ret);
 
        m = new(Manager, 1);
        if (!m)
                return -ENOMEM;
 
        *m = (Manager) {
                .syslog_fd = -EBADF,
                .native_fd = -EBADF,
                .stdout_fd = -EBADF,
                .dev_kmsg_fd = -EBADF,
                .audit_fd = -EBADF,
                .hostname_fd = -EBADF,
                .notify_fd = -EBADF,
                .forward_socket_fd = -EBADF,
 
                .system_storage.name = "System Journal",
                .runtime_storage.name = "Runtime Journal",
 
                .watchdog_usec = USEC_INFINITY,
 
                .sync_scheduled = false,
 
                .kmsg_own_ratelimit = {
                        .interval = DEFAULT_KMSG_OWN_INTERVAL,
                        .burst = DEFAULT_KMSG_OWN_BURST,
                },
 
                .sigrtmin18_info.memory_pressure_handler = manager_memory_pressure,
                .sigrtmin18_info.memory_pressure_userdata = m,
        };
 
        journal_config_set_defaults(&m->config_by_conf);
        journal_config_set_defaults(&m->config_by_cred);
        journal_config_set_defaults(&m->config_by_cmdline);
 
        *ret = TAKE_PTR(m);
        return 0;
}
 
int manager_init(Manager *m) {
        const char *native_socket, *syslog_socket, *stdout_socket, *varlink_socket, *e;
        _cleanup_fdset_free_ FDSet *fds = NULL;
        int n, r, varlink_fd = -EBADF;
        bool no_sockets;
 
        assert(m);
 
        e = getenv("RUNTIME_DIRECTORY");
        if (e)
                m->runtime_directory = strdup(e);
        else if (m->namespace)
                m->runtime_directory = strjoin("/run/systemd/journal.", m->namespace);
        else
                m->runtime_directory = strdup("/run/systemd/journal");
        if (!m->runtime_directory)
                return log_oom();
 
        (void) mkdir_p(m->runtime_directory, 0755);
 
        m->user_journals = ordered_hashmap_new(&journal_file_hash_ops_offline_close);
        if (!m->user_journals)
                return log_oom();
 
        m->mmap = mmap_cache_new();
        if (!m->mmap)
                return log_oom();
 
        m->deferred_closes = set_new(&journal_file_hash_ops_offline_close);
        if (!m->deferred_closes)
                return log_oom();
 
        r = sd_event_default(&m->event);
        if (r < 0)
                return log_error_errno(r, "Failed to create event loop: %m");
 
        n = sd_listen_fds(true);
        if (n < 0)
                return log_error_errno(n, "Failed to read listening file descriptors from environment: %m");
 
        native_socket = strjoina(m->runtime_directory, "/socket");
        stdout_socket = strjoina(m->runtime_directory, "/stdout");
        syslog_socket = strjoina(m->runtime_directory, "/dev-log");
        varlink_socket = strjoina(m->runtime_directory, "/io.systemd.journal");
 
        for (int fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++)
 
                if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, native_socket, 0) > 0) {
 
                        if (m->native_fd >= 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Too many native sockets passed.");
 
                        m->native_fd = fd;
 
                } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, stdout_socket, 0) > 0) {
 
                        if (m->stdout_fd >= 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Too many stdout sockets passed.");
 
                        m->stdout_fd = fd;
 
                } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, syslog_socket, 0) > 0) {
 
                        if (m->syslog_fd >= 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Too many /dev/log sockets passed.");
 
                        m->syslog_fd = fd;
 
                } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, varlink_socket, 0) > 0) {
 
                        if (varlink_fd >= 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Too many varlink sockets passed.");
 
                        varlink_fd = fd;
                } else if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) {
 
                        if (m->audit_fd >= 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Too many audit sockets passed.");
 
                        m->audit_fd = fd;
 
                } else {
 
                        if (!fds) {
                                fds = fdset_new();
                                if (!fds)
                                        return log_oom();
                        }
 
                        r = fdset_put(fds, fd);
                        if (r < 0)
                                return log_oom();
                }
 
        /* Try to restore streams, but don't bother if this fails */
        (void) manager_restore_streams(m, fds);
 
        if (!fdset_isempty(fds)) {
                log_warning("%u unknown file descriptors passed, closing.", fdset_size(fds));
                fds = fdset_free(fds);
        }
 
        no_sockets = m->native_fd < 0 && m->stdout_fd < 0 && m->syslog_fd < 0 && m->audit_fd < 0 && varlink_fd < 0;
 
        /* always open stdout, syslog, native, and kmsg sockets */
 
        /* systemd-journald.socket: /run/systemd/journal/stdout */
        r = manager_open_stdout_socket(m, stdout_socket);
        if (r < 0)
                return r;
 
        /* systemd-journald-dev-log.socket: /run/systemd/journal/dev-log */
        r = manager_open_syslog_socket(m, syslog_socket);
        if (r < 0)
                return r;
 
        /* systemd-journald.socket: /run/systemd/journal/socket */
        r = manager_open_native_socket(m, native_socket);
        if (r < 0)
                return r;
 
        /* /dev/kmsg */
        r = manager_open_dev_kmsg(m);
        if (r < 0)
                return r;
 
        /* Unless we got *some* sockets and not audit, open audit socket */
        if (m->audit_fd >= 0 || no_sockets) {
                log_info("Collecting audit messages is enabled.");
 
                r = manager_open_audit(m);
                if (r < 0)
                        return r;
        } else
                log_info("Collecting audit messages is disabled.");
 
        r = manager_open_varlink(m, varlink_socket, varlink_fd);
        if (r < 0)
                return r;
 
        r = manager_map_seqnum_file(m, "seqnum", sizeof(SeqnumData), (void**) &m->seqnum);
        if (r < 0)
                return log_error_errno(r, "Failed to map main seqnum file: %m");
 
        r = manager_open_kernel_seqnum(m);
        if (r < 0)
                return r;
 
        r = manager_open_hostname(m);
        if (r < 0)
                return r;
 
        r = manager_setup_signals(m);
        if (r < 0)
                return r;
 
        r = manager_setup_memory_pressure(m);
        if (r < 0)
                return r;
 
        r = cg_get_root_path(&m->cgroup_root);
        if (r < 0)
                return log_error_errno(r, "Failed to acquire cgroup root path: %m");
 
        manager_cache_hostname(m);
        manager_cache_boot_id(m);
        manager_cache_machine_id(m);
 
        if (m->namespace)
                m->runtime_storage.path = strjoin("/run/log/journal/", MANAGER_MACHINE_ID(m), ".", m->namespace);
        else
                m->runtime_storage.path = strjoin("/run/log/journal/", MANAGER_MACHINE_ID(m));
        if (!m->runtime_storage.path)
                return log_oom();
 
        e = getenv("LOGS_DIRECTORY");
        if (e)
                m->system_storage.path = strdup(e);
        else if (m->namespace)
                m->system_storage.path = strjoin("/var/log/journal/", MANAGER_MACHINE_ID(m), ".", m->namespace);
        else
                m->system_storage.path = strjoin("/var/log/journal/", MANAGER_MACHINE_ID(m));
        if (!m->system_storage.path)
                return log_oom();
 
        (void) manager_connect_notify(m);
 
        client_context_acquire_default(m);
 
        r = manager_system_journal_open(m, /* flush_requested= */ false, /* relinquish_requested= */ false);
        if (r < 0)
                return r;
 
        manager_start_or_stop_idle_timer(m);
 
        return 0;
}
 
void manager_maybe_append_tags(Manager *m) {
        assert(m);
 
        usec_t n = now(CLOCK_REALTIME);
 
        if (m->system_journal)
                journal_file_auth_append_tag_maybe(m->system_journal, n);
 
        JournalFile *f;
        ORDERED_HASHMAP_FOREACH(f, m->user_journals)
                journal_file_auth_append_tag_maybe(f, n);
}
 
Manager* manager_free(Manager *m) {
        if (!m)
                return NULL;
 
        free(m->namespace);
        free(m->namespace_field);
 
        set_free(m->deferred_closes);
 
        while (m->stdout_streams)
                stdout_stream_free(m->stdout_streams);
 
        client_context_flush_all(m);
 
        (void) journal_file_offline_close(m->system_journal);
        (void) journal_file_offline_close(m->runtime_journal);
 
        ordered_hashmap_free(m->user_journals);
 
        sd_varlink_server_unref(m->varlink_server);
 
        sd_event_source_unref(m->syslog_event_source);
        sd_event_source_unref(m->native_event_source);
        sd_event_source_unref(m->stdout_event_source);
        sd_event_source_unref(m->dev_kmsg_event_source);
        sd_event_source_unref(m->audit_event_source);
        sd_event_source_unref(m->sync_event_source);
        sd_event_source_unref(m->sigusr1_event_source);
        sd_event_source_unref(m->sigusr2_event_source);
        sd_event_source_unref(m->sigterm_event_source);
        sd_event_source_unref(m->sigint_event_source);
        sd_event_source_unref(m->sigrtmin1_event_source);
        sd_event_source_unref(m->hostname_event_source);
        sd_event_source_unref(m->notify_event_source);
        sd_event_source_unref(m->watchdog_event_source);
        sd_event_source_unref(m->idle_event_source);
        sd_event_unref(m->event);
 
        safe_close(m->syslog_fd);
        safe_close(m->native_fd);
        safe_close(m->stdout_fd);
        safe_close(m->dev_kmsg_fd);
        safe_close(m->audit_fd);
        safe_close(m->hostname_fd);
        safe_close(m->notify_fd);
        safe_close(m->forward_socket_fd);
 
        ordered_hashmap_free(m->ratelimit_groups_by_id);
 
        manager_unmap_seqnum_file(m->seqnum, sizeof(*m->seqnum));
        manager_close_kernel_seqnum(m);
 
        free(m->buffer);
        free(m->cgroup_root);
        free(m->hostname_field);
        free(m->runtime_storage.path);
        free(m->system_storage.path);
        free(m->runtime_directory);
 
        mmap_cache_unref(m->mmap);
 
        SyncReq *req;
        while ((req = prioq_peek(m->sync_req_realtime_prioq)))
                sync_req_free(req);
        prioq_free(m->sync_req_realtime_prioq);
 
        while ((req = prioq_peek(m->sync_req_boottime_prioq)))
                sync_req_free(req);
        prioq_free(m->sync_req_boottime_prioq);
 
        journal_config_done(&m->config);
        journal_config_done(&m->config_by_cred);
        journal_config_done(&m->config_by_conf);
        journal_config_done(&m->config_by_cmdline);
 
        return mfree(m);
}