From: Lennart Poettering Date: Wed, 14 May 2025 09:00:53 +0000 (+0200) Subject: journald: rename primary object from "Server" to "Manager" X-Git-Tag: v258-rc1~628 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=c55f87062d9a1bee287dcaa7321188c79d7185a5;p=thirdparty%2Fsystemd.git journald: rename primary object from "Server" to "Manager" In all our daemons the primary entrypoint object is called "Manager". But so far there was one exception: in journald it was called "Server". Let's normalize that, and stick to the same nomenclature everywhere, to make journald less special. No real code change, just some search&replace. --- diff --git a/src/journal/fuzz-journald-audit.c b/src/journal/fuzz-journald-audit.c index 3e08ce3b4ae..059becc04fe 100644 --- a/src/journal/fuzz-journald-audit.c +++ b/src/journal/fuzz-journald-audit.c @@ -5,13 +5,13 @@ #include "journald-audit.h" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { - _cleanup_(server_freep) Server *s = NULL; + _cleanup_(manager_freep) Manager *m = NULL; fuzz_setup_logging(); - assert_se(server_new(&s) >= 0); - dummy_server_init(s, data, size); - process_audit_string(s, 0, s->buffer, size); + assert_se(manager_new(&m) >= 0); + dummy_manager_init(m, data, size); + process_audit_string(m, 0, m->buffer, size); return 0; } diff --git a/src/journal/fuzz-journald-kmsg.c b/src/journal/fuzz-journald-kmsg.c index 1a19f508e8e..9c65bcf1776 100644 --- a/src/journal/fuzz-journald-kmsg.c +++ b/src/journal/fuzz-journald-kmsg.c @@ -5,16 +5,16 @@ #include "journald-kmsg.h" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { - _cleanup_(server_freep) Server *s = NULL; + _cleanup_(manager_freep) Manager *m = NULL; if (size == 0) return 0; fuzz_setup_logging(); - assert_se(server_new(&s) >= 0); - dummy_server_init(s, data, size); - dev_kmsg_record(s, s->buffer, size); + assert_se(manager_new(&m) >= 0); + dummy_manager_init(m, data, size); + dev_kmsg_record(m, m->buffer, size); return 0; } diff --git a/src/journal/fuzz-journald-native-fd.c b/src/journal/fuzz-journald-native-fd.c index d3e1d0bc1aa..f970acb6232 100644 --- a/src/journal/fuzz-journald-native-fd.c +++ b/src/journal/fuzz-journald-native-fd.c @@ -10,7 +10,7 @@ #include "tmpfile-util.h" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { - _cleanup_(server_freep) Server *s = NULL; + _cleanup_(manager_freep) Manager *m = NULL; _cleanup_close_ int sealed_fd = -EBADF, unsealed_fd = -EBADF; _cleanup_(unlink_tempfilep) char name[] = "/tmp/fuzz-journald-native-fd.XXXXXX"; char *label = NULL; @@ -20,8 +20,8 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { fuzz_setup_logging(); - assert_se(server_new(&s) >= 0); - dummy_server_init(s, NULL, 0); + assert_se(manager_new(&m) >= 0); + dummy_manager_init(m, NULL, 0); sealed_fd = memfd_new_and_seal(NULL, data, size); assert_se(sealed_fd >= 0); @@ -30,13 +30,13 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { .uid = geteuid(), .gid = getegid(), }; - (void) server_process_native_file(s, sealed_fd, &ucred, tv, label, label_len); + (void) manager_process_native_file(m, sealed_fd, &ucred, tv, label, label_len); unsealed_fd = mkostemp_safe(name); assert_se(unsealed_fd >= 0); assert_se(write(unsealed_fd, data, size) == (ssize_t) size); assert_se(lseek(unsealed_fd, 0, SEEK_SET) == 0); - (void) server_process_native_file(s, unsealed_fd, &ucred, tv, label, label_len); + (void) manager_process_native_file(m, unsealed_fd, &ucred, tv, label, label_len); return 0; } diff --git a/src/journal/fuzz-journald-native.c b/src/journal/fuzz-journald-native.c index 6738d26e97f..2aa491df137 100644 --- a/src/journal/fuzz-journald-native.c +++ b/src/journal/fuzz-journald-native.c @@ -7,6 +7,6 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { fuzz_setup_logging(); - fuzz_journald_processing_function(data, size, server_process_native_message); + fuzz_journald_processing_function(data, size, manager_process_native_message); return 0; } diff --git a/src/journal/fuzz-journald-stream.c b/src/journal/fuzz-journald-stream.c index f9c6bfba10f..cc79ed31bcd 100644 --- a/src/journal/fuzz-journald-stream.c +++ b/src/journal/fuzz-journald-stream.c @@ -11,7 +11,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { _cleanup_close_pair_ int stream_fds[2] = EBADF_PAIR; - _cleanup_(server_freep) Server *s = NULL; + _cleanup_(manager_freep) Manager *m = NULL; StdoutStream *stream; int v, fd0; @@ -21,17 +21,17 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { fuzz_setup_logging(); assert_se(socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0, stream_fds) >= 0); - assert_se(server_new(&s) >= 0); - dummy_server_init(s, NULL, 0); + assert_se(manager_new(&m) >= 0); + dummy_manager_init(m, NULL, 0); - assert_se(stdout_stream_install(s, stream_fds[0], &stream) >= 0); + assert_se(stdout_stream_install(m, stream_fds[0], &stream) >= 0); fd0 = TAKE_FD(stream_fds[0]); /* avoid double close */ assert_se(write(stream_fds[1], data, size) == (ssize_t) size); while (ioctl(fd0, SIOCINQ, &v) == 0 && v) - sd_event_run(s->event, UINT64_MAX); + sd_event_run(m->event, UINT64_MAX); - if (s->n_stdout_streams > 0) + if (m->n_stdout_streams > 0) stdout_stream_terminate(stream); return 0; diff --git a/src/journal/fuzz-journald-syslog.c b/src/journal/fuzz-journald-syslog.c index b3e2d3c09cb..a48ce88ac54 100644 --- a/src/journal/fuzz-journald-syslog.c +++ b/src/journal/fuzz-journald-syslog.c @@ -7,6 +7,6 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { fuzz_setup_logging(); - fuzz_journald_processing_function(data, size, server_process_syslog_message); + fuzz_journald_processing_function(data, size, manager_process_syslog_message); return 0; } diff --git a/src/journal/fuzz-journald.c b/src/journal/fuzz-journald.c index 86e41d3cb73..5c2953dbdc2 100644 --- a/src/journal/fuzz-journald.c +++ b/src/journal/fuzz-journald.c @@ -4,27 +4,27 @@ #include "alloc-util.h" #include "fuzz-journald.h" -#include "journald-server.h" +#include "journald-manager.h" -void dummy_server_init(Server *s, const uint8_t *buffer, size_t size) { - assert(s); +void dummy_manager_init(Manager *m, const uint8_t *buffer, size_t size) { + assert(m); - s->storage = STORAGE_NONE; - assert_se(sd_event_default(&s->event) >= 0); + m->storage = STORAGE_NONE; + assert_se(sd_event_default(&m->event) >= 0); if (buffer) { - s->buffer = memdup_suffix0(buffer, size); - assert_se(s->buffer); + m->buffer = memdup_suffix0(buffer, size); + assert_se(m->buffer); } } void fuzz_journald_processing_function( const uint8_t *data, size_t size, - void (*f)(Server *s, const char *buf, size_t raw_len, const struct ucred *ucred, const struct timeval *tv, const char *label, size_t label_len) + void (*f)(Manager *m, const char *buf, size_t raw_len, const struct ucred *ucred, const struct timeval *tv, const char *label, size_t label_len) ) { - _cleanup_(server_freep) Server *s = NULL; + _cleanup_(manager_freep) Manager *m = NULL; char *label = NULL; size_t label_len = 0; struct ucred *ucred = NULL; @@ -33,7 +33,7 @@ void fuzz_journald_processing_function( if (size == 0) return; - assert_se(server_new(&s) >= 0); - dummy_server_init(s, data, size); - (*f)(s, s->buffer, size, ucred, tv, label, label_len); + assert_se(manager_new(&m) >= 0); + dummy_manager_init(m, data, size); + (*f)(m, m->buffer, size, ucred, tv, label, label_len); } diff --git a/src/journal/fuzz-journald.h b/src/journal/fuzz-journald.h index 4abb1005ca3..0d1ebce50a7 100644 --- a/src/journal/fuzz-journald.h +++ b/src/journal/fuzz-journald.h @@ -1,12 +1,12 @@ /* SPDX-License-Identifier: LGPL-2.1-or-later */ #pragma once -#include "journald-server.h" +#include "journald-manager.h" -void dummy_server_init(Server *s, const uint8_t *buffer, size_t size); +void dummy_manager_init(Manager *m, const uint8_t *buffer, size_t size); void fuzz_journald_processing_function( const uint8_t *data, size_t size, - void (*f)(Server *s, const char *buf, size_t raw_len, const struct ucred *ucred, const struct timeval *tv, const char *label, size_t label_len) + void (*f)(Manager *m, const char *buf, size_t raw_len, const struct ucred *ucred, const struct timeval *tv, const char *label, size_t label_len) ); diff --git a/src/journal/journald-audit.c b/src/journal/journald-audit.c index 05c40a7885a..fb04074fdc1 100644 --- a/src/journal/journald-audit.c +++ b/src/journal/journald-audit.c @@ -10,7 +10,7 @@ #include "iovec-util.h" #include "journal-internal.h" #include "journald-audit.h" -#include "journald-server.h" +#include "journald-manager.h" #include "missing_audit.h" #include "string-util.h" @@ -332,17 +332,17 @@ static int map_all_fields( } } -void process_audit_string(Server *s, int type, const char *data, size_t size) { +void process_audit_string(Manager *m, int type, const char *data, size_t size) { size_t n = 0, z; uint64_t seconds, msec, id; const char *p, *type_name; char id_field[STRLEN("_AUDIT_ID=") + DECIMAL_STR_MAX(uint64_t)], type_field[STRLEN("_AUDIT_TYPE=") + DECIMAL_STR_MAX(int)]; struct iovec iovec[N_IOVEC_META_FIELDS + 7 + N_IOVEC_AUDIT_FIELDS]; - char *m, *type_field_name; + char *mm, *type_field_name; int k; - assert(s); + assert(m); if (size <= 0) return; @@ -390,16 +390,16 @@ void process_audit_string(Server *s, int type, const char *data, size_t size) { type_field_name = strjoina("_AUDIT_TYPE_NAME=", type_name); iovec[n++] = IOVEC_MAKE_STRING(type_field_name); - m = strjoina("MESSAGE=", type_name, " ", p); - iovec[n++] = IOVEC_MAKE_STRING(m); + mm = strjoina("MESSAGE=", type_name, " ", p); + iovec[n++] = IOVEC_MAKE_STRING(mm); z = n; map_all_fields(p, map_fields_kernel, "_AUDIT_FIELD_", true, iovec, &n, n + N_IOVEC_AUDIT_FIELDS); - server_dispatch_message(s, iovec, n, ELEMENTSOF(iovec), NULL, - TIMEVAL_STORE((usec_t) seconds * USEC_PER_SEC + (usec_t) msec * USEC_PER_MSEC), - LOG_NOTICE, 0); + manager_dispatch_message(m, iovec, n, ELEMENTSOF(iovec), NULL, + TIMEVAL_STORE((usec_t) seconds * USEC_PER_SEC + (usec_t) msec * USEC_PER_MSEC), + LOG_NOTICE, 0); /* free() all entries that map_all_fields() added. All others * are allocated on the stack or are constant. */ @@ -408,8 +408,8 @@ void process_audit_string(Server *s, int type, const char *data, size_t size) { free(iovec[z].iov_base); } -void server_process_audit_message( - Server *s, +void manager_process_audit_message( + Manager *m, const void *buffer, size_t buffer_size, const struct ucred *ucred, @@ -418,7 +418,7 @@ void server_process_audit_message( const struct nlmsghdr *nl = buffer; - assert(s); + assert(m); if (buffer_size < ALIGN(sizeof(struct nlmsghdr))) return; @@ -452,7 +452,7 @@ void server_process_audit_message( if (nl->nlmsg_type < AUDIT_FIRST_USER_MSG && nl->nlmsg_type != AUDIT_USER) return; - process_audit_string(s, nl->nlmsg_type, NLMSG_DATA(nl), nl->nlmsg_len - ALIGN(sizeof(struct nlmsghdr))); + process_audit_string(m, nl->nlmsg_type, NLMSG_DATA(nl), nl->nlmsg_len - ALIGN(sizeof(struct nlmsghdr))); } static int enable_audit(int fd, bool b) { @@ -500,18 +500,18 @@ static int enable_audit(int fd, bool b) { return 0; } -int server_open_audit(Server *s) { +int manager_open_audit(Manager *m) { int r; - if (s->audit_fd < 0) { + if (m->audit_fd < 0) { static const union sockaddr_union sa = { .nl.nl_family = AF_NETLINK, .nl.nl_pid = 0, .nl.nl_groups = AUDIT_NLGRP_READLOG, }; - s->audit_fd = socket(AF_NETLINK, SOCK_RAW|SOCK_CLOEXEC|SOCK_NONBLOCK, NETLINK_AUDIT); - if (s->audit_fd < 0) { + m->audit_fd = socket(AF_NETLINK, SOCK_RAW|SOCK_CLOEXEC|SOCK_NONBLOCK, NETLINK_AUDIT); + if (m->audit_fd < 0) { if (ERRNO_IS_NOT_SUPPORTED(errno)) log_debug("Audit not supported in the kernel."); else @@ -520,31 +520,31 @@ int server_open_audit(Server *s) { return 0; } - if (bind(s->audit_fd, &sa.sa, sizeof(sa.nl)) < 0) { + if (bind(m->audit_fd, &sa.sa, sizeof(sa.nl)) < 0) { log_warning_errno(errno, "Failed to join audit multicast group. " "The kernel is probably too old or multicast reading is not supported. " "Ignoring: %m"); - s->audit_fd = safe_close(s->audit_fd); + m->audit_fd = safe_close(m->audit_fd); return 0; } } else - (void) fd_nonblock(s->audit_fd, true); + (void) fd_nonblock(m->audit_fd, true); - r = setsockopt_int(s->audit_fd, SOL_SOCKET, SO_PASSCRED, true); + r = setsockopt_int(m->audit_fd, SOL_SOCKET, SO_PASSCRED, true); if (r < 0) return log_error_errno(r, "Failed to set SO_PASSCRED on audit socket: %m"); - r = sd_event_add_io(s->event, &s->audit_event_source, s->audit_fd, EPOLLIN, server_process_datagram, s); + r = sd_event_add_io(m->event, &m->audit_event_source, m->audit_fd, EPOLLIN, manager_process_datagram, m); if (r < 0) return log_error_errno(r, "Failed to add audit fd to event loop: %m"); - if (s->set_audit >= 0) { + if (m->set_audit >= 0) { /* We are listening now, try to enable audit if configured so */ - r = enable_audit(s->audit_fd, s->set_audit); + r = enable_audit(m->audit_fd, m->set_audit); if (r < 0) log_warning_errno(r, "Failed to issue audit enable call: %m"); - else if (s->set_audit > 0) + else if (m->set_audit > 0) log_debug("Auditing in kernel turned on."); else log_debug("Auditing in kernel turned off."); diff --git a/src/journal/journald-audit.h b/src/journal/journald-audit.h index 49223dbf4ac..754bf488bc8 100644 --- a/src/journal/journald-audit.h +++ b/src/journal/journald-audit.h @@ -3,10 +3,10 @@ #include "socket-util.h" -typedef struct Server Server; +typedef struct Manager Manager; -void server_process_audit_message(Server *s, const void *buffer, size_t buffer_size, const struct ucred *ucred, const union sockaddr_union *sa, socklen_t salen); +void manager_process_audit_message(Manager *m, const void *buffer, size_t buffer_size, const struct ucred *ucred, const union sockaddr_union *sa, socklen_t salen); -void process_audit_string(Server *s, int type, const char *data, size_t size); +void process_audit_string(Manager *m, int type, const char *data, size_t size); -int server_open_audit(Server *s); +int manager_open_audit(Manager *m); diff --git a/src/journal/journald-console.c b/src/journal/journald-console.c index dfa4096a91c..19ccec1ab5a 100644 --- a/src/journal/journald-console.c +++ b/src/journal/journald-console.c @@ -10,7 +10,7 @@ #include "format-util.h" #include "iovec-util.h" #include "journald-console.h" -#include "journald-server.h" +#include "journald-manager.h" #include "parse-util.h" #include "process-util.h" #include "stdio-util.h" @@ -31,8 +31,8 @@ static bool prefix_timestamp(void) { return cached_printk_time; } -void server_forward_console( - Server *s, +void manager_forward_console( + Manager *m, int priority, const char *identifier, const char *message, @@ -47,10 +47,10 @@ void server_forward_console( const char *tty, *color_on = "", *color_off = ""; int n = 0; - assert(s); + assert(m); assert(message); - if (LOG_PRI(priority) > s->max_level_console) + if (LOG_PRI(priority) > m->max_level_console) return; /* First: timestamp */ @@ -89,7 +89,7 @@ void server_forward_console( iovec[n++] = IOVEC_MAKE_STRING(color_off); iovec[n++] = IOVEC_MAKE_STRING("\n"); - tty = s->tty_path ?: "/dev/console"; + tty = m->tty_path ?: "/dev/console"; /* Before you ask: yes, on purpose we open/close the console for each log line we write individually. This is a * good strategy to avoid journald getting killed by the kernel's SAK concept (it doesn't fix this entirely, diff --git a/src/journal/journald-console.h b/src/journal/journald-console.h index a4894ce4a5a..7830a0401e2 100644 --- a/src/journal/journald-console.h +++ b/src/journal/journald-console.h @@ -3,6 +3,6 @@ #include -typedef struct Server Server; +typedef struct Manager Manager; -void server_forward_console(Server *s, int priority, const char *identifier, const char *message, const struct ucred *ucred); +void manager_forward_console(Manager *m, int priority, const char *identifier, const char *message, const struct ucred *ucred); diff --git a/src/journal/journald-context.c b/src/journal/journald-context.c index 79e52be2799..cb80e925089 100644 --- a/src/journal/journald-context.c +++ b/src/journal/journald-context.c @@ -16,7 +16,7 @@ #include "journal-util.h" #include "journald-client.h" #include "journald-context.h" -#include "journald-server.h" +#include "journald-manager.h" #include "parse-util.h" #include "path-util.h" #include "process-util.h" @@ -104,15 +104,15 @@ static int client_context_compare(const void *a, const void *b) { return CMP(x->pid, y->pid); } -static int client_context_new(Server *s, pid_t pid, ClientContext **ret) { +static int client_context_new(Manager *m, pid_t pid, ClientContext **ret) { _cleanup_free_ ClientContext *c = NULL; int r; - assert(s); + assert(m); assert(pid_is_valid(pid)); assert(ret); - r = prioq_ensure_allocated(&s->client_contexts_lru, client_context_compare); + r = prioq_ensure_allocated(&m->client_contexts_lru, client_context_compare); if (r < 0) return r; @@ -131,12 +131,12 @@ static int client_context_new(Server *s, pid_t pid, ClientContext **ret) { .timestamp = USEC_INFINITY, .extra_fields_mtime = NSEC_INFINITY, .log_level_max = -1, - .log_ratelimit_interval = s->ratelimit_interval, - .log_ratelimit_burst = s->ratelimit_burst, + .log_ratelimit_interval = m->ratelimit_interval, + .log_ratelimit_burst = m->ratelimit_burst, .capability_quintet = CAPABILITY_QUINTET_NULL, }; - r = hashmap_ensure_put(&s->client_contexts, NULL, PID_TO_PTR(pid), c); + r = hashmap_ensure_put(&m->client_contexts, NULL, PID_TO_PTR(pid), c); if (r < 0) return r; @@ -144,8 +144,8 @@ static int client_context_new(Server *s, pid_t pid, ClientContext **ret) { return 0; } -static void client_context_reset(Server *s, ClientContext *c) { - assert(s); +static void client_context_reset(Manager *m, ClientContext *c) { + assert(m); assert(c); c->timestamp = USEC_INFINITY; @@ -180,8 +180,8 @@ static void client_context_reset(Server *s, ClientContext *c) { c->log_level_max = -1; - c->log_ratelimit_interval = s->ratelimit_interval; - c->log_ratelimit_burst = s->ratelimit_burst; + c->log_ratelimit_interval = m->ratelimit_interval; + c->log_ratelimit_burst = m->ratelimit_burst; c->log_filter_allowed_patterns = set_free(c->log_filter_allowed_patterns); c->log_filter_denied_patterns = set_free(c->log_filter_denied_patterns); @@ -189,18 +189,18 @@ static void client_context_reset(Server *s, ClientContext *c) { c->capability_quintet = CAPABILITY_QUINTET_NULL; } -static ClientContext* client_context_free(Server *s, ClientContext *c) { - assert(s); +static ClientContext* client_context_free(Manager *m, ClientContext *c) { + assert(m); if (!c) return NULL; - assert_se(hashmap_remove(s->client_contexts, PID_TO_PTR(c->pid)) == c); + assert_se(hashmap_remove(m->client_contexts, PID_TO_PTR(c->pid)) == c); if (c->in_lru) - assert_se(prioq_remove(s->client_contexts_lru, c, &c->lru_index) >= 0); + assert_se(prioq_remove(m->client_contexts_lru, c, &c->lru_index) >= 0); - client_context_reset(s, c); + client_context_reset(m, c); return mfree(c); } @@ -275,14 +275,14 @@ static int client_context_read_label( return 0; } -static int client_context_read_cgroup(Server *s, ClientContext *c, const char *unit_id) { +static int client_context_read_cgroup(Manager *m, ClientContext *c, const char *unit_id) { _cleanup_free_ char *t = NULL; int r; assert(c); /* Try to acquire the current cgroup path */ - r = cg_pid_get_path_shifted(c->pid, s->cgroup_root, &t); + r = cg_pid_get_path_shifted(c->pid, m->cgroup_root, &t); if (r < 0 || empty_or_root(t)) { /* We use the unit ID passed in as fallback if we have nothing cached yet and cg_pid_get_path_shifted() * failed or process is running in a root cgroup. Zombie processes are automatically migrated to root cgroup @@ -326,13 +326,13 @@ static int client_context_read_cgroup(Server *s, ClientContext *c, const char *u } static int client_context_read_invocation_id( - Server *s, + Manager *m, ClientContext *c) { _cleanup_free_ char *p = NULL, *value = NULL; int r; - assert(s); + assert(m); assert(c); /* Read the invocation ID of a unit off a unit. @@ -360,7 +360,7 @@ static int client_context_read_invocation_id( } static int client_context_read_log_level_max( - Server *s, + Manager *m, ClientContext *c) { _cleanup_free_ char *value = NULL; @@ -384,7 +384,7 @@ static int client_context_read_log_level_max( } static int client_context_read_extra_fields( - Server *s, + Manager *m, ClientContext *c) { _cleanup_free_ struct iovec *iovec = NULL; @@ -510,14 +510,14 @@ static int client_context_read_log_ratelimit_burst(ClientContext *c) { } static void client_context_really_refresh( - Server *s, + Manager *m, ClientContext *c, const struct ucred *ucred, const char *label, size_t label_size, const char *unit_id, usec_t timestamp) { - assert(s); + assert(m); assert(c); assert(pid_is_valid(c->pid)); @@ -531,10 +531,10 @@ static void client_context_really_refresh( (void) audit_session_from_pid(&PIDREF_MAKE_FROM_PID(c->pid), &c->auditid); (void) audit_loginuid_from_pid(&PIDREF_MAKE_FROM_PID(c->pid), &c->loginuid); - (void) client_context_read_cgroup(s, c, unit_id); - (void) client_context_read_invocation_id(s, c); - (void) client_context_read_log_level_max(s, c); - (void) client_context_read_extra_fields(s, c); + (void) client_context_read_cgroup(m, c, unit_id); + (void) client_context_read_invocation_id(m, c); + (void) client_context_read_log_level_max(m, c); + (void) client_context_read_extra_fields(m, c); (void) client_context_read_log_ratelimit_interval(c); (void) client_context_read_log_ratelimit_burst(c); @@ -542,19 +542,19 @@ static void client_context_really_refresh( if (c->in_lru) { assert(c->n_ref == 0); - prioq_reshuffle(s->client_contexts_lru, c, &c->lru_index); + prioq_reshuffle(m->client_contexts_lru, c, &c->lru_index); } } void client_context_maybe_refresh( - Server *s, + Manager *m, ClientContext *c, const struct ucred *ucred, const char *label, size_t label_size, const char *unit_id, usec_t timestamp) { - assert(s); + assert(m); assert(c); if (timestamp == USEC_INFINITY) @@ -567,7 +567,7 @@ void client_context_maybe_refresh( /* If the data isn't pinned and if the cashed data is older than the upper limit, we flush it out * entirely. This follows the logic that as long as an entry is pinned the PID reuse is unlikely. */ if (c->n_ref == 0 && c->timestamp + MAX_USEC < timestamp) { - client_context_reset(s, c); + client_context_reset(m, c); goto refresh; } @@ -588,44 +588,44 @@ void client_context_maybe_refresh( return; refresh: - client_context_really_refresh(s, c, ucred, label, label_size, unit_id, timestamp); + client_context_really_refresh(m, c, ucred, label, label_size, unit_id, timestamp); } -static void client_context_try_shrink_to(Server *s, size_t limit) { +static void client_context_try_shrink_to(Manager *m, size_t limit) { ClientContext *c; usec_t t; - assert(s); + assert(m); /* Flush any cache entries for PIDs that have already moved on. Don't do this * too often, since it's a slow process. */ t = now(CLOCK_MONOTONIC); - if (s->last_cache_pid_flush + MAX_USEC < t) { - unsigned n = prioq_size(s->client_contexts_lru), idx = 0; + if (m->last_cache_pid_flush + MAX_USEC < t) { + unsigned n = prioq_size(m->client_contexts_lru), idx = 0; /* We do a number of iterations based on the initial size of the prioq. When we remove an * item, a new item is moved into its places, and items to the right might be reshuffled. */ for (unsigned i = 0; i < n; i++) { - c = prioq_peek_by_index(s->client_contexts_lru, idx); + c = prioq_peek_by_index(m->client_contexts_lru, idx); assert(c->n_ref == 0); if (pid_is_unwaited(c->pid) == 0) - client_context_free(s, c); + client_context_free(m, c); else idx++; } - s->last_cache_pid_flush = t; + m->last_cache_pid_flush = t; } /* Bring the number of cache entries below the indicated limit, so that we can create a new entry without * breaching the limit. Note that we only flush out entries that aren't pinned here. This means the number of * cache entries may very well grow beyond the limit, if all entries stored remain pinned. */ - while (hashmap_size(s->client_contexts) > limit) { - c = prioq_pop(s->client_contexts_lru); + while (hashmap_size(m->client_contexts) > limit) { + c = prioq_pop(m->client_contexts_lru); if (!c) break; /* All remaining entries are pinned, give up */ @@ -634,33 +634,33 @@ static void client_context_try_shrink_to(Server *s, size_t limit) { c->in_lru = false; - client_context_free(s, c); + client_context_free(m, c); } } -void client_context_flush_regular(Server *s) { - client_context_try_shrink_to(s, 0); +void client_context_flush_regular(Manager *m) { + client_context_try_shrink_to(m, 0); } -void client_context_flush_all(Server *s) { - assert(s); +void client_context_flush_all(Manager *m) { + assert(m); /* Flush out all remaining entries. This assumes all references are already dropped. */ - s->my_context = client_context_release(s, s->my_context); - s->pid1_context = client_context_release(s, s->pid1_context); + m->my_context = client_context_release(m, m->my_context); + m->pid1_context = client_context_release(m, m->pid1_context); - client_context_flush_regular(s); + client_context_flush_regular(m); - assert(prioq_isempty(s->client_contexts_lru)); - assert(hashmap_isempty(s->client_contexts)); + assert(prioq_isempty(m->client_contexts_lru)); + assert(hashmap_isempty(m->client_contexts)); - s->client_contexts_lru = prioq_free(s->client_contexts_lru); - s->client_contexts = hashmap_free(s->client_contexts); + m->client_contexts_lru = prioq_free(m->client_contexts_lru); + m->client_contexts = hashmap_free(m->client_contexts); } static int client_context_get_internal( - Server *s, + Manager *m, pid_t pid, const struct ucred *ucred, const char *label, size_t label_len, @@ -671,80 +671,80 @@ static int client_context_get_internal( ClientContext *c; int r; - assert(s); + assert(m); assert(ret); if (!pid_is_valid(pid)) return -EINVAL; - c = hashmap_get(s->client_contexts, PID_TO_PTR(pid)); + c = hashmap_get(m->client_contexts, PID_TO_PTR(pid)); if (c) { if (add_ref) { if (c->in_lru) { /* The entry wasn't pinned so far, let's remove it from the LRU list then */ assert(c->n_ref == 0); - assert_se(prioq_remove(s->client_contexts_lru, c, &c->lru_index) >= 0); + assert_se(prioq_remove(m->client_contexts_lru, c, &c->lru_index) >= 0); c->in_lru = false; } c->n_ref++; } - client_context_maybe_refresh(s, c, ucred, label, label_len, unit_id, USEC_INFINITY); + client_context_maybe_refresh(m, c, ucred, label, label_len, unit_id, USEC_INFINITY); *ret = c; return 0; } - client_context_try_shrink_to(s, cache_max()-1); + client_context_try_shrink_to(m, cache_max()-1); - r = client_context_new(s, pid, &c); + r = client_context_new(m, pid, &c); if (r < 0) return r; if (add_ref) c->n_ref++; else { - r = prioq_put(s->client_contexts_lru, c, &c->lru_index); + r = prioq_put(m->client_contexts_lru, c, &c->lru_index); if (r < 0) { - client_context_free(s, c); + client_context_free(m, c); return r; } c->in_lru = true; } - client_context_really_refresh(s, c, ucred, label, label_len, unit_id, USEC_INFINITY); + client_context_really_refresh(m, c, ucred, label, label_len, unit_id, USEC_INFINITY); *ret = c; return 0; } int client_context_get( - Server *s, + Manager *m, pid_t pid, const struct ucred *ucred, const char *label, size_t label_len, const char *unit_id, ClientContext **ret) { - return client_context_get_internal(s, pid, ucred, label, label_len, unit_id, false, ret); + return client_context_get_internal(m, pid, ucred, label, label_len, unit_id, false, ret); } int client_context_acquire( - Server *s, + Manager *m, pid_t pid, const struct ucred *ucred, const char *label, size_t label_len, const char *unit_id, ClientContext **ret) { - return client_context_get_internal(s, pid, ucred, label, label_len, unit_id, true, ret); + return client_context_get_internal(m, pid, ucred, label, label_len, unit_id, true, ret); }; -ClientContext *client_context_release(Server *s, ClientContext *c) { - assert(s); +ClientContext *client_context_release(Manager *m, ClientContext *c) { + assert(m); if (!c) return NULL; @@ -759,40 +759,40 @@ ClientContext *client_context_release(Server *s, ClientContext *c) { /* The entry is not pinned anymore, let's add it to the LRU prioq if we can. If we can't we'll drop it * right-away */ - if (prioq_put(s->client_contexts_lru, c, &c->lru_index) < 0) - client_context_free(s, c); + if (prioq_put(m->client_contexts_lru, c, &c->lru_index) < 0) + client_context_free(m, c); else c->in_lru = true; return NULL; } -void client_context_acquire_default(Server *s) { +void client_context_acquire_default(Manager *m) { int r; - assert(s); + assert(m); /* Ensure that our own and PID1's contexts are always pinned. Our own context is particularly useful to * generate driver messages. */ - if (!s->my_context) { + if (!m->my_context) { struct ucred ucred = { .pid = getpid_cached(), .uid = getuid(), .gid = getgid(), }; - r = client_context_acquire(s, ucred.pid, &ucred, NULL, 0, NULL, &s->my_context); + r = client_context_acquire(m, ucred.pid, &ucred, NULL, 0, NULL, &m->my_context); if (r < 0) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, "Failed to acquire our own context, ignoring: %m"); } - if (!s->namespace && !s->pid1_context) { + if (!m->namespace && !m->pid1_context) { /* Acquire PID1's context, but only if we are in non-namespaced mode, since PID 1 is only * going to log to the non-namespaced journal instance. */ - r = client_context_acquire(s, 1, NULL, NULL, 0, NULL, &s->pid1_context); + r = client_context_acquire(m, 1, NULL, NULL, 0, NULL, &m->pid1_context); if (r < 0) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, "Failed to acquire PID1's context, ignoring: %m"); diff --git a/src/journal/journald-context.h b/src/journal/journald-context.h index e908540eb4a..c784378b85c 100644 --- a/src/journal/journald-context.h +++ b/src/journal/journald-context.h @@ -12,7 +12,7 @@ #include "set.h" #include "time-util.h" -typedef struct Server Server; +typedef struct Manager Manager; typedef struct ClientContext { unsigned n_ref; @@ -62,7 +62,7 @@ typedef struct ClientContext { } ClientContext; int client_context_get( - Server *s, + Manager *m, pid_t pid, const struct ucred *ucred, const char *label, size_t label_len, @@ -70,26 +70,26 @@ int client_context_get( ClientContext **ret); int client_context_acquire( - Server *s, + Manager *m, pid_t pid, const struct ucred *ucred, const char *label, size_t label_len, const char *unit_id, ClientContext **ret); -ClientContext* client_context_release(Server *s, ClientContext *c); +ClientContext* client_context_release(Manager *m, ClientContext *c); void client_context_maybe_refresh( - Server *s, + Manager *m, ClientContext *c, const struct ucred *ucred, const char *label, size_t label_size, const char *unit_id, usec_t tstamp); -void client_context_acquire_default(Server *s); -void client_context_flush_all(Server *s); -void client_context_flush_regular(Server *s); +void client_context_acquire_default(Manager *m); +void client_context_flush_all(Manager *m); +void client_context_flush_regular(Manager *m); static inline size_t client_context_extra_fields_n_iovec(const ClientContext *c) { return c ? c->extra_fields_n_iovec : 0; diff --git a/src/journal/journald-gperf.gperf b/src/journal/journald-gperf.gperf index 317cfb64268..b65faa41996 100644 --- a/src/journal/journald-gperf.gperf +++ b/src/journal/journald-gperf.gperf @@ -7,7 +7,7 @@ _Pragma("GCC diagnostic ignored \"-Wzero-as-null-pointer-constant\"") #include #include #include "conf-parser.h" -#include "journald-server.h" +#include "journald-manager.h" %} struct ConfigPerfItem; %null_strings @@ -20,37 +20,37 @@ struct ConfigPerfItem; %struct-type %includes %% -Journal.Storage, config_parse_storage, 0, offsetof(Server, storage) -Journal.Compress, config_parse_compress, 0, offsetof(Server, compress) -Journal.Seal, config_parse_bool, 0, offsetof(Server, seal) -Journal.ReadKMsg, config_parse_bool, 0, offsetof(Server, read_kmsg) -Journal.Audit, config_parse_tristate, 0, offsetof(Server, set_audit) -Journal.SyncIntervalSec, config_parse_sec, 0, offsetof(Server, sync_interval_usec) +Journal.Storage, config_parse_storage, 0, offsetof(Manager, storage) +Journal.Compress, config_parse_compress, 0, offsetof(Manager, compress) +Journal.Seal, config_parse_bool, 0, offsetof(Manager, seal) +Journal.ReadKMsg, config_parse_bool, 0, offsetof(Manager, read_kmsg) +Journal.Audit, config_parse_tristate, 0, offsetof(Manager, set_audit) +Journal.SyncIntervalSec, config_parse_sec, 0, offsetof(Manager, sync_interval_usec) # The following is a legacy name for compatibility -Journal.RateLimitInterval, config_parse_sec, 0, offsetof(Server, ratelimit_interval) -Journal.RateLimitIntervalSec,config_parse_sec, 0, offsetof(Server, ratelimit_interval) -Journal.RateLimitBurst, config_parse_unsigned, 0, offsetof(Server, ratelimit_burst) -Journal.SystemMaxUse, config_parse_iec_uint64, 0, offsetof(Server, system_storage.metrics.max_use) -Journal.SystemMaxFileSize, config_parse_iec_uint64, 0, offsetof(Server, system_storage.metrics.max_size) -Journal.SystemKeepFree, config_parse_iec_uint64, 0, offsetof(Server, system_storage.metrics.keep_free) -Journal.SystemMaxFiles, config_parse_uint64, 0, offsetof(Server, system_storage.metrics.n_max_files) -Journal.RuntimeMaxUse, config_parse_iec_uint64, 0, offsetof(Server, runtime_storage.metrics.max_use) -Journal.RuntimeMaxFileSize, config_parse_iec_uint64, 0, offsetof(Server, runtime_storage.metrics.max_size) -Journal.RuntimeKeepFree, config_parse_iec_uint64, 0, offsetof(Server, runtime_storage.metrics.keep_free) -Journal.RuntimeMaxFiles, config_parse_uint64, 0, offsetof(Server, runtime_storage.metrics.n_max_files) -Journal.MaxRetentionSec, config_parse_sec, 0, offsetof(Server, max_retention_usec) -Journal.MaxFileSec, config_parse_sec, 0, offsetof(Server, max_file_usec) -Journal.ForwardToSyslog, config_parse_bool, 0, offsetof(Server, forward_to_syslog) -Journal.ForwardToKMsg, config_parse_bool, 0, offsetof(Server, forward_to_kmsg) -Journal.ForwardToConsole, config_parse_bool, 0, offsetof(Server, forward_to_console) -Journal.ForwardToWall, config_parse_bool, 0, offsetof(Server, forward_to_wall) -Journal.ForwardToSocket, config_parse_forward_to_socket, 0, offsetof(Server, forward_to_socket) -Journal.TTYPath, config_parse_path, 0, offsetof(Server, tty_path) -Journal.MaxLevelStore, config_parse_log_level, 0, offsetof(Server, max_level_store) -Journal.MaxLevelSyslog, config_parse_log_level, 0, offsetof(Server, max_level_syslog) -Journal.MaxLevelKMsg, config_parse_log_level, 0, offsetof(Server, max_level_kmsg) -Journal.MaxLevelConsole, config_parse_log_level, 0, offsetof(Server, max_level_console) -Journal.MaxLevelWall, config_parse_log_level, 0, offsetof(Server, max_level_wall) -Journal.MaxLevelSocket, config_parse_log_level, 0, offsetof(Server, max_level_socket) -Journal.SplitMode, config_parse_split_mode, 0, offsetof(Server, split_mode) -Journal.LineMax, config_parse_line_max, 0, offsetof(Server, line_max) +Journal.RateLimitInterval, config_parse_sec, 0, offsetof(Manager, ratelimit_interval) +Journal.RateLimitIntervalSec,config_parse_sec, 0, offsetof(Manager, ratelimit_interval) +Journal.RateLimitBurst, config_parse_unsigned, 0, offsetof(Manager, ratelimit_burst) +Journal.SystemMaxUse, config_parse_iec_uint64, 0, offsetof(Manager, system_storage.metrics.max_use) +Journal.SystemMaxFileSize, config_parse_iec_uint64, 0, offsetof(Manager, system_storage.metrics.max_size) +Journal.SystemKeepFree, config_parse_iec_uint64, 0, offsetof(Manager, system_storage.metrics.keep_free) +Journal.SystemMaxFiles, config_parse_uint64, 0, offsetof(Manager, system_storage.metrics.n_max_files) +Journal.RuntimeMaxUse, config_parse_iec_uint64, 0, offsetof(Manager, runtime_storage.metrics.max_use) +Journal.RuntimeMaxFileSize, config_parse_iec_uint64, 0, offsetof(Manager, runtime_storage.metrics.max_size) +Journal.RuntimeKeepFree, config_parse_iec_uint64, 0, offsetof(Manager, runtime_storage.metrics.keep_free) +Journal.RuntimeMaxFiles, config_parse_uint64, 0, offsetof(Manager, runtime_storage.metrics.n_max_files) +Journal.MaxRetentionSec, config_parse_sec, 0, offsetof(Manager, max_retention_usec) +Journal.MaxFileSec, config_parse_sec, 0, offsetof(Manager, max_file_usec) +Journal.ForwardToSyslog, config_parse_bool, 0, offsetof(Manager, forward_to_syslog) +Journal.ForwardToKMsg, config_parse_bool, 0, offsetof(Manager, forward_to_kmsg) +Journal.ForwardToConsole, config_parse_bool, 0, offsetof(Manager, forward_to_console) +Journal.ForwardToWall, config_parse_bool, 0, offsetof(Manager, forward_to_wall) +Journal.ForwardToSocket, config_parse_forward_to_socket, 0, offsetof(Manager, forward_to_socket) +Journal.TTYPath, config_parse_path, 0, offsetof(Manager, tty_path) +Journal.MaxLevelStore, config_parse_log_level, 0, offsetof(Manager, max_level_store) +Journal.MaxLevelSyslog, config_parse_log_level, 0, offsetof(Manager, max_level_syslog) +Journal.MaxLevelKMsg, config_parse_log_level, 0, offsetof(Manager, max_level_kmsg) +Journal.MaxLevelConsole, config_parse_log_level, 0, offsetof(Manager, max_level_console) +Journal.MaxLevelWall, config_parse_log_level, 0, offsetof(Manager, max_level_wall) +Journal.MaxLevelSocket, config_parse_log_level, 0, offsetof(Manager, max_level_socket) +Journal.SplitMode, config_parse_split_mode, 0, offsetof(Manager, split_mode) +Journal.LineMax, config_parse_line_max, 0, offsetof(Manager, line_max) diff --git a/src/journal/journald-kmsg.c b/src/journal/journald-kmsg.c index 767e590b260..bfd32cbdc44 100644 --- a/src/journal/journald-kmsg.c +++ b/src/journal/journald-kmsg.c @@ -18,7 +18,7 @@ #include "iovec-util.h" #include "journal-internal.h" #include "journald-kmsg.h" -#include "journald-server.h" +#include "journald-manager.h" #include "journald-syslog.h" #include "log.h" #include "parse-util.h" @@ -26,8 +26,8 @@ #include "stdio-util.h" #include "string-util.h" -void server_forward_kmsg( - Server *s, +void manager_forward_kmsg( + Manager *m, int priority, const char *identifier, const char *message, @@ -39,15 +39,15 @@ void server_forward_kmsg( header_pid[STRLEN("[]: ") + DECIMAL_STR_MAX(pid_t) + 1]; size_t n = 0; - assert(s); + assert(m); assert(priority >= 0); assert(priority <= 999); assert(message); - if (_unlikely_(LOG_PRI(priority) > s->max_level_kmsg)) + if (_unlikely_(LOG_PRI(priority) > m->max_level_kmsg)) return; - if (_unlikely_(s->dev_kmsg_fd < 0)) + if (_unlikely_(m->dev_kmsg_fd < 0)) return; /* Never allow messages with kernel facility to be written to @@ -79,7 +79,7 @@ void server_forward_kmsg( iovec[n++] = IOVEC_MAKE_STRING(message); iovec[n++] = IOVEC_MAKE_STRING("\n"); - if (writev(s->dev_kmsg_fd, iovec, n) < 0) + if (writev(m->dev_kmsg_fd, iovec, n) < 0) log_debug_errno(errno, "Failed to write to /dev/kmsg for logging, ignoring: %m"); } @@ -96,7 +96,7 @@ static bool is_us(const char *identifier, const char *pid) { streq(identifier, program_invocation_short_name); } -void dev_kmsg_record(Server *s, char *p, size_t l) { +void dev_kmsg_record(Manager *m, char *p, size_t l) { _cleanup_free_ char *message = NULL, *syslog_pid = NULL, *syslog_identifier = NULL, *identifier = NULL, *pid = NULL; struct iovec iovec[N_IOVEC_META_FIELDS + 7 + N_IOVEC_KERNEL_FIELDS + 2 + N_IOVEC_UDEV_FIELDS]; @@ -110,7 +110,7 @@ void dev_kmsg_record(Server *s, char *p, size_t l) { int saved_log_max_level = INT_MAX; ClientContext *c = NULL; - assert(s); + assert(m); assert(p); if (l <= 0) @@ -126,7 +126,7 @@ void dev_kmsg_record(Server *s, char *p, size_t l) { if (r < 0 || priority < 0 || priority > 999) return; - if (s->forward_to_kmsg && LOG_FAC(priority) != LOG_KERN) + if (m->forward_to_kmsg && LOG_FAC(priority) != LOG_KERN) return; /* seqnum */ @@ -141,23 +141,23 @@ void dev_kmsg_record(Server *s, char *p, size_t l) { if (r < 0) return; - if (s->kernel_seqnum) { + if (m->kernel_seqnum) { /* We already read this one? */ - if (serial < *s->kernel_seqnum) + if (serial < *m->kernel_seqnum) return; /* Did we lose any? */ - if (serial > *s->kernel_seqnum) - server_driver_message(s, 0, - LOG_MESSAGE_ID(SD_MESSAGE_JOURNAL_MISSED_STR), - LOG_MESSAGE("Missed %"PRIu64" kernel messages", - serial - *s->kernel_seqnum)); + if (serial > *m->kernel_seqnum) + manager_driver_message(m, 0, + LOG_MESSAGE_ID(SD_MESSAGE_JOURNAL_MISSED_STR), + LOG_MESSAGE("Missed %"PRIu64" kernel messages", + serial - *m->kernel_seqnum)); /* Make sure we never read this one again. Note that * we always store the next message serial we expect * here, simply because this makes handling the first * message with serial 0 easy. */ - *s->kernel_seqnum = serial + 1; + *m->kernel_seqnum = serial + 1; } /* CLOCK_BOOTTIME timestamp */ @@ -192,7 +192,7 @@ void dev_kmsg_record(Server *s, char *p, size_t l) { k = e + 1; for (j = 0; l > 0 && j < N_IOVEC_KERNEL_FIELDS; j++) { - char *m; + char *mm; /* Metadata fields attached */ if (*k != ' ') @@ -206,13 +206,13 @@ void dev_kmsg_record(Server *s, char *p, size_t l) { *e = 0; - if (cunescape_length_with_prefix(k, e - k, "_KERNEL_", UNESCAPE_RELAX, &m) < 0) + if (cunescape_length_with_prefix(k, e - k, "_KERNEL_", UNESCAPE_RELAX, &mm) < 0) break; - if (startswith(m, "_KERNEL_DEVICE=")) - kernel_device = m + 15; + if (startswith(mm, "_KERNEL_DEVICE=")) + kernel_device = mm + 15; - iovec[n++] = IOVEC_MAKE_STRING(m); + iovec[n++] = IOVEC_MAKE_STRING(mm); z++; l -= (e - k) + 1; @@ -287,11 +287,11 @@ void dev_kmsg_record(Server *s, char *p, size_t l) { /* Avoid logging any new messages when we're processing messages generated by ourselves via * log_info() and friends to avoid infinite loops. */ if (is_us(identifier, pid)) { - if (!ratelimit_below(&s->kmsg_own_ratelimit)) + if (!ratelimit_below(&m->kmsg_own_ratelimit)) return; saved_log_max_level = log_get_max_level(); - c = s->my_context; + c = m->my_context; log_set_max_level(LOG_NULL); } @@ -311,28 +311,28 @@ void dev_kmsg_record(Server *s, char *p, size_t l) { if (cunescape_length_with_prefix(p, pl, "MESSAGE=", UNESCAPE_RELAX, &message) >= 0) iovec[n++] = IOVEC_MAKE_STRING(message); - server_dispatch_message(s, iovec, n, ELEMENTSOF(iovec), c, NULL, priority, 0); + manager_dispatch_message(m, iovec, n, ELEMENTSOF(iovec), c, NULL, priority, 0); if (saved_log_max_level != INT_MAX) log_set_max_level(saved_log_max_level); - s->dev_kmsg_timestamp = usec; - sync_req_revalidate_by_timestamp(s); + m->dev_kmsg_timestamp = usec; + sync_req_revalidate_by_timestamp(m); finish: for (j = 0; j < z; j++) free(iovec[j].iov_base); } -static int server_read_dev_kmsg(Server *s) { +static int manager_read_dev_kmsg(Manager *m) { char buffer[8192+1]; /* the kernel-side limit per record is 8K currently */ ssize_t l; - assert(s); - assert(s->dev_kmsg_fd >= 0); - assert(s->read_kmsg); + assert(m); + assert(m->dev_kmsg_fd >= 0); + assert(m->read_kmsg); - l = read(s->dev_kmsg_fd, buffer, sizeof(buffer) - 1); + l = read(m->dev_kmsg_fd, buffer, sizeof(buffer) - 1); if (l == 0) return 0; if (l < 0) { @@ -342,25 +342,25 @@ static int server_read_dev_kmsg(Server *s) { return log_ratelimit_error_errno(errno, JOURNAL_LOG_RATELIMIT, "Failed to read from /dev/kmsg: %m"); } - dev_kmsg_record(s, buffer, l); + dev_kmsg_record(m, buffer, l); return 1; } -int server_flush_dev_kmsg(Server *s) { +int manager_flush_dev_kmsg(Manager *m) { int r; - assert(s); + assert(m); - if (s->dev_kmsg_fd < 0) + if (m->dev_kmsg_fd < 0) return 0; - if (!s->read_kmsg) + if (!m->read_kmsg) return 0; log_debug("Flushing /dev/kmsg..."); for (;;) { - r = server_read_dev_kmsg(s); + r = manager_read_dev_kmsg(m); if (r < 0) return r; @@ -372,10 +372,10 @@ int server_flush_dev_kmsg(Server *s) { } static int dispatch_dev_kmsg(sd_event_source *es, int fd, uint32_t revents, void *userdata) { - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); assert(es); - assert(fd == s->dev_kmsg_fd); + assert(fd == m->dev_kmsg_fd); if (revents & EPOLLERR) log_ratelimit_warning(JOURNAL_LOG_RATELIMIT, @@ -384,17 +384,17 @@ static int dispatch_dev_kmsg(sd_event_source *es, int fd, uint32_t revents, void if (!(revents & EPOLLIN)) log_error("Got invalid event from epoll for /dev/kmsg: %"PRIx32, revents); - return server_read_dev_kmsg(s); + return manager_read_dev_kmsg(m); } -int server_open_dev_kmsg(Server *s) { +int manager_open_dev_kmsg(Manager *m) { int r; - assert(s); - assert(s->dev_kmsg_fd < 0); - assert(!s->dev_kmsg_event_source); + assert(m); + assert(m->dev_kmsg_fd < 0); + assert(!m->dev_kmsg_event_source); - mode_t mode = O_CLOEXEC|O_NONBLOCK|O_NOCTTY|(s->read_kmsg ? O_RDWR : O_WRONLY); + mode_t mode = O_CLOEXEC|O_NONBLOCK|O_NOCTTY|(m->read_kmsg ? O_RDWR : O_WRONLY); _cleanup_close_ int fd = open("/dev/kmsg", mode); if (fd < 0) { @@ -403,13 +403,13 @@ int server_open_dev_kmsg(Server *s) { return 0; } - if (!s->read_kmsg) { - s->dev_kmsg_fd = TAKE_FD(fd); + if (!m->read_kmsg) { + m->dev_kmsg_fd = TAKE_FD(fd); return 0; } _cleanup_(sd_event_source_unrefp) sd_event_source *es = NULL; - r = sd_event_add_io(s->event, &es, fd, EPOLLIN, dispatch_dev_kmsg, s); + r = sd_event_add_io(m->event, &es, fd, EPOLLIN, dispatch_dev_kmsg, m); if (r < 0) return log_error_errno(r, "Failed to add /dev/kmsg fd to event loop: %m"); @@ -417,23 +417,23 @@ int server_open_dev_kmsg(Server *s) { if (r < 0) return log_error_errno(r, "Failed to adjust priority of kmsg event source: %m"); - s->dev_kmsg_fd = TAKE_FD(fd); - s->dev_kmsg_event_source = TAKE_PTR(es); + m->dev_kmsg_fd = TAKE_FD(fd); + m->dev_kmsg_event_source = TAKE_PTR(es); return 0; } -int server_open_kernel_seqnum(Server *s) { +int manager_open_kernel_seqnum(Manager *m) { int r; - assert(s); + assert(m); /* We store the seqnum we last read in an mmapped file. That way we can just use it like a variable, * but it is persistent and automatically flushed at reboot. */ - if (!s->read_kmsg) + if (!m->read_kmsg) return 0; - r = server_map_seqnum_file(s, "kernel-seqnum", sizeof(uint64_t), (void**) &s->kernel_seqnum); + r = manager_map_seqnum_file(m, "kernel-seqnum", sizeof(uint64_t), (void**) &m->kernel_seqnum); if (r < 0) return log_error_errno(r, "Failed to map kernel seqnum file: %m"); diff --git a/src/journal/journald-kmsg.h b/src/journal/journald-kmsg.h index dcbe0b510c2..fa33e897a47 100644 --- a/src/journal/journald-kmsg.h +++ b/src/journal/journald-kmsg.h @@ -4,13 +4,13 @@ #include #include -typedef struct Server Server; +typedef struct Manager Manager; -int server_open_dev_kmsg(Server *s); -int server_flush_dev_kmsg(Server *s); +int manager_open_dev_kmsg(Manager *m); +int manager_flush_dev_kmsg(Manager *m); -void server_forward_kmsg(Server *s, int priority, const char *identifier, const char *message, const struct ucred *ucred); +void manager_forward_kmsg(Manager *m, int priority, const char *identifier, const char *message, const struct ucred *ucred); -int server_open_kernel_seqnum(Server *s); +int manager_open_kernel_seqnum(Manager *m); -void dev_kmsg_record(Server *s, char *p, size_t l); +void dev_kmsg_record(Manager *m, char *p, size_t l); diff --git a/src/journal/journald-server.c b/src/journal/journald-manager.c similarity index 71% rename from src/journal/journald-server.c rename to src/journal/journald-manager.c index 419dc040cb7..3d81808c946 100644 --- a/src/journal/journald-server.c +++ b/src/journal/journald-manager.c @@ -41,9 +41,9 @@ #include "journald-audit.h" #include "journald-context.h" #include "journald-kmsg.h" +#include "journald-manager.h" #include "journald-native.h" #include "journald-rate-limit.h" -#include "journald-server.h" #include "journald-socket.h" #include "journald-stream.h" #include "journald-syslog.h" @@ -95,11 +95,11 @@ #define FAILED_TO_WRITE_ENTRY_RATELIMIT ((const RateLimit) { .interval = 1 * USEC_PER_SEC, .burst = 1 }) -static int server_schedule_sync(Server *s, int priority); -static int server_refresh_idle_timer(Server *s); +static int manager_schedule_sync(Manager *m, int priority); +static int manager_refresh_idle_timer(Manager *m); -static int server_determine_path_usage( - Server *s, +static int manager_determine_path_usage( + Manager *m, const char *path, uint64_t *ret_used, uint64_t *ret_free) { @@ -107,7 +107,7 @@ static int server_determine_path_usage( _cleanup_closedir_ DIR *d = NULL; struct statvfs ss; - assert(s); + assert(m); assert(path); assert(ret_used); assert(ret_free); @@ -148,14 +148,14 @@ static void cache_space_invalidate(JournalStorageSpace *space) { zero(*space); } -static int cache_space_refresh(Server *s, JournalStorage *storage) { +static int cache_space_refresh(Manager *m, JournalStorage *storage) { JournalStorageSpace *space; JournalMetrics *metrics; uint64_t vfs_used, vfs_avail, avail; usec_t ts; int r; - assert(s); + assert(m); metrics = &storage->metrics; space = &storage->space; @@ -165,7 +165,7 @@ static int cache_space_refresh(Server *s, JournalStorage *storage) { if (space->timestamp != 0 && usec_add(space->timestamp, RECHECK_SPACE_USEC) > ts) return 0; - r = server_determine_path_usage(s, storage->path, &vfs_used, &vfs_avail); + r = manager_determine_path_usage(m, storage->path, &vfs_used, &vfs_avail); if (r < 0) return r; @@ -192,21 +192,21 @@ static void patch_min_use(JournalStorage *storage) { storage->metrics.min_use = MAX(storage->metrics.min_use, storage->space.vfs_used); } -static JournalStorage* server_current_storage(Server *s) { - assert(s); +static JournalStorage* manager_current_storage(Manager *m) { + assert(m); - return s->system_journal ? &s->system_storage : &s->runtime_storage; + return m->system_journal ? &m->system_storage : &m->runtime_storage; } -static int server_determine_space(Server *s, uint64_t *available, uint64_t *limit) { +static int manager_determine_space(Manager *m, uint64_t *available, uint64_t *limit) { JournalStorage *js; int r; - assert(s); + assert(m); - js = server_current_storage(s); + js = manager_current_storage(m); - r = cache_space_refresh(s, js); + r = cache_space_refresh(m, js); if (r >= 0) { if (available) *available = js->space.available; @@ -216,41 +216,41 @@ static int server_determine_space(Server *s, uint64_t *available, uint64_t *limi return r; } -void server_space_usage_message(Server *s, JournalStorage *storage) { - assert(s); +void manager_space_usage_message(Manager *m, JournalStorage *storage) { + assert(m); if (!storage) - storage = server_current_storage(s); + storage = manager_current_storage(m); - if (cache_space_refresh(s, storage) < 0) + if (cache_space_refresh(m, storage) < 0) return; const JournalMetrics *metrics = &storage->metrics; - server_driver_message(s, 0, - LOG_MESSAGE_ID(SD_MESSAGE_JOURNAL_USAGE_STR), - LOG_MESSAGE("%s (%s) is %s, max %s, %s free.", - storage->name, storage->path, - FORMAT_BYTES(storage->space.vfs_used), - FORMAT_BYTES(storage->space.limit), - FORMAT_BYTES(storage->space.available)), - LOG_ITEM("JOURNAL_NAME=%s", storage->name), - LOG_ITEM("JOURNAL_PATH=%s", storage->path), - LOG_ITEM("CURRENT_USE=%"PRIu64, storage->space.vfs_used), - LOG_ITEM("CURRENT_USE_PRETTY=%s", FORMAT_BYTES(storage->space.vfs_used)), - LOG_ITEM("MAX_USE=%"PRIu64, metrics->max_use), - LOG_ITEM("MAX_USE_PRETTY=%s", FORMAT_BYTES(metrics->max_use)), - LOG_ITEM("DISK_KEEP_FREE=%"PRIu64, metrics->keep_free), - LOG_ITEM("DISK_KEEP_FREE_PRETTY=%s", FORMAT_BYTES(metrics->keep_free)), - LOG_ITEM("DISK_AVAILABLE=%"PRIu64, storage->space.vfs_available), - LOG_ITEM("DISK_AVAILABLE_PRETTY=%s", FORMAT_BYTES(storage->space.vfs_available)), - LOG_ITEM("LIMIT=%"PRIu64, storage->space.limit), - LOG_ITEM("LIMIT_PRETTY=%s", FORMAT_BYTES(storage->space.limit)), - LOG_ITEM("AVAILABLE=%"PRIu64, storage->space.available), - LOG_ITEM("AVAILABLE_PRETTY=%s", FORMAT_BYTES(storage->space.available))); -} - -static void server_add_acls(JournalFile *f, uid_t uid) { + manager_driver_message(m, 0, + LOG_MESSAGE_ID(SD_MESSAGE_JOURNAL_USAGE_STR), + LOG_MESSAGE("%s (%s) is %s, max %s, %s free.", + storage->name, storage->path, + FORMAT_BYTES(storage->space.vfs_used), + FORMAT_BYTES(storage->space.limit), + FORMAT_BYTES(storage->space.available)), + LOG_ITEM("JOURNAL_NAME=%s", storage->name), + LOG_ITEM("JOURNAL_PATH=%s", storage->path), + LOG_ITEM("CURRENT_USE=%"PRIu64, storage->space.vfs_used), + LOG_ITEM("CURRENT_USE_PRETTY=%s", FORMAT_BYTES(storage->space.vfs_used)), + LOG_ITEM("MAX_USE=%"PRIu64, metrics->max_use), + LOG_ITEM("MAX_USE_PRETTY=%s", FORMAT_BYTES(metrics->max_use)), + LOG_ITEM("DISK_KEEP_FREE=%"PRIu64, metrics->keep_free), + LOG_ITEM("DISK_KEEP_FREE_PRETTY=%s", FORMAT_BYTES(metrics->keep_free)), + LOG_ITEM("DISK_AVAILABLE=%"PRIu64, storage->space.vfs_available), + LOG_ITEM("DISK_AVAILABLE_PRETTY=%s", FORMAT_BYTES(storage->space.vfs_available)), + LOG_ITEM("LIMIT=%"PRIu64, storage->space.limit), + LOG_ITEM("LIMIT_PRETTY=%s", FORMAT_BYTES(storage->space.limit)), + LOG_ITEM("AVAILABLE=%"PRIu64, storage->space.available), + LOG_ITEM("AVAILABLE_PRETTY=%s", FORMAT_BYTES(storage->space.available))); +} + +static void manager_add_acls(JournalFile *f, uid_t uid) { assert(f); #if HAVE_ACL @@ -266,8 +266,8 @@ static void server_add_acls(JournalFile *f, uid_t uid) { #endif } -static int server_open_journal( - Server *s, +static int manager_open_journal( + Manager *m, bool reliably, const char *fname, int open_flags, @@ -279,16 +279,16 @@ static int server_open_journal( JournalFileFlags file_flags; int r; - assert(s); + assert(m); assert(fname); assert(ret); file_flags = - (s->compress.enabled ? JOURNAL_COMPRESS : 0) | + (m->compress.enabled ? JOURNAL_COMPRESS : 0) | (seal ? JOURNAL_SEAL : 0) | JOURNAL_STRICT_ORDER; - set_clear(s->deferred_closes); + set_clear(m->deferred_closes); if (reliably) r = journal_file_open_reliably( @@ -296,9 +296,9 @@ static int server_open_journal( open_flags, file_flags, 0640, - s->compress.threshold_bytes, + m->compress.threshold_bytes, metrics, - s->mmap, + m->mmap, &f); else r = journal_file_open( @@ -307,15 +307,15 @@ static int server_open_journal( open_flags, file_flags, 0640, - s->compress.threshold_bytes, + m->compress.threshold_bytes, metrics, - s->mmap, + m->mmap, /* template= */ NULL, &f); if (r < 0) return r; - r = journal_file_enable_post_change_timer(f, s->event, POST_CHANGE_TIMER_INTERVAL_USEC); + r = journal_file_enable_post_change_timer(f, m->event, POST_CHANGE_TIMER_INTERVAL_USEC); if (r < 0) return r; @@ -323,69 +323,69 @@ static int server_open_journal( return r; } -static bool server_flushed_flag_is_set(Server *s) { +static bool manager_flushed_flag_is_set(Manager *m) { const char *fn; - assert(s); + assert(m); /* We don't support the "flushing" concept for namespace instances, we assume them to always have * access to /var */ - if (s->namespace) + if (m->namespace) return true; - fn = strjoina(s->runtime_directory, "/flushed"); + fn = strjoina(m->runtime_directory, "/flushed"); return access(fn, F_OK) >= 0; } -static void server_drop_flushed_flag(Server *s) { +static void manager_drop_flushed_flag(Manager *m) { const char *fn; - assert(s); + assert(m); - if (s->namespace) + if (m->namespace) return; - fn = strjoina(s->runtime_directory, "/flushed"); + fn = strjoina(m->runtime_directory, "/flushed"); if (unlink(fn) < 0 && errno != ENOENT) log_ratelimit_warning_errno(errno, JOURNAL_LOG_RATELIMIT, "Failed to unlink %s, ignoring: %m", fn); } -static int server_system_journal_open( - Server *s, +static int manager_system_journal_open( + Manager *m, bool flush_requested, bool relinquish_requested) { const char *fn; int r = 0; - if (!s->system_journal && - IN_SET(s->storage, STORAGE_PERSISTENT, STORAGE_AUTO) && - (flush_requested || server_flushed_flag_is_set(s)) && + if (!m->system_journal && + IN_SET(m->storage, STORAGE_PERSISTENT, STORAGE_AUTO) && + (flush_requested || manager_flushed_flag_is_set(m)) && !relinquish_requested) { /* If in auto mode: first try to create the machine path, but not the prefix. * * If in persistent mode: create /var/log/journal and the machine path */ - if (s->storage == STORAGE_PERSISTENT) - (void) mkdir_parents(s->system_storage.path, 0755); + if (m->storage == STORAGE_PERSISTENT) + (void) mkdir_parents(m->system_storage.path, 0755); - (void) mkdir(s->system_storage.path, 0755); + (void) mkdir(m->system_storage.path, 0755); - fn = strjoina(s->system_storage.path, "/system.journal"); - r = server_open_journal( - s, + fn = strjoina(m->system_storage.path, "/system.journal"); + r = manager_open_journal( + m, /* reliably= */ true, fn, O_RDWR|O_CREAT, - s->seal, - &s->system_storage.metrics, - &s->system_journal); + m->seal, + &m->system_storage.metrics, + &m->system_journal); if (r >= 0) { - server_add_acls(s->system_journal, 0); - (void) cache_space_refresh(s, &s->system_storage); - patch_min_use(&s->system_storage); + manager_add_acls(m->system_journal, 0); + (void) cache_space_refresh(m, &m->system_storage); + patch_min_use(&m->system_storage); } else { if (!IN_SET(r, -ENOENT, -EROFS)) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, @@ -401,45 +401,45 @@ static int server_system_journal_open( * journal is back. */ if (!flush_requested) - (void) server_flush_to_var(s, true); + (void) manager_flush_to_var(m, true); } - if (!s->runtime_journal && - (s->storage != STORAGE_NONE)) { + if (!m->runtime_journal && + (m->storage != STORAGE_NONE)) { - fn = strjoina(s->runtime_storage.path, "/system.journal"); + fn = strjoina(m->runtime_storage.path, "/system.journal"); - if (!s->system_journal || relinquish_requested) { + if (!m->system_journal || relinquish_requested) { /* OK, we really need the runtime journal, so create it if necessary. */ - (void) mkdir_parents(s->runtime_storage.path, 0755); - (void) mkdir(s->runtime_storage.path, 0750); + (void) mkdir_parents(m->runtime_storage.path, 0755); + (void) mkdir(m->runtime_storage.path, 0750); - r = server_open_journal( - s, + r = manager_open_journal( + m, /* reliably= */ true, fn, O_RDWR|O_CREAT, /* seal= */ false, - &s->runtime_storage.metrics, - &s->runtime_journal); + &m->runtime_storage.metrics, + &m->runtime_journal); if (r < 0) return log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, "Failed to open runtime journal: %m"); - } else if (!server_flushed_flag_is_set(s)) { + } else if (!manager_flushed_flag_is_set(m)) { /* Try to open the runtime journal, but only if it already exists, so that we can * flush it into the system journal */ - r = server_open_journal( - s, + r = manager_open_journal( + m, /* reliably= */ false, fn, O_RDWR, /* seal= */ false, - &s->runtime_storage.metrics, - &s->runtime_journal); + &m->runtime_storage.metrics, + &m->runtime_journal); if (r < 0) { if (r != -ENOENT) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, @@ -449,65 +449,65 @@ static int server_system_journal_open( } } - if (s->runtime_journal) { - server_add_acls(s->runtime_journal, 0); - (void) cache_space_refresh(s, &s->runtime_storage); - patch_min_use(&s->runtime_storage); - server_drop_flushed_flag(s); + if (m->runtime_journal) { + manager_add_acls(m->runtime_journal, 0); + (void) cache_space_refresh(m, &m->runtime_storage); + patch_min_use(&m->runtime_storage); + manager_drop_flushed_flag(m); } } return r; } -static int server_find_user_journal(Server *s, uid_t uid, JournalFile **ret) { +static int manager_find_user_journal(Manager *m, uid_t uid, JournalFile **ret) { _cleanup_(journal_file_offline_closep) JournalFile *f = NULL; _cleanup_free_ char *p = NULL; int r; assert(!uid_for_system_journal(uid)); - f = ordered_hashmap_get(s->user_journals, UID_TO_PTR(uid)); + f = ordered_hashmap_get(m->user_journals, UID_TO_PTR(uid)); if (f) goto found; - if (asprintf(&p, "%s/user-" UID_FMT ".journal", s->system_storage.path, uid) < 0) + if (asprintf(&p, "%s/user-" UID_FMT ".journal", m->system_storage.path, uid) < 0) return log_oom(); /* Too many open? Then let's close one (or more) */ - while (ordered_hashmap_size(s->user_journals) >= USER_JOURNALS_MAX) { + while (ordered_hashmap_size(m->user_journals) >= USER_JOURNALS_MAX) { JournalFile *first; - assert_se(first = ordered_hashmap_steal_first(s->user_journals)); + assert_se(first = ordered_hashmap_steal_first(m->user_journals)); (void) journal_file_offline_close(first); } - r = server_open_journal( - s, + r = manager_open_journal( + m, /* reliably= */ true, p, O_RDWR|O_CREAT, - s->seal, - &s->system_storage.metrics, + m->seal, + &m->system_storage.metrics, &f); if (r < 0) return r; - r = ordered_hashmap_put(s->user_journals, UID_TO_PTR(uid), f); + r = ordered_hashmap_put(m->user_journals, UID_TO_PTR(uid), f); if (r < 0) return r; - server_add_acls(f, uid); + manager_add_acls(f, uid); found: *ret = TAKE_PTR(f); return 0; } -static JournalFile* server_find_journal(Server *s, uid_t uid) { +static JournalFile* manager_find_journal(Manager *m, uid_t uid) { int r; - assert(s); + assert(m); /* A rotate that fails to create the new journal (ENOSPC) leaves the rotated journal as NULL. Unless * we revisit opening, even after space is made available we'll continue to return NULL indefinitely. @@ -516,37 +516,37 @@ static JournalFile* server_find_journal(Server *s, uid_t uid) { * recover from failed rotates (or anything else that's left the journals as NULL). * * Fixes https://github.com/systemd/systemd/issues/3968 */ - (void) server_system_journal_open(s, /* flush_requested= */ false, /* relinquish_requested= */ false); + (void) manager_system_journal_open(m, /* flush_requested= */ false, /* relinquish_requested= */ false); /* We split up user logs only on /var, not on /run. If the runtime file is open, we write to it * exclusively, in order to guarantee proper order as soon as we flush /run to /var and close the * runtime file. */ - if (s->runtime_journal) - return s->runtime_journal; + if (m->runtime_journal) + return m->runtime_journal; /* If we are not in persistent mode, then we need return NULL immediately rather than opening a * persistent journal of any sort. * * Fixes https://github.com/systemd/systemd/issues/20390 */ - if (!IN_SET(s->storage, STORAGE_AUTO, STORAGE_PERSISTENT)) + if (!IN_SET(m->storage, STORAGE_AUTO, STORAGE_PERSISTENT)) return NULL; if (!uid_for_system_journal(uid)) { JournalFile *f = NULL; - r = server_find_user_journal(s, uid, &f); + r = manager_find_user_journal(m, uid, &f); if (r >= 0) return ASSERT_PTR(f); log_warning_errno(r, "Failed to open user journal file, falling back to system journal: %m"); } - return s->system_journal; + return m->system_journal; } -static int server_do_rotate( - Server *s, +static int manager_do_rotate( + Manager *m, JournalFile **f, const char* name, bool seal, @@ -555,17 +555,17 @@ static int server_do_rotate( JournalFileFlags file_flags; int r; - assert(s); + assert(m); if (!*f) return -EINVAL; file_flags = - (s->compress.enabled ? JOURNAL_COMPRESS : 0)| + (m->compress.enabled ? JOURNAL_COMPRESS : 0)| (seal ? JOURNAL_SEAL : 0) | JOURNAL_STRICT_ORDER; - r = journal_file_rotate(f, s->mmap, file_flags, s->compress.threshold_bytes, s->deferred_closes); + r = journal_file_rotate(f, m->mmap, file_flags, m->compress.threshold_bytes, m->deferred_closes); if (r < 0) { if (*f) return log_ratelimit_error_errno(r, JOURNAL_LOG_RATELIMIT, @@ -575,55 +575,55 @@ static int server_do_rotate( "Failed to create new %s journal: %m", name); } - server_add_acls(*f, uid); + manager_add_acls(*f, uid); return r; } -static void server_process_deferred_closes(Server *s) { +static void manager_process_deferred_closes(Manager *m) { JournalFile *f; /* Perform any deferred closes which aren't still offlining. */ - SET_FOREACH(f, s->deferred_closes) { + SET_FOREACH(f, m->deferred_closes) { if (journal_file_is_offlining(f)) continue; - (void) set_remove(s->deferred_closes, f); + (void) set_remove(m->deferred_closes, f); (void) journal_file_offline_close(f); } } -static void server_vacuum_deferred_closes(Server *s) { - assert(s); +static void manager_vacuum_deferred_closes(Manager *m) { + assert(m); /* Make some room in the deferred closes list, so that it doesn't grow without bounds */ - if (set_size(s->deferred_closes) < DEFERRED_CLOSES_MAX) + if (set_size(m->deferred_closes) < DEFERRED_CLOSES_MAX) return; /* Let's first remove all journal files that might already have completed closing */ - server_process_deferred_closes(s); + manager_process_deferred_closes(m); /* And now, let's close some more until we reach the limit again. */ - while (set_size(s->deferred_closes) >= DEFERRED_CLOSES_MAX) { + while (set_size(m->deferred_closes) >= DEFERRED_CLOSES_MAX) { JournalFile *f; - assert_se(f = set_steal_first(s->deferred_closes)); + assert_se(f = set_steal_first(m->deferred_closes)); journal_file_offline_close(f); } } -static int server_archive_offline_user_journals(Server *s) { +static int manager_archive_offline_user_journals(Manager *m) { _cleanup_closedir_ DIR *d = NULL; int r; - assert(s); + assert(m); - d = opendir(s->system_storage.path); + d = opendir(m->system_storage.path); if (!d) { if (errno == ENOENT) return 0; return log_ratelimit_error_errno(errno, JOURNAL_LOG_RATELIMIT, - "Failed to open %s: %m", s->system_storage.path); + "Failed to open %s: %m", m->system_storage.path); } for (;;) { @@ -639,7 +639,7 @@ static int server_archive_offline_user_journals(Server *s) { if (errno != 0) log_ratelimit_warning_errno(errno, JOURNAL_LOG_RATELIMIT, "Failed to enumerate %s, ignoring: %m", - s->system_storage.path); + m->system_storage.path); break; } @@ -652,10 +652,10 @@ static int server_archive_offline_user_journals(Server *s) { } /* Already rotated in the above loop? i.e. is it an open user journal? */ - if (ordered_hashmap_contains(s->user_journals, UID_TO_PTR(uid))) + if (ordered_hashmap_contains(m->user_journals, UID_TO_PTR(uid))) continue; - full = path_join(s->system_storage.path, de->d_name); + full = path_join(m->system_storage.path, de->d_name); if (!full) return log_oom(); @@ -668,19 +668,19 @@ static int server_archive_offline_user_journals(Server *s) { } /* Make some room in the set of deferred close()s */ - server_vacuum_deferred_closes(s); + manager_vacuum_deferred_closes(m); /* Open the file briefly, so that we can archive it */ r = journal_file_open( fd, full, O_RDWR, - (s->compress.enabled ? JOURNAL_COMPRESS : 0) | - (s->seal ? JOURNAL_SEAL : 0), /* strict order does not matter here */ + (m->compress.enabled ? JOURNAL_COMPRESS : 0) | + (m->seal ? JOURNAL_SEAL : 0), /* strict order does not matter here */ 0640, - s->compress.threshold_bytes, - &s->system_storage.metrics, - s->mmap, + m->compress.threshold_bytes, + &m->system_storage.metrics, + m->mmap, /* template= */ NULL, &f); if (r < 0) { @@ -706,13 +706,13 @@ static int server_archive_offline_user_journals(Server *s) { if (r < 0) log_debug_errno(r, "Failed to archive journal file '%s', ignoring: %m", full); - journal_file_initiate_close(TAKE_PTR(f), s->deferred_closes); + journal_file_initiate_close(TAKE_PTR(f), m->deferred_closes); } return 0; } -void server_rotate(Server *s) { +void manager_rotate(Manager *m) { JournalFile *f; void *k; int r; @@ -720,95 +720,95 @@ void server_rotate(Server *s) { log_debug("Rotating..."); /* First, rotate the system journal (either in its runtime flavour or in its runtime flavour) */ - (void) server_do_rotate(s, &s->runtime_journal, "runtime", /* seal= */ false, /* uid= */ 0); - (void) server_do_rotate(s, &s->system_journal, "system", s->seal, /* uid= */ 0); + (void) manager_do_rotate(m, &m->runtime_journal, "runtime", /* seal= */ false, /* uid= */ 0); + (void) manager_do_rotate(m, &m->system_journal, "system", m->seal, /* uid= */ 0); /* Then, rotate all user journals we have open (keeping them open) */ - ORDERED_HASHMAP_FOREACH_KEY(f, k, s->user_journals) { - r = server_do_rotate(s, &f, "user", s->seal, PTR_TO_UID(k)); + ORDERED_HASHMAP_FOREACH_KEY(f, k, m->user_journals) { + r = manager_do_rotate(m, &f, "user", m->seal, PTR_TO_UID(k)); if (r >= 0) - ordered_hashmap_replace(s->user_journals, k, f); + ordered_hashmap_replace(m->user_journals, k, f); else if (!f) /* Old file has been closed and deallocated */ - ordered_hashmap_remove(s->user_journals, k); + ordered_hashmap_remove(m->user_journals, k); } /* Finally, also rotate all user journals we currently do not have open. (But do so only if we * actually have access to /var, i.e. are not in the log-to-runtime-journal mode). */ - if (!s->runtime_journal) - (void) server_archive_offline_user_journals(s); + if (!m->runtime_journal) + (void) manager_archive_offline_user_journals(m); - server_process_deferred_closes(s); + manager_process_deferred_closes(m); } -static void server_rotate_journal(Server *s, JournalFile *f, uid_t uid) { +static void manager_rotate_journal(Manager *m, JournalFile *f, uid_t uid) { int r; - assert(s); + assert(m); assert(f); - /* This is similar to server_rotate(), but rotates only specified journal file. + /* This is similar to manager_rotate(), but rotates only specified journal file. * * 💣💣💣 This invalidate 'f', and the caller cannot reuse the passed JournalFile object. 💣💣💣 */ - if (f == s->system_journal) - (void) server_do_rotate(s, &s->system_journal, "system", s->seal, /* uid= */ 0); - else if (f == s->runtime_journal) - (void) server_do_rotate(s, &s->runtime_journal, "runtime", /* seal= */ false, /* uid= */ 0); + if (f == m->system_journal) + (void) manager_do_rotate(m, &m->system_journal, "system", m->seal, /* uid= */ 0); + else if (f == m->runtime_journal) + (void) manager_do_rotate(m, &m->runtime_journal, "runtime", /* seal= */ false, /* uid= */ 0); else { - assert(ordered_hashmap_get(s->user_journals, UID_TO_PTR(uid)) == f); - r = server_do_rotate(s, &f, "user", s->seal, uid); + assert(ordered_hashmap_get(m->user_journals, UID_TO_PTR(uid)) == f); + r = manager_do_rotate(m, &f, "user", m->seal, uid); if (r >= 0) - ordered_hashmap_replace(s->user_journals, UID_TO_PTR(uid), f); + ordered_hashmap_replace(m->user_journals, UID_TO_PTR(uid), f); else if (!f) /* Old file has been closed and deallocated */ - ordered_hashmap_remove(s->user_journals, UID_TO_PTR(uid)); + ordered_hashmap_remove(m->user_journals, UID_TO_PTR(uid)); } - server_process_deferred_closes(s); + manager_process_deferred_closes(m); } -static void server_sync(Server *s, bool wait) { +static void manager_sync(Manager *m, bool wait) { JournalFile *f; int r; - if (s->system_journal) { - r = journal_file_set_offline(s->system_journal, wait); + if (m->system_journal) { + r = journal_file_set_offline(m->system_journal, wait); if (r < 0) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, "Failed to sync system journal, ignoring: %m"); } - ORDERED_HASHMAP_FOREACH(f, s->user_journals) { + ORDERED_HASHMAP_FOREACH(f, m->user_journals) { r = journal_file_set_offline(f, wait); if (r < 0) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, "Failed to sync user journal, ignoring: %m"); } - r = sd_event_source_set_enabled(s->sync_event_source, SD_EVENT_OFF); + r = sd_event_source_set_enabled(m->sync_event_source, SD_EVENT_OFF); if (r < 0) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, "Failed to disable sync timer source, ignoring: %m"); - s->sync_scheduled = false; + m->sync_scheduled = false; } -static void server_do_vacuum(Server *s, JournalStorage *storage, bool verbose) { +static void manager_do_vacuum(Manager *m, JournalStorage *storage, bool verbose) { int r; - assert(s); + assert(m); assert(storage); - (void) cache_space_refresh(s, storage); + (void) cache_space_refresh(m, storage); if (verbose) - server_space_usage_message(s, storage); + manager_space_usage_message(m, storage); r = journal_directory_vacuum(storage->path, storage->space.limit, - storage->metrics.n_max_files, s->max_retention_usec, - &s->oldest_file_usec, verbose); + storage->metrics.n_max_files, m->max_retention_usec, + &m->oldest_file_usec, verbose); if (r < 0 && r != -ENOENT) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, "Failed to vacuum %s, ignoring: %m", storage->path); @@ -816,50 +816,50 @@ static void server_do_vacuum(Server *s, JournalStorage *storage, bool verbose) { cache_space_invalidate(&storage->space); } -void server_vacuum(Server *s, bool verbose) { - assert(s); +void manager_vacuum(Manager *m, bool verbose) { + assert(m); log_debug("Vacuuming..."); - s->oldest_file_usec = 0; + m->oldest_file_usec = 0; - if (s->system_journal) - server_do_vacuum(s, &s->system_storage, verbose); - if (s->runtime_journal) - server_do_vacuum(s, &s->runtime_storage, verbose); + if (m->system_journal) + manager_do_vacuum(m, &m->system_storage, verbose); + if (m->runtime_journal) + manager_do_vacuum(m, &m->runtime_storage, verbose); } -static void server_cache_machine_id(Server *s) { +static void manager_cache_machine_id(Manager *m) { sd_id128_t id; int r; - assert(s); + assert(m); r = sd_id128_get_machine(&id); if (r < 0) return; - sd_id128_to_string(id, stpcpy(s->machine_id_field, "_MACHINE_ID=")); + sd_id128_to_string(id, stpcpy(m->machine_id_field, "_MACHINE_ID=")); } -static void server_cache_boot_id(Server *s) { +static void manager_cache_boot_id(Manager *m) { sd_id128_t id; int r; - assert(s); + assert(m); r = sd_id128_get_boot(&id); if (r < 0) return; - sd_id128_to_string(id, stpcpy(s->boot_id_field, "_BOOT_ID=")); + sd_id128_to_string(id, stpcpy(m->boot_id_field, "_BOOT_ID=")); } -static void server_cache_hostname(Server *s) { +static void manager_cache_hostname(Manager *m) { _cleanup_free_ char *t = NULL; char *x; - assert(s); + assert(m); t = gethostname_malloc(); if (!t) @@ -869,7 +869,7 @@ static void server_cache_hostname(Server *s) { if (!x) return; - free_and_replace(s->hostname_field, x); + free_and_replace(m->hostname_field, x); } static bool shall_try_append_again(JournalFile *f, int r) { @@ -884,8 +884,8 @@ static bool shall_try_append_again(JournalFile *f, int r) { case -EROFS: /* Read-only file system */ /* When appending an entry fails if shall_try_append_again returns true, the journal is - * rotated. If the FS is read-only, rotation will fail and s->system_journal will be set to - * NULL. After that, when find_journal will try to open the journal since s->system_journal + * rotated. If the FS is read-only, rotation will fail and m->system_journal will be set to + * NULL. After that, when find_journal will try to open the journal since m->system_journal * will be NULL, it will open the runtime journal. */ log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, "%s: Read-only file system, rotating.", f->path); return true; @@ -943,8 +943,8 @@ static bool shall_try_append_again(JournalFile *f, int r) { } } -static void server_write_to_journal( - Server *s, +static void manager_write_to_journal( + Manager *m, uid_t uid, const struct iovec *iovec, size_t n, @@ -955,28 +955,28 @@ static void server_write_to_journal( JournalFile *f; int r; - assert(s); + assert(m); assert(iovec); assert(n > 0); assert(ts); - if (ts->realtime < s->last_realtime_clock) { + if (ts->realtime < m->last_realtime_clock) { /* When the time jumps backwards, let's immediately rotate. Of course, this should not happen during * regular operation. However, when it does happen, then we should make sure that we start fresh files * to ensure that the entries in the journal files are strictly ordered by time, in order to ensure * bisection works correctly. */ log_ratelimit_info(JOURNAL_LOG_RATELIMIT, "Time jumped backwards, rotating."); - server_rotate(s); - server_vacuum(s, /* verbose = */ false); + manager_rotate(m); + manager_vacuum(m, /* verbose = */ false); vacuumed = true; } - f = server_find_journal(s, uid); + f = manager_find_journal(m, uid); if (!f) return; - if (journal_file_rotate_suggested(f, s->max_file_usec, LOG_DEBUG)) { + if (journal_file_rotate_suggested(f, m->max_file_usec, LOG_DEBUG)) { if (vacuumed) { log_ratelimit_warning(JOURNAL_LOG_RATELIMIT, "Suppressing rotation, as we already rotated immediately before write attempt. Giving up."); @@ -985,28 +985,28 @@ static void server_write_to_journal( log_debug("%s: Journal header limits reached or header out-of-date, rotating.", f->path); - server_rotate_journal(s, TAKE_PTR(f), uid); - server_vacuum(s, /* verbose = */ false); + manager_rotate_journal(m, TAKE_PTR(f), uid); + manager_vacuum(m, /* verbose = */ false); vacuumed = true; - f = server_find_journal(s, uid); + f = manager_find_journal(m, uid); if (!f) return; } - s->last_realtime_clock = ts->realtime; + m->last_realtime_clock = ts->realtime; r = journal_file_append_entry( f, ts, /* boot_id= */ NULL, iovec, n, - &s->seqnum->seqnum, - &s->seqnum->id, + &m->seqnum->seqnum, + &m->seqnum->id, /* ret_object= */ NULL, /* ret_offset= */ NULL); if (r >= 0) { - server_schedule_sync(s, priority); + manager_schedule_sync(m, priority); return; } @@ -1020,10 +1020,10 @@ static void server_write_to_journal( return; } - server_rotate_journal(s, TAKE_PTR(f), uid); - server_vacuum(s, /* verbose = */ false); + manager_rotate_journal(m, TAKE_PTR(f), uid); + manager_vacuum(m, /* verbose = */ false); - f = server_find_journal(s, uid); + f = manager_find_journal(m, uid); if (!f) return; @@ -1033,8 +1033,8 @@ static void server_write_to_journal( ts, /* boot_id= */ NULL, iovec, n, - &s->seqnum->seqnum, - &s->seqnum->id, + &m->seqnum->seqnum, + &m->seqnum->id, /* ret_object= */ NULL, /* ret_offset= */ NULL); if (r < 0) @@ -1042,7 +1042,7 @@ static void server_write_to_journal( "Failed to write entry to %s (%zu items, %zu bytes) despite vacuuming, ignoring: %m", f->path, n, iovec_total_size(iovec, n)); else - server_schedule_sync(s, priority); + manager_schedule_sync(m, priority); } #define IOVEC_ADD_NUMERIC_FIELD(iovec, n, value, type, isset, format, field) \ @@ -1076,9 +1076,9 @@ static void server_write_to_journal( iovec[n++] = IOVEC_MAKE_STRING(k); \ } -static void server_dispatch_message_real( - Server *s, - struct iovec *iovec, size_t n, size_t m, +static void manager_dispatch_message_real( + Manager *m, + struct iovec *iovec, size_t n, size_t mm, const ClientContext *c, const struct timeval *tv, int priority, @@ -1089,13 +1089,13 @@ static void server_dispatch_message_real( uid_t journal_uid; ClientContext *o; - assert(s); + assert(m); assert(iovec); assert(n > 0); assert(n + N_IOVEC_META_FIELDS + (pid_is_valid(object_pid) ? N_IOVEC_OBJECT_FIELDS : 0) + - client_context_extra_fields_n_iovec(c) <= m); + client_context_extra_fields_n_iovec(c) <= mm); if (c) { IOVEC_ADD_NUMERIC_FIELD(iovec, n, c->pid, pid_t, pid_is_valid, PID_FMT, "_PID"); @@ -1131,9 +1131,9 @@ static void server_dispatch_message_real( } } - assert(n <= m); + assert(n <= mm); - if (pid_is_valid(object_pid) && client_context_get(s, object_pid, NULL, NULL, 0, NULL, &o) >= 0) { + if (pid_is_valid(object_pid) && client_context_get(m, object_pid, NULL, NULL, 0, NULL, &o) >= 0) { IOVEC_ADD_NUMERIC_FIELD(iovec, n, o->pid, pid_t, pid_is_valid, PID_FMT, "OBJECT_PID"); IOVEC_ADD_NUMERIC_FIELD(iovec, n, o->uid, uid_t, uid_is_valid, UID_FMT, "OBJECT_UID"); @@ -1161,7 +1161,7 @@ static void server_dispatch_message_real( IOVEC_ADD_ID128_FIELD(iovec, n, o->invocation_id, "OBJECT_SYSTEMD_INVOCATION_ID"); } - assert(n <= m); + assert(n <= mm); if (tv) { xsprintf(source_time, "_SOURCE_REALTIME_TIMESTAMP=" USEC_FMT, timeval_load(tv)); @@ -1171,25 +1171,25 @@ static void server_dispatch_message_real( /* Note that strictly speaking storing the boot id here is * redundant since the entry includes this in-line * anyway. However, we need this indexed, too. */ - if (!isempty(s->boot_id_field)) - iovec[n++] = IOVEC_MAKE_STRING(s->boot_id_field); + if (!isempty(m->boot_id_field)) + iovec[n++] = IOVEC_MAKE_STRING(m->boot_id_field); - if (!isempty(s->machine_id_field)) - iovec[n++] = IOVEC_MAKE_STRING(s->machine_id_field); + if (!isempty(m->machine_id_field)) + iovec[n++] = IOVEC_MAKE_STRING(m->machine_id_field); - if (!isempty(s->hostname_field)) - iovec[n++] = IOVEC_MAKE_STRING(s->hostname_field); + if (!isempty(m->hostname_field)) + iovec[n++] = IOVEC_MAKE_STRING(m->hostname_field); - if (!isempty(s->namespace_field)) - iovec[n++] = IOVEC_MAKE_STRING(s->namespace_field); + if (!isempty(m->namespace_field)) + iovec[n++] = IOVEC_MAKE_STRING(m->namespace_field); iovec[n++] = in_initrd() ? IOVEC_MAKE_STRING("_RUNTIME_SCOPE=initrd") : IOVEC_MAKE_STRING("_RUNTIME_SCOPE=system"); - assert(n <= m); + assert(n <= mm); - if (s->split_mode == SPLIT_UID && c && uid_is_valid(c->uid)) + if (m->split_mode == SPLIT_UID && c && uid_is_valid(c->uid)) /* Split up strictly by (non-root) UID */ journal_uid = c->uid; - else if (s->split_mode == SPLIT_LOGIN && c && c->uid > 0 && uid_is_valid(c->owner_uid)) + else if (m->split_mode == SPLIT_LOGIN && c && c->uid > 0 && uid_is_valid(c->owner_uid)) /* Split up by login UIDs. We do this only if the * realuid is not root, in order not to accidentally * leak privileged information to the user that is @@ -1203,24 +1203,24 @@ static void server_dispatch_message_real( * not use the source time, and not even the time the event was originally seen, but instead simply * the time we started processing it, as we want strictly linear ordering in what we write out.) */ struct dual_timestamp ts; - event_dual_timestamp_now(s->event, &ts); + event_dual_timestamp_now(m->event, &ts); - (void) server_forward_socket(s, iovec, n, &ts, priority); + (void) manager_forward_socket(m, iovec, n, &ts, priority); - server_write_to_journal(s, journal_uid, iovec, n, &ts, priority); + manager_write_to_journal(m, journal_uid, iovec, n, &ts, priority); } -void server_driver_message_internal(Server *s, pid_t object_pid, const char *format, ...) { +void manager_driver_message_internal(Manager *m, pid_t object_pid, const char *format, ...) { struct iovec *iovec; - size_t n = 0, k, m; + size_t n = 0, k, mm; va_list ap; int r; - assert(s); + assert(m); assert(format); - m = N_IOVEC_META_FIELDS + 5 + N_IOVEC_PAYLOAD_FIELDS + client_context_extra_fields_n_iovec(s->my_context) + N_IOVEC_OBJECT_FIELDS; - iovec = newa(struct iovec, m); + mm = N_IOVEC_META_FIELDS + 5 + N_IOVEC_PAYLOAD_FIELDS + client_context_extra_fields_n_iovec(m->my_context) + N_IOVEC_OBJECT_FIELDS; + iovec = newa(struct iovec, mm); assert_cc(3 == LOG_FAC(LOG_DAEMON)); iovec[n++] = IOVEC_MAKE_STRING("SYSLOG_FACILITY=3"); @@ -1234,13 +1234,13 @@ void server_driver_message_internal(Server *s, pid_t object_pid, const char *for va_start(ap, format); DISABLE_WARNING_FORMAT_NONLITERAL; - r = log_format_iovec(iovec, m, &n, false, 0, format, ap); + r = log_format_iovec(iovec, mm, &n, false, 0, format, ap); REENABLE_WARNING; /* Error handling below */ va_end(ap); if (r >= 0) - server_dispatch_message_real(s, iovec, n, m, s->my_context, /* tv= */ NULL, LOG_INFO, object_pid); + manager_dispatch_message_real(m, iovec, n, mm, m->my_context, /* tv= */ NULL, LOG_INFO, object_pid); while (k < n) free(iovec[k++].iov_base); @@ -1255,13 +1255,13 @@ void server_driver_message_internal(Server *s, pid_t object_pid, const char *for n = 3; iovec[n++] = IOVEC_MAKE_STRING("PRIORITY=4"); iovec[n++] = IOVEC_MAKE_STRING(buf); - server_dispatch_message_real(s, iovec, n, m, s->my_context, /* tv= */ NULL, LOG_INFO, object_pid); + manager_dispatch_message_real(m, iovec, n, mm, m->my_context, /* tv= */ NULL, LOG_INFO, object_pid); } } -void server_dispatch_message( - Server *s, - struct iovec *iovec, size_t n, size_t m, +void manager_dispatch_message( + Manager *m, + struct iovec *iovec, size_t n, size_t mm, ClientContext *c, const struct timeval *tv, int priority, @@ -1270,25 +1270,25 @@ void server_dispatch_message( uint64_t available = 0; int rl; - assert(s); + assert(m); assert(iovec || n == 0); if (n == 0) return; - if (LOG_PRI(priority) > s->max_level_store) + if (LOG_PRI(priority) > m->max_level_store) return; /* Stop early in case the information will not be stored * in a journal. */ - if (s->storage == STORAGE_NONE) + if (m->storage == STORAGE_NONE) return; if (c && c->unit) { - (void) server_determine_space(s, &available, /* limit= */ NULL); + (void) manager_determine_space(m, &available, /* limit= */ NULL); rl = journal_ratelimit_test( - &s->ratelimit_groups_by_id, + &m->ratelimit_groups_by_id, c->unit, c->log_ratelimit_interval, c->log_ratelimit_burst, @@ -1299,50 +1299,50 @@ void server_dispatch_message( /* Write a suppression message if we suppressed something */ if (rl > 1) - server_driver_message(s, c->pid, + manager_driver_message(m, c->pid, LOG_MESSAGE_ID(SD_MESSAGE_JOURNAL_DROPPED_STR), LOG_MESSAGE("Suppressed %i messages from %s", rl - 1, c->unit), LOG_ITEM("N_DROPPED=%i", rl - 1)); } - server_dispatch_message_real(s, iovec, n, m, c, tv, priority, object_pid); + manager_dispatch_message_real(m, iovec, n, mm, c, tv, priority, object_pid); } -int server_flush_to_var(Server *s, bool require_flag_file) { +int manager_flush_to_var(Manager *m, bool require_flag_file) { sd_journal *j = NULL; const char *fn; unsigned n = 0; usec_t start; int r, k; - assert(s); + assert(m); - if (!IN_SET(s->storage, STORAGE_AUTO, STORAGE_PERSISTENT)) + if (!IN_SET(m->storage, STORAGE_AUTO, STORAGE_PERSISTENT)) return 0; - if (s->namespace) /* Flushing concept does not exist for namespace instances */ + if (m->namespace) /* Flushing concept does not exist for namespace instances */ return 0; - if (!s->runtime_journal) /* Nothing to flush? */ + if (!m->runtime_journal) /* Nothing to flush? */ return 0; - if (require_flag_file && !server_flushed_flag_is_set(s)) + if (require_flag_file && !manager_flushed_flag_is_set(m)) return 0; - (void) server_system_journal_open(s, /* flush_requested=*/ true, /* relinquish_requested= */ false); + (void) manager_system_journal_open(m, /* flush_requested=*/ true, /* relinquish_requested= */ false); - if (!s->system_journal) + if (!m->system_journal) return 0; /* Offline and close the 'main' runtime journal file to allow the runtime journal to be opened with * the SD_JOURNAL_ASSUME_IMMUTABLE flag in the below. */ - s->runtime_journal = journal_file_offline_close(s->runtime_journal); + m->runtime_journal = journal_file_offline_close(m->runtime_journal); /* Reset current seqnum data to avoid unnecessary rotation when switching to system journal. * See issue #30092. */ - zero(*s->seqnum); + zero(*m->seqnum); - log_debug("Flushing to %s...", s->system_storage.path); + log_debug("Flushing to %s...", m->system_storage.path); start = now(CLOCK_MONOTONIC); @@ -1371,25 +1371,25 @@ int server_flush_to_var(Server *s, bool require_flag_file) { r = journal_file_copy_entry( f, - s->system_journal, + m->system_journal, o, f->current_offset, - &s->seqnum->seqnum, - &s->seqnum->id); + &m->seqnum->seqnum, + &m->seqnum->id); if (r >= 0) continue; - if (!shall_try_append_again(s->system_journal, r)) { + if (!shall_try_append_again(m->system_journal, r)) { log_ratelimit_error_errno(r, JOURNAL_LOG_RATELIMIT, "Can't write entry: %m"); goto finish; } log_ratelimit_info(JOURNAL_LOG_RATELIMIT, "Rotating system journal."); - server_rotate_journal(s, s->system_journal, /* uid = */ 0); - server_vacuum(s, /* verbose = */ false); + manager_rotate_journal(m, m->system_journal, /* uid = */ 0); + manager_vacuum(m, /* verbose = */ false); - if (!s->system_journal) { + if (!m->system_journal) { log_ratelimit_notice(JOURNAL_LOG_RATELIMIT, "Didn't flush runtime journal since rotation of system journal wasn't successful."); r = -EIO; @@ -1399,11 +1399,11 @@ int server_flush_to_var(Server *s, bool require_flag_file) { log_debug("Retrying write."); r = journal_file_copy_entry( f, - s->system_journal, + m->system_journal, o, f->current_offset, - &s->seqnum->seqnum, - &s->seqnum->id); + &m->seqnum->seqnum, + &m->seqnum->id); if (r < 0) { log_ratelimit_error_errno(r, JOURNAL_LOG_RATELIMIT, "Can't write entry: %m"); goto finish; @@ -1413,8 +1413,8 @@ int server_flush_to_var(Server *s, bool require_flag_file) { r = 0; finish: - if (s->system_journal) - journal_file_post_change(s->system_journal); + if (m->system_journal) + journal_file_post_change(m->system_journal); /* Save parent directories of runtime journals before closing runtime journals. */ _cleanup_strv_free_ char **dirs = NULL; @@ -1425,11 +1425,11 @@ finish: /* Remove the runtime directory if the all entries are successfully flushed to /var/. */ if (r >= 0) { - r = rm_rf(s->runtime_storage.path, REMOVE_ROOT); + r = rm_rf(m->runtime_storage.path, REMOVE_ROOT); if (r < 0) - log_debug_errno(r, "Failed to remove runtime journal directory %s, ignoring: %m", s->runtime_storage.path); + log_debug_errno(r, "Failed to remove runtime journal directory %s, ignoring: %m", m->runtime_storage.path); else - log_debug("Removed runtime journal directory %s.", s->runtime_storage.path); + log_debug("Removed runtime journal directory %s.", m->runtime_storage.path); /* The initrd may have a different machine ID from the host's one. Typically, that happens * when our tests running on qemu, as the host's initrd is picked as is without updating @@ -1446,54 +1446,54 @@ finish: } } - server_driver_message(s, 0, + manager_driver_message(m, 0, LOG_MESSAGE("Time spent on flushing to %s is %s for %u entries.", - s->system_storage.path, + m->system_storage.path, FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), start), 0), n)); - fn = strjoina(s->runtime_directory, "/flushed"); + fn = strjoina(m->runtime_directory, "/flushed"); k = touch(fn); if (k < 0) log_ratelimit_warning_errno(k, JOURNAL_LOG_RATELIMIT, "Failed to touch %s, ignoring: %m", fn); - server_refresh_idle_timer(s); + manager_refresh_idle_timer(m); return r; } -int server_relinquish_var(Server *s) { - assert(s); +int manager_relinquish_var(Manager *m) { + assert(m); - if (s->storage == STORAGE_NONE) + if (m->storage == STORAGE_NONE) return 0; - if (s->namespace) /* Concept does not exist for namespaced instances */ + if (m->namespace) /* Concept does not exist for namespaced instances */ return -EOPNOTSUPP; - if (s->runtime_journal && !s->system_journal) + if (m->runtime_journal && !m->system_journal) return 0; - log_debug("Relinquishing %s...", s->system_storage.path); + log_debug("Relinquishing %s...", m->system_storage.path); - (void) server_system_journal_open(s, /* flush_requested */ false, /* relinquish_requested=*/ true); + (void) manager_system_journal_open(m, /* flush_requested */ false, /* relinquish_requested=*/ true); - s->system_journal = journal_file_offline_close(s->system_journal); - ordered_hashmap_clear(s->user_journals); - set_clear(s->deferred_closes); + m->system_journal = journal_file_offline_close(m->system_journal); + ordered_hashmap_clear(m->user_journals); + set_clear(m->deferred_closes); - server_refresh_idle_timer(s); + manager_refresh_idle_timer(m); return 0; } -int server_process_datagram( +int manager_process_datagram( sd_event_source *es, int fd, uint32_t revents, void *userdata) { - size_t label_len = 0, m; - Server *s = ASSERT_PTR(userdata); + size_t label_len = 0, mm; + Manager *m = ASSERT_PTR(userdata); struct ucred *ucred = NULL; struct timeval tv_buf, *tv = NULL; struct cmsghdr *cmsg; @@ -1527,7 +1527,7 @@ int server_process_datagram( .msg_namelen = sizeof(sa), }; - assert(fd == s->native_fd || fd == s->syslog_fd || fd == s->audit_fd); + assert(fd == m->native_fd || fd == m->syslog_fd || fd == m->audit_fd); if (revents != EPOLLIN) return log_error_errno(SYNTHETIC_ERRNO(EIO), @@ -1539,14 +1539,14 @@ int server_process_datagram( (void) ioctl(fd, SIOCINQ, &v); /* Fix it up, if it is too small. We use the same fixed value as auditd here. Awful! */ - m = PAGE_ALIGN(MAX3((size_t) v + 1, + mm = PAGE_ALIGN(MAX3((size_t) v + 1, (size_t) LINE_MAX, ALIGN(sizeof(struct nlmsghdr)) + ALIGN((size_t) MAX_AUDIT_MESSAGE_LENGTH)) + 1); - if (!GREEDY_REALLOC(s->buffer, m)) + if (!GREEDY_REALLOC(m->buffer, mm)) return log_oom(); - iovec = IOVEC_MAKE(s->buffer, MALLOC_ELEMENTSOF(s->buffer) - 1); /* Leave room for trailing NUL we add later */ + iovec = IOVEC_MAKE(m->buffer, MALLOC_ELEMENTSOF(m->buffer) - 1); /* Leave room for trailing NUL we add later */ n = recvmsg_safe(fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC); if (ERRNO_IS_NEG_TRANSIENT(n)) @@ -1587,35 +1587,35 @@ int server_process_datagram( } /* And a trailing NUL, just in case */ - s->buffer[n] = 0; + m->buffer[n] = 0; - if (fd == s->syslog_fd) { + if (fd == m->syslog_fd) { if (n > 0 && n_fds == 0) - server_process_syslog_message(s, s->buffer, n, ucred, tv, label, label_len); + manager_process_syslog_message(m, m->buffer, n, ucred, tv, label, label_len); else if (n_fds > 0) log_ratelimit_warning(JOURNAL_LOG_RATELIMIT, "Got file descriptors via syslog socket. Ignoring."); if (tv) - s->syslog_timestamp = timeval_load(tv); + m->syslog_timestamp = timeval_load(tv); - } else if (fd == s->native_fd) { + } else if (fd == m->native_fd) { if (n > 0 && n_fds == 0) - server_process_native_message(s, s->buffer, n, ucred, tv, label, label_len); + manager_process_native_message(m, m->buffer, n, ucred, tv, label, label_len); else if (n == 0 && n_fds == 1) - (void) server_process_native_file(s, fds[0], ucred, tv, label, label_len); + (void) manager_process_native_file(m, fds[0], ucred, tv, label, label_len); else if (n_fds > 0) log_ratelimit_warning(JOURNAL_LOG_RATELIMIT, "Got too many file descriptors via native socket. Ignoring."); if (tv) - s->native_timestamp = timeval_load(tv); + m->native_timestamp = timeval_load(tv); } else { - assert(fd == s->audit_fd); + assert(fd == m->audit_fd); if (n > 0 && n_fds == 0) - server_process_audit_message(s, s->buffer, n, ucred, &sa, msghdr.msg_namelen); + manager_process_audit_message(m, m->buffer, n, ucred, &sa, msghdr.msg_namelen); else if (n_fds > 0) log_ratelimit_warning(JOURNAL_LOG_RATELIMIT, "Got file descriptors via audit socket. Ignoring."); @@ -1624,54 +1624,54 @@ int server_process_datagram( close_many(fds, n_fds); if (tv) - sync_req_revalidate_by_timestamp(s); + sync_req_revalidate_by_timestamp(m); - server_refresh_idle_timer(s); + manager_refresh_idle_timer(m); return 0; } -void server_full_flush(Server *s) { - assert(s); +void manager_full_flush(Manager *m) { + assert(m); - (void) server_flush_to_var(s, false); - server_sync(s, /* wait = */ false); - server_vacuum(s, false); + (void) manager_flush_to_var(m, false); + manager_sync(m, /* wait = */ false); + manager_vacuum(m, false); - server_space_usage_message(s, NULL); + manager_space_usage_message(m, NULL); - server_refresh_idle_timer(s); + manager_refresh_idle_timer(m); } static int dispatch_sigusr1(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) { - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); - if (s->namespace) { + if (m->namespace) { log_error("Received SIGUSR1 signal from PID %u, but flushing runtime journals not supported for namespaced instances.", si->ssi_pid); return 0; } log_info("Received SIGUSR1 signal from PID %u, as request to flush runtime journal.", si->ssi_pid); - server_full_flush(s); + manager_full_flush(m); return 0; } -void server_full_rotate(Server *s) { +void manager_full_rotate(Manager *m) { const char *fn; int r; - assert(s); + assert(m); - server_rotate(s); - server_vacuum(s, true); + manager_rotate(m); + manager_vacuum(m, true); - if (s->system_journal) - patch_min_use(&s->system_storage); - if (s->runtime_journal) - patch_min_use(&s->runtime_storage); + if (m->system_journal) + patch_min_use(&m->system_storage); + if (m->runtime_journal) + patch_min_use(&m->runtime_storage); /* Let clients know when the most recent rotation happened. */ - fn = strjoina(s->runtime_directory, "/rotated"); + fn = strjoina(m->runtime_directory, "/rotated"); r = write_timestamp_file_atomic(fn, now(CLOCK_MONOTONIC)); if (r < 0) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, @@ -1679,17 +1679,17 @@ void server_full_rotate(Server *s) { } static int dispatch_sigusr2(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) { - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); log_info("Received SIGUSR2 signal from PID %u, as request to rotate journal, rotating.", si->ssi_pid); - server_full_rotate(s); + manager_full_rotate(m); return 0; } static int dispatch_sigterm(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) { _cleanup_(sd_event_source_disable_unrefp) sd_event_source *news = NULL; - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); int r; log_received_signal(LOG_INFO, si); @@ -1712,7 +1712,7 @@ static int dispatch_sigterm(sd_event_source *es, const struct signalfd_siginfo * * start up next – unless we are going down for the final system shutdown, in which case everything * is lost. */ - r = sd_event_add_defer(s->event, &news, NULL, NULL); /* NULL handler means → exit when triggered */ + r = sd_event_add_defer(m->event, &news, NULL, NULL); /* NULL handler means → exit when triggered */ if (r < 0) { log_error_errno(r, "Failed to allocate exit idle event handler: %m"); goto fail; @@ -1736,7 +1736,7 @@ static int dispatch_sigterm(sd_event_source *es, const struct signalfd_siginfo * news = sd_event_source_unref(news); - r = sd_event_add_time_relative(s->event, &news, CLOCK_MONOTONIC, 10 * USEC_PER_SEC, 0, NULL, NULL); + r = sd_event_add_time_relative(m->event, &news, CLOCK_MONOTONIC, 10 * USEC_PER_SEC, 0, NULL, NULL); if (r < 0) { log_error_errno(r, "Failed to allocate exit timeout event handler: %m"); goto fail; @@ -1762,20 +1762,20 @@ static int dispatch_sigterm(sd_event_source *es, const struct signalfd_siginfo * return 0; fail: - sd_event_exit(s->event, 0); + sd_event_exit(m->event, 0); return 0; } -void server_full_sync(Server *s, bool wait) { +void manager_full_sync(Manager *m, bool wait) { const char *fn; int r; - assert(s); + assert(m); - server_sync(s, wait); + manager_sync(m, wait); /* Let clients know when the most recent sync happened. */ - fn = strjoina(s->runtime_directory, "/synced"); + fn = strjoina(m->runtime_directory, "/synced"); r = write_timestamp_file_atomic(fn, now(CLOCK_MONOTONIC)); if (r < 0) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, @@ -1783,58 +1783,58 @@ void server_full_sync(Server *s, bool wait) { } static int dispatch_sigrtmin1(sd_event_source *es, const struct signalfd_siginfo *si, void *userdata) { - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); log_debug("Received SIGRTMIN1 signal from PID %u, as request to sync.", si->ssi_pid); - server_full_sync(s, /* wait = */ false); + manager_full_sync(m, /* wait = */ false); return 0; } -static int server_setup_signals(Server *s) { +static int manager_setup_signals(Manager *m) { int r; - assert(s); + assert(m); - r = sd_event_add_signal(s->event, &s->sigusr1_event_source, SIGUSR1|SD_EVENT_SIGNAL_PROCMASK, dispatch_sigusr1, s); + r = sd_event_add_signal(m->event, &m->sigusr1_event_source, SIGUSR1|SD_EVENT_SIGNAL_PROCMASK, dispatch_sigusr1, m); if (r < 0) return r; - r = sd_event_add_signal(s->event, &s->sigusr2_event_source, SIGUSR2|SD_EVENT_SIGNAL_PROCMASK, dispatch_sigusr2, s); + r = sd_event_add_signal(m->event, &m->sigusr2_event_source, SIGUSR2|SD_EVENT_SIGNAL_PROCMASK, dispatch_sigusr2, m); if (r < 0) return r; - r = sd_event_add_signal(s->event, &s->sigterm_event_source, SIGTERM|SD_EVENT_SIGNAL_PROCMASK, dispatch_sigterm, s); + r = sd_event_add_signal(m->event, &m->sigterm_event_source, SIGTERM|SD_EVENT_SIGNAL_PROCMASK, dispatch_sigterm, m); if (r < 0) return r; /* Let's process SIGTERM early, so that we definitely react to it */ - r = sd_event_source_set_priority(s->sigterm_event_source, SD_EVENT_PRIORITY_IMPORTANT-10); + r = sd_event_source_set_priority(m->sigterm_event_source, SD_EVENT_PRIORITY_IMPORTANT-10); if (r < 0) return r; /* When journald is invoked on the terminal (when debugging), it's useful if C-c is handled * equivalent to SIGTERM. */ - r = sd_event_add_signal(s->event, &s->sigint_event_source, SIGINT|SD_EVENT_SIGNAL_PROCMASK, dispatch_sigterm, s); + r = sd_event_add_signal(m->event, &m->sigint_event_source, SIGINT|SD_EVENT_SIGNAL_PROCMASK, dispatch_sigterm, m); if (r < 0) return r; - r = sd_event_source_set_priority(s->sigint_event_source, SD_EVENT_PRIORITY_IMPORTANT-10); + r = sd_event_source_set_priority(m->sigint_event_source, SD_EVENT_PRIORITY_IMPORTANT-10); if (r < 0) return r; /* SIGRTMIN+1 causes an immediate sync. We process this very late, so that everything else queued at * this point is really written to disk. Clients can watch /run/systemd/journal/synced with inotify * until its mtime changes to see when a sync happened. */ - r = sd_event_add_signal(s->event, &s->sigrtmin1_event_source, (SIGRTMIN+1)|SD_EVENT_SIGNAL_PROCMASK, dispatch_sigrtmin1, s); + r = sd_event_add_signal(m->event, &m->sigrtmin1_event_source, (SIGRTMIN+1)|SD_EVENT_SIGNAL_PROCMASK, dispatch_sigrtmin1, m); if (r < 0) return r; - r = sd_event_source_set_priority(s->sigrtmin1_event_source, SD_EVENT_PRIORITY_NORMAL+15); + r = sd_event_source_set_priority(m->sigrtmin1_event_source, SD_EVENT_PRIORITY_NORMAL+15); if (r < 0) return r; - r = sd_event_add_signal(s->event, /* ret_event_source= */ NULL, (SIGRTMIN+18)|SD_EVENT_SIGNAL_PROCMASK, sigrtmin18_handler, &s->sigrtmin18_info); + r = sd_event_add_signal(m->event, /* ret_event_source= */ NULL, (SIGRTMIN+18)|SD_EVENT_SIGNAL_PROCMASK, sigrtmin18_handler, &m->sigrtmin18_info); if (r < 0) return r; @@ -1842,7 +1842,7 @@ static int server_setup_signals(Server *s) { } static int parse_proc_cmdline_item(const char *key, const char *value, void *data) { - Server *s = ASSERT_PTR(data); + Manager *m = ASSERT_PTR(data); int r; if (proc_cmdline_key_streq(key, "systemd.journald.forward_to_syslog")) { @@ -1851,7 +1851,7 @@ static int parse_proc_cmdline_item(const char *key, const char *value, void *dat if (r < 0) log_warning("Failed to parse forward to syslog switch \"%s\". Ignoring.", value); else - s->forward_to_syslog = r; + m->forward_to_syslog = r; } else if (proc_cmdline_key_streq(key, "systemd.journald.forward_to_kmsg")) { @@ -1859,7 +1859,7 @@ static int parse_proc_cmdline_item(const char *key, const char *value, void *dat if (r < 0) log_warning("Failed to parse forward to kmsg switch \"%s\". Ignoring.", value); else - s->forward_to_kmsg = r; + m->forward_to_kmsg = r; } else if (proc_cmdline_key_streq(key, "systemd.journald.forward_to_console")) { @@ -1867,7 +1867,7 @@ static int parse_proc_cmdline_item(const char *key, const char *value, void *dat if (r < 0) log_warning("Failed to parse forward to console switch \"%s\". Ignoring.", value); else - s->forward_to_console = r; + m->forward_to_console = r; } else if (proc_cmdline_key_streq(key, "systemd.journald.forward_to_wall")) { @@ -1875,7 +1875,7 @@ static int parse_proc_cmdline_item(const char *key, const char *value, void *dat if (r < 0) log_warning("Failed to parse forward to wall switch \"%s\". Ignoring.", value); else - s->forward_to_wall = r; + m->forward_to_wall = r; } else if (proc_cmdline_key_streq(key, "systemd.journald.max_level_console")) { @@ -1886,7 +1886,7 @@ static int parse_proc_cmdline_item(const char *key, const char *value, void *dat if (r < 0) log_warning("Failed to parse max level console value \"%s\". Ignoring.", value); else - s->max_level_console = r; + m->max_level_console = r; } else if (proc_cmdline_key_streq(key, "systemd.journald.max_level_store")) { @@ -1897,7 +1897,7 @@ static int parse_proc_cmdline_item(const char *key, const char *value, void *dat if (r < 0) log_warning("Failed to parse max level store value \"%s\". Ignoring.", value); else - s->max_level_store = r; + m->max_level_store = r; } else if (proc_cmdline_key_streq(key, "systemd.journald.max_level_syslog")) { @@ -1908,7 +1908,7 @@ static int parse_proc_cmdline_item(const char *key, const char *value, void *dat if (r < 0) log_warning("Failed to parse max level syslog value \"%s\". Ignoring.", value); else - s->max_level_syslog = r; + m->max_level_syslog = r; } else if (proc_cmdline_key_streq(key, "systemd.journald.max_level_kmsg")) { @@ -1919,7 +1919,7 @@ static int parse_proc_cmdline_item(const char *key, const char *value, void *dat if (r < 0) log_warning("Failed to parse max level kmsg value \"%s\". Ignoring.", value); else - s->max_level_kmsg = r; + m->max_level_kmsg = r; } else if (proc_cmdline_key_streq(key, "systemd.journald.max_level_wall")) { @@ -1930,7 +1930,7 @@ static int parse_proc_cmdline_item(const char *key, const char *value, void *dat if (r < 0) log_warning("Failed to parse max level wall value \"%s\". Ignoring.", value); else - s->max_level_wall = r; + m->max_level_wall = r; } else if (proc_cmdline_key_streq(key, "systemd.journald.max_level_socket")) { @@ -1941,7 +1941,7 @@ static int parse_proc_cmdline_item(const char *key, const char *value, void *dat if (r < 0) log_warning("Failed to parse max level socket value \"%s\". Ignoring.", value); else - s->max_level_socket = r; + m->max_level_socket = r; } else if (startswith(key, "systemd.journald")) log_warning("Unknown journald kernel command line option \"%s\". Ignoring.", key); @@ -1950,13 +1950,13 @@ static int parse_proc_cmdline_item(const char *key, const char *value, void *dat return 0; } -static int server_parse_config_file(Server *s) { +static int manager_parse_config_file(Manager *m) { const char *conf_file; - assert(s); + assert(m); - if (s->namespace) - conf_file = strjoina("systemd/journald@", s->namespace, ".conf"); + if (m->namespace) + conf_file = strjoina("systemd/journald@", m->namespace, ".conf"); else conf_file = "systemd/journald.conf"; @@ -1965,87 +1965,87 @@ static int server_parse_config_file(Server *s) { "Journal\0", config_item_perf_lookup, journald_gperf_lookup, CONFIG_PARSE_WARN, - /* userdata= */ s); + /* userdata= */ m); } -static int server_dispatch_sync(sd_event_source *es, usec_t t, void *userdata) { - Server *s = ASSERT_PTR(userdata); +static int manager_dispatch_sync(sd_event_source *es, usec_t t, void *userdata) { + Manager *m = ASSERT_PTR(userdata); - server_sync(s, /* wait = */ false); + manager_sync(m, /* wait = */ false); return 0; } -static int server_schedule_sync(Server *s, int priority) { +static int manager_schedule_sync(Manager *m, int priority) { int r; - assert(s); + assert(m); if (priority <= LOG_CRIT) { /* Immediately sync to disk when this is of priority CRIT, ALERT, EMERG */ - server_sync(s, /* wait = */ false); + manager_sync(m, /* wait = */ false); return 0; } - if (!s->event || sd_event_get_state(s->event) == SD_EVENT_FINISHED) { + if (!m->event || sd_event_get_state(m->event) == SD_EVENT_FINISHED) { /* Shutting down the server? Let's sync immediately. */ - server_sync(s, /* wait = */ false); + manager_sync(m, /* wait = */ false); return 0; } - if (s->sync_scheduled) + if (m->sync_scheduled) return 0; - if (s->sync_interval_usec > 0) { + if (m->sync_interval_usec > 0) { - if (!s->sync_event_source) { + if (!m->sync_event_source) { r = sd_event_add_time_relative( - s->event, - &s->sync_event_source, + m->event, + &m->sync_event_source, CLOCK_MONOTONIC, - s->sync_interval_usec, 0, - server_dispatch_sync, s); + m->sync_interval_usec, 0, + manager_dispatch_sync, m); if (r < 0) return r; - r = sd_event_source_set_priority(s->sync_event_source, SD_EVENT_PRIORITY_IMPORTANT); + r = sd_event_source_set_priority(m->sync_event_source, SD_EVENT_PRIORITY_IMPORTANT); } else { - r = sd_event_source_set_time_relative(s->sync_event_source, s->sync_interval_usec); + r = sd_event_source_set_time_relative(m->sync_event_source, m->sync_interval_usec); if (r < 0) return r; - r = sd_event_source_set_enabled(s->sync_event_source, SD_EVENT_ONESHOT); + r = sd_event_source_set_enabled(m->sync_event_source, SD_EVENT_ONESHOT); } if (r < 0) return r; - s->sync_scheduled = true; + m->sync_scheduled = true; } return 0; } static int dispatch_hostname_change(sd_event_source *es, int fd, uint32_t revents, void *userdata) { - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); - server_cache_hostname(s); + manager_cache_hostname(m); return 0; } -static int server_open_hostname(Server *s) { +static int manager_open_hostname(Manager *m) { int r; - assert(s); + assert(m); - s->hostname_fd = open("/proc/sys/kernel/hostname", + m->hostname_fd = open("/proc/sys/kernel/hostname", O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_NOCTTY); - if (s->hostname_fd < 0) + if (m->hostname_fd < 0) return log_error_errno(errno, "Failed to open /proc/sys/kernel/hostname: %m"); - r = sd_event_add_io(s->event, &s->hostname_event_source, s->hostname_fd, 0, dispatch_hostname_change, s); + r = sd_event_add_io(m->event, &m->hostname_event_source, m->hostname_fd, 0, dispatch_hostname_change, m); if (r < 0) return log_error_errno(r, "Failed to register hostname fd in event loop: %m"); - r = sd_event_source_set_priority(s->hostname_event_source, SD_EVENT_PRIORITY_IMPORTANT-10); + r = sd_event_source_set_priority(m->hostname_event_source, SD_EVENT_PRIORITY_IMPORTANT-10); if (r < 0) return log_error_errno(r, "Failed to adjust priority of hostname event source: %m"); @@ -2053,11 +2053,11 @@ static int server_open_hostname(Server *s) { } static int dispatch_notify_event(sd_event_source *es, int fd, uint32_t revents, void *userdata) { - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); int r; - assert(s->notify_event_source == es); - assert(s->notify_fd == fd); + assert(m->notify_event_source == es); + assert(m->notify_fd == fd); /* The $NOTIFY_SOCKET is writable again, now send exactly one * message on it. Either it's the watchdog event, the initial @@ -2065,36 +2065,36 @@ static int dispatch_notify_event(sd_event_source *es, int fd, uint32_t revents, * to write anymore, turn our event source off. The next time * there's something to send it will be turned on again. */ - if (!s->sent_notify_ready) { - if (send(s->notify_fd, NOTIFY_READY_MESSAGE, strlen(NOTIFY_READY_MESSAGE), MSG_DONTWAIT) < 0) { + if (!m->sent_notify_ready) { + if (send(m->notify_fd, NOTIFY_READY_MESSAGE, strlen(NOTIFY_READY_MESSAGE), MSG_DONTWAIT) < 0) { if (errno == EAGAIN) return 0; return log_error_errno(errno, "Failed to send READY=1 notification message: %m"); } - s->sent_notify_ready = true; + m->sent_notify_ready = true; log_debug("Sent READY=1 notification."); - } else if (s->send_watchdog) { + } else if (m->send_watchdog) { static const char p[] = "WATCHDOG=1"; - if (send(s->notify_fd, p, strlen(p), MSG_DONTWAIT) < 0) { + if (send(m->notify_fd, p, strlen(p), MSG_DONTWAIT) < 0) { if (errno == EAGAIN) return 0; return log_error_errno(errno, "Failed to send WATCHDOG=1 notification message: %m"); } - s->send_watchdog = false; + m->send_watchdog = false; log_debug("Sent WATCHDOG=1 notification."); - } else if (s->stdout_streams_notify_queue) + } else if (m->stdout_streams_notify_queue) /* Dispatch one stream notification event */ - stdout_stream_send_notify(s->stdout_streams_notify_queue); + stdout_stream_send_notify(m->stdout_streams_notify_queue); /* Leave us enabled if there's still more to do. */ - if (s->send_watchdog || s->stdout_streams_notify_queue) + if (m->send_watchdog || m->stdout_streams_notify_queue) return 0; /* There was nothing to do anymore, let's turn ourselves off. */ @@ -2106,35 +2106,35 @@ static int dispatch_notify_event(sd_event_source *es, int fd, uint32_t revents, } static int dispatch_watchdog(sd_event_source *es, uint64_t usec, void *userdata) { - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); int r; - s->send_watchdog = true; + m->send_watchdog = true; - r = sd_event_source_set_enabled(s->notify_event_source, SD_EVENT_ON); + r = sd_event_source_set_enabled(m->notify_event_source, SD_EVENT_ON); if (r < 0) log_warning_errno(r, "Failed to turn on notify event source: %m"); - r = sd_event_source_set_time(s->watchdog_event_source, usec + s->watchdog_usec / 2); + 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(s->watchdog_event_source, SD_EVENT_ON); + 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 server_connect_notify(Server *s) { +static int manager_connect_notify(Manager *m) { union sockaddr_union sa; socklen_t sa_len; const char *e; int r; - assert(s); - assert(s->notify_fd < 0); - assert(!s->notify_event_source); + 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 @@ -2158,24 +2158,24 @@ static int server_connect_notify(Server *s) { return log_error_errno(r, "NOTIFY_SOCKET set to invalid value '%s': %m", e); sa_len = r; - s->notify_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); - if (s->notify_fd < 0) + 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(s->notify_fd, NOTIFY_SNDBUF_SIZE); + (void) fd_inc_sndbuf(m->notify_fd, NOTIFY_SNDBUF_SIZE); - r = connect(s->notify_fd, &sa.sa, sa_len); + 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(s->event, &s->notify_event_source, s->notify_fd, EPOLLOUT, dispatch_notify_event, s); + 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, &s->watchdog_usec) > 0) { - s->send_watchdog = true; + if (sd_watchdog_enabled(false, &m->watchdog_usec) > 0) { + m->send_watchdog = true; - r = sd_event_add_time_relative(s->event, &s->watchdog_event_source, CLOCK_MONOTONIC, s->watchdog_usec/2, s->watchdog_usec/4, dispatch_watchdog, s); + 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"); } @@ -2185,8 +2185,8 @@ static int server_connect_notify(Server *s) { return 0; } -int server_map_seqnum_file( - Server *s, +int manager_map_seqnum_file( + Manager *m, const char *fname, size_t size, void **ret) { @@ -2196,12 +2196,12 @@ int server_map_seqnum_file( uint64_t *p; int r; - assert(s); + assert(m); assert(fname); assert(size > 0); assert(ret); - fn = path_join(s->runtime_directory, fname); + fn = path_join(m->runtime_directory, fname); if (!fn) return -ENOMEM; @@ -2221,7 +2221,7 @@ int server_map_seqnum_file( return 0; } -static void server_unmap_seqnum_file(void *p, size_t size) { +static void manager_unmap_seqnum_file(void *p, size_t size) { assert(size > 0); if (!p) @@ -2230,55 +2230,55 @@ static void server_unmap_seqnum_file(void *p, size_t size) { assert_se(munmap(p, size) >= 0); } -static bool server_is_idle(Server *s) { - assert(s); +static bool manager_is_idle(Manager *m) { + assert(m); /* The server for the main namespace is never idle */ - if (!s->namespace) + 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 (s->max_retention_usec > IDLE_TIMEOUT_USEC) + if (m->max_retention_usec > IDLE_TIMEOUT_USEC) return false; /* We aren't idle if we have a varlink client */ - if (sd_varlink_server_current_connections(s->varlink_server) > 0) + if (sd_varlink_server_current_connections(m->varlink_server) > 0) return false; /* If we have stdout streams we aren't idle */ - if (s->n_stdout_streams > 0) + if (m->n_stdout_streams > 0) return false; return true; } -static int server_idle_handler(sd_event_source *source, uint64_t usec, void *userdata) { - Server *s = ASSERT_PTR(userdata); +static int manager_idle_handler(sd_event_source *source, uint64_t usec, void *userdata) { + Manager *m = ASSERT_PTR(userdata); assert(source); - log_debug("Server is idle, exiting."); - sd_event_exit(s->event, 0); + log_debug("Manager is idle, exiting."); + sd_event_exit(m->event, 0); return 0; } -int server_start_or_stop_idle_timer(Server *s) { +int manager_start_or_stop_idle_timer(Manager *m) { _cleanup_(sd_event_source_unrefp) sd_event_source *source = NULL; int r; - assert(s); + assert(m); - if (sd_event_get_state(s->event) == SD_EVENT_FINISHED || - !server_is_idle(s)) { - s->idle_event_source = sd_event_source_disable_unref(s->idle_event_source); + 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 (s->idle_event_source) + if (m->idle_event_source) return 1; - r = sd_event_add_time_relative(s->event, &source, CLOCK_MONOTONIC, IDLE_TIMEOUT_USEC, 0, server_idle_handler, s); + 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"); @@ -2288,27 +2288,27 @@ int server_start_or_stop_idle_timer(Server *s) { (void) sd_event_source_set_description(source, "idle-timer"); - s->idle_event_source = TAKE_PTR(source); + m->idle_event_source = TAKE_PTR(source); return 1; } -static int server_refresh_idle_timer(Server *s) { +static int manager_refresh_idle_timer(Manager *m) { int r; - assert(s); + assert(m); - if (!s->idle_event_source) + if (!m->idle_event_source) return 0; - r = sd_event_source_set_time_relative(s->idle_event_source, IDLE_TIMEOUT_USEC); + 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; } -static int server_set_namespace(Server *s, const char *namespace) { - assert(s); +static int manager_set_namespace(Manager *m, const char *namespace) { + assert(m); if (!namespace) return 0; @@ -2316,28 +2316,28 @@ static int server_set_namespace(Server *s, const char *namespace) { if (!log_namespace_name_valid(namespace)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Specified namespace name not valid, refusing: %s", namespace); - s->namespace = strdup(namespace); - if (!s->namespace) + m->namespace = strdup(namespace); + if (!m->namespace) return log_oom(); - s->namespace_field = strjoin("_NAMESPACE=", namespace); - if (!s->namespace_field) + m->namespace_field = strjoin("_NAMESPACE=", namespace); + if (!m->namespace_field) return log_oom(); return 1; } -static int server_memory_pressure(sd_event_source *es, void *userdata) { - Server *s = ASSERT_PTR(userdata); +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(s); + 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(s->user_journals); + JournalFile *first = ordered_hashmap_steal_first(m->user_journals); if (!first) break; @@ -2350,12 +2350,12 @@ static int server_memory_pressure(sd_event_source *es, void *userdata) { return 0; } -static int server_setup_memory_pressure(Server *s) { +static int manager_setup_memory_pressure(Manager *m) { int r; - assert(s); + assert(m); - r = sd_event_add_memory_pressure(s->event, NULL, server_memory_pressure, s); + 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"); @@ -2363,17 +2363,17 @@ static int server_setup_memory_pressure(Server *s) { return 0; } -static void server_load_credentials(Server *s) { +static void manager_load_credentials(Manager *m) { _cleanup_free_ void *data = NULL; int r; - assert(s); + assert(m); r = read_credential("journal.forward_to_socket", &data, NULL); if (r < 0) log_debug_errno(r, "Failed to read credential journal.forward_to_socket, ignoring: %m"); else { - r = socket_address_parse(&s->forward_to_socket, data); + r = socket_address_parse(&m->forward_to_socket, data); if (r < 0) log_debug_errno(r, "Failed to parse socket address '%s' from credential journal.forward_to_socket, ignoring: %m", (char *) data); } @@ -2388,20 +2388,20 @@ static void server_load_credentials(Server *s) { if (r < 0) log_debug_errno(r, "Failed to parse storage '%s' from credential journal.storage, ignoring: %m", (char *) data); else - s->storage = r; + m->storage = r; } } -int server_new(Server **ret) { - _cleanup_(server_freep) Server *s = NULL; +int manager_new(Manager **ret) { + _cleanup_(manager_freep) Manager *m = NULL; assert(ret); - s = new(Server, 1); - if (!s) + m = new(Manager, 1); + if (!m) return -ENOMEM; - *s = (Server) { + *m = (Manager) { .syslog_fd = -EBADF, .native_fd = -EBADF, .stdout_fd = -EBADF, @@ -2447,74 +2447,74 @@ int server_new(Server **ret) { .burst = DEFAULT_KMSG_OWN_BURST, }, - .sigrtmin18_info.memory_pressure_handler = server_memory_pressure, - .sigrtmin18_info.memory_pressure_userdata = s, + .sigrtmin18_info.memory_pressure_handler = manager_memory_pressure, + .sigrtmin18_info.memory_pressure_userdata = m, }; - *ret = TAKE_PTR(s); + *ret = TAKE_PTR(m); return 0; } -int server_init(Server *s, const char *namespace) { +int manager_init(Manager *m, const char *namespace) { 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(s); + assert(m); - r = server_set_namespace(s, namespace); + r = manager_set_namespace(m, namespace); if (r < 0) return r; /* By default, only read from /dev/kmsg if are the main namespace */ - s->read_kmsg = !s->namespace; - s->storage = s->namespace ? STORAGE_PERSISTENT : STORAGE_AUTO; + m->read_kmsg = !m->namespace; + m->storage = m->namespace ? STORAGE_PERSISTENT : STORAGE_AUTO; - journal_reset_metrics(&s->system_storage.metrics); - journal_reset_metrics(&s->runtime_storage.metrics); + journal_reset_metrics(&m->system_storage.metrics); + journal_reset_metrics(&m->runtime_storage.metrics); - server_load_credentials(s); - server_parse_config_file(s); + manager_load_credentials(m); + manager_parse_config_file(m); - if (!s->namespace) { + if (!m->namespace) { /* Parse kernel command line, but only if we are not a namespace instance */ - r = proc_cmdline_parse(parse_proc_cmdline_item, s, PROC_CMDLINE_STRIP_RD_PREFIX); + r = proc_cmdline_parse(parse_proc_cmdline_item, m, PROC_CMDLINE_STRIP_RD_PREFIX); if (r < 0) log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m"); } - if (!!s->ratelimit_interval != !!s->ratelimit_burst) { /* One set to 0 and the other not? */ + if (!!m->ratelimit_interval != !!m->ratelimit_burst) { /* One set to 0 and the other not? */ log_debug("Setting both rate limit interval and burst from "USEC_FMT",%u to 0,0", - s->ratelimit_interval, s->ratelimit_burst); - s->ratelimit_interval = s->ratelimit_burst = 0; + m->ratelimit_interval, m->ratelimit_burst); + m->ratelimit_interval = m->ratelimit_burst = 0; } e = getenv("RUNTIME_DIRECTORY"); if (e) - s->runtime_directory = strdup(e); - else if (s->namespace) - s->runtime_directory = strjoin("/run/systemd/journal.", s->namespace); + m->runtime_directory = strdup(e); + else if (m->namespace) + m->runtime_directory = strjoin("/run/systemd/journal.", m->namespace); else - s->runtime_directory = strdup("/run/systemd/journal"); - if (!s->runtime_directory) + m->runtime_directory = strdup("/run/systemd/journal"); + if (!m->runtime_directory) return log_oom(); - (void) mkdir_p(s->runtime_directory, 0755); + (void) mkdir_p(m->runtime_directory, 0755); - s->user_journals = ordered_hashmap_new(&journal_file_hash_ops_offline_close); - if (!s->user_journals) + m->user_journals = ordered_hashmap_new(&journal_file_hash_ops_offline_close); + if (!m->user_journals) return log_oom(); - s->mmap = mmap_cache_new(); - if (!s->mmap) + m->mmap = mmap_cache_new(); + if (!m->mmap) return log_oom(); - s->deferred_closes = set_new(&journal_file_hash_ops_offline_close); - if (!s->deferred_closes) + m->deferred_closes = set_new(&journal_file_hash_ops_offline_close); + if (!m->deferred_closes) return log_oom(); - r = sd_event_default(&s->event); + r = sd_event_default(&m->event); if (r < 0) return log_error_errno(r, "Failed to create event loop: %m"); @@ -2522,36 +2522,36 @@ int server_init(Server *s, const char *namespace) { if (n < 0) return log_error_errno(n, "Failed to read listening file descriptors from environment: %m"); - native_socket = strjoina(s->runtime_directory, "/socket"); - stdout_socket = strjoina(s->runtime_directory, "/stdout"); - syslog_socket = strjoina(s->runtime_directory, "/dev-log"); - varlink_socket = strjoina(s->runtime_directory, "/io.systemd.journal"); + 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 (s->native_fd >= 0) + if (m->native_fd >= 0) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Too many native sockets passed."); - s->native_fd = fd; + m->native_fd = fd; } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, stdout_socket, 0) > 0) { - if (s->stdout_fd >= 0) + if (m->stdout_fd >= 0) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Too many stdout sockets passed."); - s->stdout_fd = fd; + m->stdout_fd = fd; } else if (sd_is_socket_unix(fd, SOCK_DGRAM, -1, syslog_socket, 0) > 0) { - if (s->syslog_fd >= 0) + if (m->syslog_fd >= 0) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Too many /dev/log sockets passed."); - s->syslog_fd = fd; + m->syslog_fd = fd; } else if (sd_is_socket_unix(fd, SOCK_STREAM, 1, varlink_socket, 0) > 0) { @@ -2562,11 +2562,11 @@ int server_init(Server *s, const char *namespace) { varlink_fd = fd; } else if (sd_is_socket(fd, AF_NETLINK, SOCK_RAW, -1) > 0) { - if (s->audit_fd >= 0) + if (m->audit_fd >= 0) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Too many audit sockets passed."); - s->audit_fd = fd; + m->audit_fd = fd; } else { @@ -2582,196 +2582,196 @@ int server_init(Server *s, const char *namespace) { } /* Try to restore streams, but don't bother if this fails */ - (void) server_restore_streams(s, fds); + (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 = s->native_fd < 0 && s->stdout_fd < 0 && s->syslog_fd < 0 && s->audit_fd < 0 && varlink_fd < 0; + 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 = server_open_stdout_socket(s, stdout_socket); + r = manager_open_stdout_socket(m, stdout_socket); if (r < 0) return r; /* systemd-journald-dev-log.socket: /run/systemd/journal/dev-log */ - r = server_open_syslog_socket(s, syslog_socket); + r = manager_open_syslog_socket(m, syslog_socket); if (r < 0) return r; /* systemd-journald.socket: /run/systemd/journal/socket */ - r = server_open_native_socket(s, native_socket); + r = manager_open_native_socket(m, native_socket); if (r < 0) return r; /* /dev/kmsg */ - r = server_open_dev_kmsg(s); + r = manager_open_dev_kmsg(m); if (r < 0) return r; /* Unless we got *some* sockets and not audit, open audit socket */ - if (s->audit_fd >= 0 || no_sockets) { + if (m->audit_fd >= 0 || no_sockets) { log_info("Collecting audit messages is enabled."); - r = server_open_audit(s); + r = manager_open_audit(m); if (r < 0) return r; } else log_info("Collecting audit messages is disabled."); - r = server_open_varlink(s, varlink_socket, varlink_fd); + r = manager_open_varlink(m, varlink_socket, varlink_fd); if (r < 0) return r; - r = server_map_seqnum_file(s, "seqnum", sizeof(SeqnumData), (void**) &s->seqnum); + 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 = server_open_kernel_seqnum(s); + r = manager_open_kernel_seqnum(m); if (r < 0) return r; - r = server_open_hostname(s); + r = manager_open_hostname(m); if (r < 0) return r; - r = server_setup_signals(s); + r = manager_setup_signals(m); if (r < 0) return r; - r = server_setup_memory_pressure(s); + r = manager_setup_memory_pressure(m); if (r < 0) return r; - r = cg_get_root_path(&s->cgroup_root); + r = cg_get_root_path(&m->cgroup_root); if (r < 0) return log_error_errno(r, "Failed to acquire cgroup root path: %m"); - server_cache_hostname(s); - server_cache_boot_id(s); - server_cache_machine_id(s); + manager_cache_hostname(m); + manager_cache_boot_id(m); + manager_cache_machine_id(m); - if (s->namespace) - s->runtime_storage.path = strjoin("/run/log/journal/", SERVER_MACHINE_ID(s), ".", s->namespace); + if (m->namespace) + m->runtime_storage.path = strjoin("/run/log/journal/", MANAGER_MACHINE_ID(m), ".", m->namespace); else - s->runtime_storage.path = strjoin("/run/log/journal/", SERVER_MACHINE_ID(s)); - if (!s->runtime_storage.path) + 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) - s->system_storage.path = strdup(e); - else if (s->namespace) - s->system_storage.path = strjoin("/var/log/journal/", SERVER_MACHINE_ID(s), ".", s->namespace); + 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 - s->system_storage.path = strjoin("/var/log/journal/", SERVER_MACHINE_ID(s)); - if (!s->system_storage.path) + m->system_storage.path = strjoin("/var/log/journal/", MANAGER_MACHINE_ID(m)); + if (!m->system_storage.path) return log_oom(); - (void) server_connect_notify(s); + (void) manager_connect_notify(m); - (void) client_context_acquire_default(s); + (void) client_context_acquire_default(m); - r = server_system_journal_open(s, /* flush_requested= */ false, /* relinquish_requested= */ false); + r = manager_system_journal_open(m, /* flush_requested= */ false, /* relinquish_requested= */ false); if (r < 0) return r; - server_start_or_stop_idle_timer(s); + manager_start_or_stop_idle_timer(m); return 0; } -void server_maybe_append_tags(Server *s) { +void manager_maybe_append_tags(Manager *m) { #if HAVE_GCRYPT JournalFile *f; usec_t n; n = now(CLOCK_REALTIME); - if (s->system_journal) - journal_file_maybe_append_tag(s->system_journal, n); + if (m->system_journal) + journal_file_maybe_append_tag(m->system_journal, n); - ORDERED_HASHMAP_FOREACH(f, s->user_journals) + ORDERED_HASHMAP_FOREACH(f, m->user_journals) journal_file_maybe_append_tag(f, n); #endif } -Server* server_free(Server *s) { - if (!s) +Manager* manager_free(Manager *m) { + if (!m) return NULL; - free(s->namespace); - free(s->namespace_field); + free(m->namespace); + free(m->namespace_field); - set_free(s->deferred_closes); + set_free(m->deferred_closes); - while (s->stdout_streams) - stdout_stream_free(s->stdout_streams); + while (m->stdout_streams) + stdout_stream_free(m->stdout_streams); - client_context_flush_all(s); + client_context_flush_all(m); - (void) journal_file_offline_close(s->system_journal); - (void) journal_file_offline_close(s->runtime_journal); + (void) journal_file_offline_close(m->system_journal); + (void) journal_file_offline_close(m->runtime_journal); - ordered_hashmap_free(s->user_journals); + ordered_hashmap_free(m->user_journals); - sd_varlink_server_unref(s->varlink_server); + sd_varlink_server_unref(m->varlink_server); - sd_event_source_unref(s->syslog_event_source); - sd_event_source_unref(s->native_event_source); - sd_event_source_unref(s->stdout_event_source); - sd_event_source_unref(s->dev_kmsg_event_source); - sd_event_source_unref(s->audit_event_source); - sd_event_source_unref(s->sync_event_source); - sd_event_source_unref(s->sigusr1_event_source); - sd_event_source_unref(s->sigusr2_event_source); - sd_event_source_unref(s->sigterm_event_source); - sd_event_source_unref(s->sigint_event_source); - sd_event_source_unref(s->sigrtmin1_event_source); - sd_event_source_unref(s->hostname_event_source); - sd_event_source_unref(s->notify_event_source); - sd_event_source_unref(s->watchdog_event_source); - sd_event_source_unref(s->idle_event_source); - sd_event_unref(s->event); + 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(s->syslog_fd); - safe_close(s->native_fd); - safe_close(s->stdout_fd); - safe_close(s->dev_kmsg_fd); - safe_close(s->audit_fd); - safe_close(s->hostname_fd); - safe_close(s->notify_fd); - safe_close(s->forward_socket_fd); + 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(s->ratelimit_groups_by_id); + ordered_hashmap_free(m->ratelimit_groups_by_id); - server_unmap_seqnum_file(s->seqnum, sizeof(*s->seqnum)); - server_unmap_seqnum_file(s->kernel_seqnum, sizeof(*s->kernel_seqnum)); + manager_unmap_seqnum_file(m->seqnum, sizeof(*m->seqnum)); + manager_unmap_seqnum_file(m->kernel_seqnum, sizeof(*m->kernel_seqnum)); - free(s->buffer); - free(s->tty_path); - free(s->cgroup_root); - free(s->hostname_field); - free(s->runtime_storage.path); - free(s->system_storage.path); - free(s->runtime_directory); + free(m->buffer); + free(m->tty_path); + 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(s->mmap); + mmap_cache_unref(m->mmap); SyncReq *req; - while ((req = prioq_peek(s->sync_req_realtime_prioq))) + while ((req = prioq_peek(m->sync_req_realtime_prioq))) sync_req_free(req); - prioq_free(s->sync_req_realtime_prioq); + prioq_free(m->sync_req_realtime_prioq); - while ((req = prioq_peek(s->sync_req_boottime_prioq))) + while ((req = prioq_peek(m->sync_req_boottime_prioq))) sync_req_free(req); - prioq_free(s->sync_req_boottime_prioq); + prioq_free(m->sync_req_boottime_prioq); - return mfree(s); + return mfree(m); } static const char* const storage_table[_STORAGE_MAX] = { diff --git a/src/journal/journald-server.h b/src/journal/journald-manager.h similarity index 83% rename from src/journal/journald-server.h rename to src/journal/journald-manager.h index fd07ca8d077..32412fc6a19 100644 --- a/src/journal/journald-server.h +++ b/src/journal/journald-manager.h @@ -67,7 +67,7 @@ typedef struct SeqnumData { uint64_t seqnum; } SeqnumData; -typedef struct Server { +typedef struct Manager { char *namespace; int syslog_fd; @@ -195,9 +195,9 @@ typedef struct Server { /* Pending synchronization requests with non-zero rqlen counter */ LIST_HEAD(SyncReq, sync_req_pending_rqlen); -} Server; +} Manager; -#define SERVER_MACHINE_ID(s) ((s)->machine_id_field + STRLEN("_MACHINE_ID=")) +#define MANAGER_MACHINE_ID(s) ((s)->machine_id_field + STRLEN("_MACHINE_ID=")) /* Extra fields for any log messages */ #define N_IOVEC_META_FIELDS 24 @@ -217,9 +217,9 @@ typedef struct Server { /* audit: Maximum number of extra fields we'll import from audit messages */ #define N_IOVEC_AUDIT_FIELDS 64 -void server_dispatch_message(Server *s, struct iovec *iovec, size_t n, size_t m, ClientContext *c, const struct timeval *tv, int priority, pid_t object_pid); -void server_driver_message_internal(Server *s, pid_t object_pid, const char *format, ...) _sentinel_; -#define server_driver_message(...) server_driver_message_internal(__VA_ARGS__, NULL) +void manager_dispatch_message(Manager *m, struct iovec *iovec, size_t n, size_t k, ClientContext *c, const struct timeval *tv, int priority, pid_t object_pid); +void manager_driver_message_internal(Manager *m, pid_t object_pid, const char *format, ...) _sentinel_; +#define manager_driver_message(...) manager_driver_message_internal(__VA_ARGS__, NULL) /* gperf lookup function */ const struct ConfigPerfItem* journald_gperf_lookup(const char *key, GPERF_LEN_TYPE length); @@ -237,21 +237,21 @@ CONFIG_PARSER_PROTOTYPE(config_parse_split_mode); const char* split_mode_to_string(SplitMode s) _const_; SplitMode split_mode_from_string(const char *s) _pure_; -int server_new(Server **ret); -int server_init(Server *s, const char *namespace); -Server* server_free(Server *s); -DEFINE_TRIVIAL_CLEANUP_FUNC(Server*, server_free); -void server_full_sync(Server *s, bool wait); -void server_vacuum(Server *s, bool verbose); -void server_rotate(Server *s); -void server_full_rotate(Server *s); -int server_flush_to_var(Server *s, bool require_flag_file); -void server_full_flush(Server *s); -int server_relinquish_var(Server *s); -void server_maybe_append_tags(Server *s); -int server_process_datagram(sd_event_source *es, int fd, uint32_t revents, void *userdata); -void server_space_usage_message(Server *s, JournalStorage *storage); - -int server_start_or_stop_idle_timer(Server *s); - -int server_map_seqnum_file(Server *s, const char *fname, size_t size, void **ret); +int manager_new(Manager **ret); +int manager_init(Manager *m, const char *namespace); +Manager* manager_free(Manager *m); +DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free); +void manager_full_sync(Manager *m, bool wait); +void manager_vacuum(Manager *m, bool verbose); +void manager_rotate(Manager *m); +void manager_full_rotate(Manager *m); +int manager_flush_to_var(Manager *m, bool require_flag_file); +void manager_full_flush(Manager *m); +int manager_relinquish_var(Manager *m); +void manager_maybe_append_tags(Manager *m); +int manager_process_datagram(sd_event_source *es, int fd, uint32_t revents, void *userdata); +void manager_space_usage_message(Manager *m, JournalStorage *storage); + +int manager_start_or_stop_idle_timer(Manager *m); + +int manager_map_seqnum_file(Manager *m, const char *fname, size_t size, void **ret); diff --git a/src/journal/journald-native.c b/src/journal/journald-native.c index 2cb6e9e9884..db1131d5d81 100644 --- a/src/journal/journald-native.c +++ b/src/journal/journald-native.c @@ -16,8 +16,8 @@ #include "journald-client.h" #include "journald-console.h" #include "journald-kmsg.h" +#include "journald-manager.h" #include "journald-native.h" -#include "journald-server.h" #include "journald-syslog.h" #include "journald-wall.h" #include "memfd-util.h" @@ -36,7 +36,7 @@ static bool allow_object_pid(const struct ucred *ucred) { return ucred && ucred->uid == 0; } -static void server_process_entry_meta( +static void manager_process_entry_meta( const char *p, size_t l, const struct ucred *ucred, int *priority, @@ -91,8 +91,8 @@ static void server_process_entry_meta( } } -static int server_process_entry( - Server *s, +static int manager_process_entry( + Manager *m, const void *buffer, size_t *remaining, ClientContext *context, const struct ucred *ucred, @@ -175,7 +175,7 @@ static int server_process_entry( iovec[n++] = IOVEC_MAKE((char*) p, l); entry_size += l; - server_process_entry_meta(p, l, ucred, + manager_process_entry_meta(p, l, ucred, &priority, &identifier, &message, @@ -228,7 +228,7 @@ static int server_process_entry( entry_size += iovec[n].iov_len; n++; - server_process_entry_meta(k, (e - p) + 1 + l, ucred, + manager_process_entry_meta(k, (e - p) + 1 + l, ucred, &priority, &identifier, &message, @@ -260,26 +260,26 @@ static int server_process_entry( if (message) { /* Ensure message is not NULL, otherwise strlen(message) would crash. This check needs to - * be here until server_process_entry() is able to process messages containing \0 characters, + * be here until manager_process_entry() is able to process messages containing \0 characters, * as we would have access to the actual size of message. */ r = client_context_check_keep_log(context, message, strlen(message)); if (r <= 0) goto finish; - if (s->forward_to_syslog) - server_forward_syslog(s, syslog_fixup_facility(priority), identifier, message, ucred, tv); + if (m->forward_to_syslog) + manager_forward_syslog(m, syslog_fixup_facility(priority), identifier, message, ucred, tv); - if (s->forward_to_kmsg) - server_forward_kmsg(s, priority, identifier, message, ucred); + if (m->forward_to_kmsg) + manager_forward_kmsg(m, priority, identifier, message, ucred); - if (s->forward_to_console) - server_forward_console(s, priority, identifier, message, ucred); + if (m->forward_to_console) + manager_forward_console(m, priority, identifier, message, ucred); - if (s->forward_to_wall) - server_forward_wall(s, priority, identifier, message, ucred); + if (m->forward_to_wall) + manager_forward_wall(m, priority, identifier, message, ucred); } - server_dispatch_message(s, iovec, n, MALLOC_ELEMENTSOF(iovec), context, tv, priority, object_pid); + manager_dispatch_message(m, iovec, n, MALLOC_ELEMENTSOF(iovec), context, tv, priority, object_pid); finish: for (j = 0; j < n; j++) { @@ -298,8 +298,8 @@ finish: return r; } -void server_process_native_message( - Server *s, +void manager_process_native_message( + Manager *m, const char *buffer, size_t buffer_size, const struct ucred *ucred, const struct timeval *tv, @@ -309,11 +309,11 @@ void server_process_native_message( ClientContext *context = NULL; int r; - assert(s); + assert(m); assert(buffer || buffer_size == 0); if (ucred && pid_is_valid(ucred->pid)) { - r = client_context_get(s, ucred->pid, ucred, label, label_len, NULL, &context); + r = client_context_get(m, ucred->pid, ucred, label, label_len, NULL, &context); if (r < 0) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, "Failed to retrieve credentials for PID " PID_FMT ", ignoring: %m", @@ -321,14 +321,14 @@ void server_process_native_message( } do { - r = server_process_entry(s, + r = manager_process_entry(m, (const uint8_t*) buffer + (buffer_size - remaining), &remaining, context, ucred, tv, label, label_len); } while (r == 0); } -int server_process_native_file( - Server *s, +int manager_process_native_file( + Manager *m, int fd, const struct ucred *ucred, const struct timeval *tv, @@ -340,7 +340,7 @@ int server_process_native_file( /* Data is in the passed fd, probably it didn't fit in a datagram. */ - assert(s); + assert(m); assert(fd >= 0); if (fstat(fd, &st) < 0) @@ -409,7 +409,7 @@ int server_process_native_file( return log_ratelimit_error_errno(errno, JOURNAL_LOG_RATELIMIT, "Failed to map memfd: %m"); - server_process_native_message(s, p, st.st_size, ucred, tv, label, label_len); + manager_process_native_message(m, p, st.st_size, ucred, tv, label, label_len); assert_se(munmap(p, ps) >= 0); return 0; @@ -450,18 +450,18 @@ int server_process_native_file( return log_ratelimit_error_errno(errno, JOURNAL_LOG_RATELIMIT, "Failed to read file: %m"); if (n > 0) - server_process_native_message(s, p, n, ucred, tv, label, label_len); + manager_process_native_message(m, p, n, ucred, tv, label, label_len); return 0; } -int server_open_native_socket(Server *s, const char *native_socket) { +int manager_open_native_socket(Manager *m, const char *native_socket) { int r; - assert(s); + assert(m); assert(native_socket); - if (s->native_fd < 0) { + if (m->native_fd < 0) { union sockaddr_union sa; size_t sa_len; @@ -470,39 +470,39 @@ int server_open_native_socket(Server *s, const char *native_socket) { return log_error_errno(r, "Unable to use namespace path %s for AF_UNIX socket: %m", native_socket); sa_len = r; - s->native_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); - if (s->native_fd < 0) + m->native_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); + if (m->native_fd < 0) return log_error_errno(errno, "socket() failed: %m"); (void) sockaddr_un_unlink(&sa.un); - r = bind(s->native_fd, &sa.sa, sa_len); + r = bind(m->native_fd, &sa.sa, sa_len); if (r < 0) return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path); (void) chmod(sa.un.sun_path, 0666); } else - (void) fd_nonblock(s->native_fd, true); + (void) fd_nonblock(m->native_fd, true); - r = setsockopt_int(s->native_fd, SOL_SOCKET, SO_PASSCRED, true); + r = setsockopt_int(m->native_fd, SOL_SOCKET, SO_PASSCRED, true); if (r < 0) return log_error_errno(r, "SO_PASSCRED failed: %m"); if (mac_selinux_use()) { - r = setsockopt_int(s->native_fd, SOL_SOCKET, SO_PASSSEC, true); + r = setsockopt_int(m->native_fd, SOL_SOCKET, SO_PASSSEC, true); if (r < 0) log_warning_errno(r, "SO_PASSSEC failed: %m"); } - r = setsockopt_int(s->native_fd, SOL_SOCKET, SO_TIMESTAMP, true); + r = setsockopt_int(m->native_fd, SOL_SOCKET, SO_TIMESTAMP, true); if (r < 0) return log_error_errno(r, "SO_TIMESTAMP failed: %m"); - r = sd_event_add_io(s->event, &s->native_event_source, s->native_fd, EPOLLIN, server_process_datagram, s); + r = sd_event_add_io(m->event, &m->native_event_source, m->native_fd, EPOLLIN, manager_process_datagram, m); if (r < 0) - return log_error_errno(r, "Failed to add native server fd to event loop: %m"); + return log_error_errno(r, "Failed to add native manager fd to event loop: %m"); - r = sd_event_source_set_priority(s->native_event_source, SD_EVENT_PRIORITY_NORMAL+5); + r = sd_event_source_set_priority(m->native_event_source, SD_EVENT_PRIORITY_NORMAL+5); if (r < 0) return log_error_errno(r, "Failed to adjust native event source priority: %m"); diff --git a/src/journal/journald-native.h b/src/journal/journald-native.h index 3807b2ca974..ac8801f9de8 100644 --- a/src/journal/journald-native.h +++ b/src/journal/journald-native.h @@ -4,10 +4,10 @@ #include #include -typedef struct Server Server; +typedef struct Manager Manager; -void server_process_native_message( - Server *s, +void manager_process_native_message( + Manager *m, const char *buffer, size_t buffer_size, const struct ucred *ucred, @@ -15,12 +15,12 @@ void server_process_native_message( const char *label, size_t label_len); -int server_process_native_file( - Server *s, +int manager_process_native_file( + Manager *m, int fd, const struct ucred *ucred, const struct timeval *tv, const char *label, size_t label_len); -int server_open_native_socket(Server *s, const char *native_socket); +int manager_open_native_socket(Manager *m, const char *native_socket); diff --git a/src/journal/journald-socket.c b/src/journal/journald-socket.c index 9f419d393a7..a46b355fc5f 100644 --- a/src/journal/journald-socket.c +++ b/src/journal/journald-socket.c @@ -6,7 +6,7 @@ #include "fd-util.h" #include "iovec-util.h" -#include "journald-server.h" +#include "journald-manager.h" #include "journald-socket.h" #include "log.h" #include "macro.h" @@ -14,21 +14,21 @@ #include "socket-util.h" #include "sparse-endian.h" -static int server_open_forward_socket(Server *s) { +static int manager_open_forward_socket(Manager *m) { _cleanup_close_ int socket_fd = -EBADF; const SocketAddress *addr; int family; - assert(s); + assert(m); /* Noop if there is nothing to do. */ - if (s->forward_to_socket.sockaddr.sa.sa_family == AF_UNSPEC || s->namespace) + if (m->forward_to_socket.sockaddr.sa.sa_family == AF_UNSPEC || m->namespace) return 0; /* All ready, nothing to do. */ - if (s->forward_socket_fd >= 0) + if (m->forward_socket_fd >= 0) return 1; - addr = &s->forward_to_socket; + addr = &m->forward_to_socket; family = socket_address_family(addr); @@ -43,7 +43,7 @@ static int server_open_forward_socket(Server *s) { if (connect(socket_fd, &addr->sockaddr.sa, addr->size) < 0) return log_debug_errno(errno, "Failed to connect to remote address for forwarding, ignoring: %m"); - s->forward_socket_fd = TAKE_FD(socket_fd); + m->forward_socket_fd = TAKE_FD(socket_fd); log_debug("Successfully connected to remote address for forwarding."); return 1; } @@ -67,8 +67,8 @@ static inline bool must_serialize(struct iovec iov) { return false; } -int server_forward_socket( - Server *s, +int manager_forward_socket( + Manager *m, const struct iovec *iovec, size_t n_iovec, const dual_timestamp *ts, @@ -80,15 +80,15 @@ int server_forward_socket( le64_t *len; int r; - assert(s); + assert(m); assert(iovec); assert(n_iovec > 0); assert(ts); - if (LOG_PRI(priority) > s->max_level_socket) + if (LOG_PRI(priority) > m->max_level_socket) return 0; - r = server_open_forward_socket(s); + r = manager_open_forward_socket(m); if (r <= 0) return r; @@ -152,12 +152,12 @@ int server_forward_socket( xsprintf(monotonic_buf, "__MONOTONIC_TIMESTAMP="USEC_FMT"\n\n", ts->monotonic); iov[iov_idx++] = IOVEC_MAKE_STRING(monotonic_buf); - if (writev(s->forward_socket_fd, iov, iov_idx) < 0) { + if (writev(m->forward_socket_fd, iov, iov_idx) < 0) { log_debug_errno(errno, "Failed to forward log message over socket: %m"); /* If we failed to send once we will probably fail again so wait for a new connection to * establish before attempting to forward again. */ - s->forward_socket_fd = safe_close(s->forward_socket_fd); + m->forward_socket_fd = safe_close(m->forward_socket_fd); } return 0; diff --git a/src/journal/journald-socket.h b/src/journal/journald-socket.h index 3cddace1663..ee1813d5dff 100644 --- a/src/journal/journald-socket.h +++ b/src/journal/journald-socket.h @@ -5,6 +5,6 @@ #include "time-util.h" -typedef struct Server Server; +typedef struct Manager Manager; -int server_forward_socket(Server *s, const struct iovec *iovec, size_t n, const dual_timestamp *ts, int priority); +int manager_forward_socket(Manager *m, const struct iovec *iovec, size_t n, const dual_timestamp *ts, int priority); diff --git a/src/journal/journald-stream.c b/src/journal/journald-stream.c index 4afcc7be03e..be8edc0e445 100644 --- a/src/journal/journald-stream.c +++ b/src/journal/journald-stream.c @@ -25,7 +25,7 @@ #include "journald-console.h" #include "journald-context.h" #include "journald-kmsg.h" -#include "journald-server.h" +#include "journald-manager.h" #include "journald-stream.h" #include "journald-syslog.h" #include "journald-wall.h" @@ -69,16 +69,16 @@ StdoutStream* stdout_stream_free(StdoutStream *s) { while (s->stream_sync_reqs) stream_sync_req_free(s->stream_sync_reqs); - if (s->server) { + if (s->manager) { if (s->context) - client_context_release(s->server, s->context); + client_context_release(s->manager, s->context); - assert(s->server->n_stdout_streams > 0); - s->server->n_stdout_streams--; - LIST_REMOVE(stdout_stream, s->server->stdout_streams, s); + assert(s->manager->n_stdout_streams > 0); + s->manager->n_stdout_streams--; + LIST_REMOVE(stdout_stream, s->manager->stdout_streams, s); if (s->in_notify_queue) - LIST_REMOVE(stdout_stream_notify_queue, s->server->stdout_streams_notify_queue, s); + LIST_REMOVE(stdout_stream_notify_queue, s->manager->stdout_streams_notify_queue, s); } sd_event_source_disable_unref(s->event_source); @@ -108,9 +108,9 @@ void stdout_stream_terminate(StdoutStream *s) { sync_req_revalidate(TAKE_PTR(req)); } - Server *server = s->server; + Manager *manager = s->manager; stdout_stream_free(TAKE_PTR(s)); - (void) server_start_or_stop_idle_timer(server); /* Maybe we are idle now? */ + (void) manager_start_or_stop_idle_timer(manager); /* Maybe we are idle now? */ } static int stdout_stream_save(StdoutStream *s) { @@ -132,7 +132,7 @@ static int stdout_stream_save(StdoutStream *s) { "Failed to stat connected stream: %m"); /* We use device and inode numbers as identifier for the stream */ - r = asprintf(&s->state_file, "%s/streams/%lu:%lu", s->server->runtime_directory, (unsigned long) st.st_dev, (unsigned long) st.st_ino); + r = asprintf(&s->state_file, "%s/streams/%lu:%lu", s->manager->runtime_directory, (unsigned long) st.st_dev, (unsigned long) st.st_ino); if (r < 0) return log_oom(); } @@ -186,19 +186,18 @@ static int stdout_stream_save(StdoutStream *s) { if (r < 0) goto fail; - if (rename(temp_path, s->state_file) < 0) { - r = -errno; + r = RET_NERRNO(rename(temp_path, s->state_file)); + if (r < 0) goto fail; - } temp_path = mfree(temp_path); if (!s->fdstore && !s->in_notify_queue) { - LIST_PREPEND(stdout_stream_notify_queue, s->server->stdout_streams_notify_queue, s); + LIST_PREPEND(stdout_stream_notify_queue, s->manager->stdout_streams_notify_queue, s); s->in_notify_queue = true; - if (s->server->notify_event_source) { - r = sd_event_source_set_enabled(s->server->notify_event_source, SD_EVENT_ON); + if (s->manager->notify_event_source) { + r = sd_event_source_set_enabled(s->manager->notify_event_source, SD_EVENT_ON); if (r < 0) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, "Failed to enable notify event source: %m"); } @@ -232,9 +231,9 @@ static int stdout_stream_log( assert(line_break < _LINE_BREAK_MAX); if (s->context) - (void) client_context_maybe_refresh(s->server, s->context, NULL, NULL, 0, NULL, USEC_INFINITY); + (void) client_context_maybe_refresh(s->manager, s->context, NULL, NULL, 0, NULL, USEC_INFINITY); else if (pid_is_valid(s->ucred.pid)) { - r = client_context_acquire(s->server, s->ucred.pid, &s->ucred, s->label, strlen_ptr(s->label), s->unit_id, &s->context); + r = client_context_acquire(s->manager, s->ucred.pid, &s->ucred, s->label, strlen_ptr(s->label), s->unit_id, &s->context); if (r < 0) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, "Failed to acquire client context, ignoring: %m"); @@ -255,17 +254,17 @@ static int stdout_stream_log( if (r <= 0) return r; - if (s->forward_to_syslog || s->server->forward_to_syslog) - server_forward_syslog(s->server, syslog_fixup_facility(priority), s->identifier, p, &s->ucred, NULL); + if (s->forward_to_syslog || s->manager->forward_to_syslog) + manager_forward_syslog(s->manager, syslog_fixup_facility(priority), s->identifier, p, &s->ucred, NULL); - if (s->forward_to_kmsg || s->server->forward_to_kmsg) - server_forward_kmsg(s->server, priority, s->identifier, p, &s->ucred); + if (s->forward_to_kmsg || s->manager->forward_to_kmsg) + manager_forward_kmsg(s->manager, priority, s->identifier, p, &s->ucred); - if (s->forward_to_console || s->server->forward_to_console) - server_forward_console(s->server, priority, s->identifier, p, &s->ucred); + if (s->forward_to_console || s->manager->forward_to_console) + manager_forward_console(s->manager, priority, s->identifier, p, &s->ucred); - if (s->server->forward_to_wall) - server_forward_wall(s->server, priority, s->identifier, p, &s->ucred); + if (s->manager->forward_to_wall) + manager_forward_wall(s->manager, priority, s->identifier, p, &s->ucred); m = N_IOVEC_META_FIELDS + 7 + client_context_extra_fields_n_iovec(s->context); iovec = newa(struct iovec, m); @@ -306,7 +305,7 @@ static int stdout_stream_log( if (message) iovec[n++] = IOVEC_MAKE_STRING(message); - server_dispatch_message(s->server, iovec, n, m, s->context, NULL, priority, 0); + manager_dispatch_message(s->manager, iovec, n, m, s->context, NULL, priority, 0); return 0; } @@ -458,7 +457,7 @@ static size_t stdout_stream_line_max(StdoutStream *s) { return STDOUT_STREAM_SETUP_PROTOCOL_LINE_MAX; /* After the protocol's "setup" phase is complete, let's use whatever the user configured */ - return s->server->line_max; + return s->manager->line_max; } static int stdout_stream_scan( @@ -561,7 +560,7 @@ static int stdout_stream_process(sd_event_source *es, int fd, uint32_t revents, /* Try to make use of the allocated buffer in full, but never read more than the configured line size. Also, * always leave room for a terminating NUL we might need to add. */ - limit = MIN(allocated - 1, MAX(s->server->line_max, STDOUT_STREAM_SETUP_PROTOCOL_LINE_MAX)); + limit = MIN(allocated - 1, MAX(s->manager->line_max, STDOUT_STREAM_SETUP_PROTOCOL_LINE_MAX)); assert(s->length <= limit); iovec = IOVEC_MAKE(s->buffer + s->length, limit - s->length); @@ -591,7 +590,7 @@ static int stdout_stream_process(sd_event_source *es, int fd, uint32_t revents, if (r < 0) goto terminate; - s->context = client_context_release(s->server, s->context); + s->context = client_context_release(s->manager, s->context); p = s->buffer + s->length; } else { @@ -623,12 +622,12 @@ terminate: return 0; } -int stdout_stream_install(Server *s, int fd, StdoutStream **ret) { +int stdout_stream_install(Manager *m, int fd, StdoutStream **ret) { _cleanup_(stdout_stream_freep) StdoutStream *stream = NULL; sd_id128_t id; int r; - assert(s); + assert(m); assert(fd >= 0); r = sd_id128_randomize(&id); @@ -663,7 +662,7 @@ int stdout_stream_install(Server *s, int fd, StdoutStream **ret) { (void) shutdown(fd, SHUT_WR); - r = sd_event_add_io(s->event, &stream->event_source, fd, EPOLLIN, stdout_stream_process, stream); + r = sd_event_add_io(m->event, &stream->event_source, fd, EPOLLIN, stdout_stream_process, stream); if (r < 0) return log_ratelimit_error_errno(r, JOURNAL_LOG_RATELIMIT, "Failed to add stream to event loop: %m"); @@ -673,11 +672,11 @@ int stdout_stream_install(Server *s, int fd, StdoutStream **ret) { stream->fd = fd; - stream->server = s; - LIST_PREPEND(stdout_stream, s->stdout_streams, stream); - s->n_stdout_streams++; + stream->manager = m; + LIST_PREPEND(stdout_stream, m->stdout_streams, stream); + m->n_stdout_streams++; - (void) server_start_or_stop_idle_timer(s); /* Maybe no longer idle? */ + (void) manager_start_or_stop_idle_timer(m); /* Maybe no longer idle? */ if (ret) *ret = stream; @@ -688,7 +687,7 @@ int stdout_stream_install(Server *s, int fd, StdoutStream **ret) { static int stdout_stream_new(sd_event_source *es, int listen_fd, uint32_t revents, void *userdata) { _cleanup_close_ int fd = -EBADF; - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); int r; if (revents != EPOLLIN) @@ -696,7 +695,7 @@ static int stdout_stream_new(sd_event_source *es, int listen_fd, uint32_t revent "Got invalid event from epoll for stdout server fd: %" PRIx32, revents); - fd = accept4(s->stdout_fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC); + fd = accept4(m->stdout_fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC); if (fd < 0) { if (ERRNO_IS_ACCEPT_AGAIN(errno)) return 0; @@ -704,7 +703,7 @@ static int stdout_stream_new(sd_event_source *es, int listen_fd, uint32_t revent return log_ratelimit_error_errno(errno, JOURNAL_LOG_RATELIMIT, "Failed to accept stdout connection: %m"); } - if (s->n_stdout_streams >= STDOUT_STREAMS_MAX) { + if (m->n_stdout_streams >= STDOUT_STREAMS_MAX) { struct ucred u = UCRED_INVALID; (void) getpeercred(fd, &u); @@ -715,23 +714,23 @@ static int stdout_stream_new(sd_event_source *es, int listen_fd, uint32_t revent */ fd = safe_close(fd); - server_driver_message(s, u.pid, LOG_MESSAGE("Too many stdout streams, refusing connection.")); + manager_driver_message(m, u.pid, LOG_MESSAGE("Too many stdout streams, refusing connection.")); - server_notify_stream(s, /* stream= */ NULL); + manager_notify_stream(m, /* stream= */ NULL); return 0; } StdoutStream *stream; - r = stdout_stream_install(s, fd, &stream); + r = stdout_stream_install(m, fd, &stream); if (r < 0) { - server_notify_stream(s, /* stream= */ NULL); + manager_notify_stream(m, /* stream= */ NULL); return r; } TAKE_FD(fd); /* Tell the synchronization logic that we dropped one item from the incoming connection queue */ - server_notify_stream(s, stream); + manager_notify_stream(m, stream); return 0; } @@ -750,7 +749,7 @@ static int stdout_stream_load(StdoutStream *stream, const char *fname) { assert(fname); if (!stream->state_file) { - stream->state_file = path_join(stream->server->runtime_directory, "streams", fname); + stream->state_file = path_join(stream->manager->runtime_directory, "streams", fname); if (!stream->state_file) return log_oom(); } @@ -810,19 +809,19 @@ static int stdout_stream_load(StdoutStream *stream, const char *fname) { return 0; } -static int stdout_stream_restore(Server *s, const char *fname, int fd) { +static int stdout_stream_restore(Manager *m, const char *fname, int fd) { StdoutStream *stream; int r; - assert(s); + assert(m); assert(fname); assert(fd >= 0); - if (s->n_stdout_streams >= STDOUT_STREAMS_MAX) + if (m->n_stdout_streams >= STDOUT_STREAMS_MAX) return log_warning_errno(SYNTHETIC_ERRNO(ENOBUFS), "Too many stdout streams, refusing restoring of stream."); - r = stdout_stream_install(s, fd, &stream); + r = stdout_stream_install(m, fd, &stream); if (r < 0) return r; @@ -835,12 +834,12 @@ static int stdout_stream_restore(Server *s, const char *fname, int fd) { return 0; } -int server_restore_streams(Server *s, FDSet *fds) { +int manager_restore_streams(Manager *m, FDSet *fds) { _cleanup_closedir_ DIR *d = NULL; const char *path; int r; - path = strjoina(s->runtime_directory, "/streams"); + path = strjoina(m->runtime_directory, "/streams"); d = opendir(path); if (!d) { if (errno == ENOENT) @@ -879,7 +878,7 @@ int server_restore_streams(Server *s, FDSet *fds) { fdset_remove(fds, fd); - r = stdout_stream_restore(s, de->d_name, fd); + r = stdout_stream_restore(m, de->d_name, fd); if (r < 0) safe_close(fd); } @@ -890,13 +889,13 @@ fail: return log_error_errno(errno, "Failed to read streams directory: %m"); } -int server_open_stdout_socket(Server *s, const char *stdout_socket) { +int manager_open_stdout_socket(Manager *m, const char *stdout_socket) { int r; - assert(s); + assert(m); assert(stdout_socket); - if (s->stdout_fd < 0) { + if (m->stdout_fd < 0) { union sockaddr_union sa; socklen_t sa_len; @@ -905,28 +904,28 @@ int server_open_stdout_socket(Server *s, const char *stdout_socket) { return log_error_errno(r, "Unable to use namespace path %s for AF_UNIX socket: %m", stdout_socket); sa_len = r; - s->stdout_fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); - if (s->stdout_fd < 0) + m->stdout_fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); + if (m->stdout_fd < 0) return log_error_errno(errno, "socket() failed: %m"); (void) sockaddr_un_unlink(&sa.un); - r = bind(s->stdout_fd, &sa.sa, sa_len); + r = bind(m->stdout_fd, &sa.sa, sa_len); if (r < 0) return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path); (void) chmod(sa.un.sun_path, 0666); - if (listen(s->stdout_fd, SOMAXCONN_DELUXE) < 0) + if (listen(m->stdout_fd, SOMAXCONN_DELUXE) < 0) return log_error_errno(errno, "listen(%s) failed: %m", sa.un.sun_path); } else - (void) fd_nonblock(s->stdout_fd, true); + (void) fd_nonblock(m->stdout_fd, true); - r = sd_event_add_io(s->event, &s->stdout_event_source, s->stdout_fd, EPOLLIN, stdout_stream_new, s); + r = sd_event_add_io(m->event, &m->stdout_event_source, m->stdout_fd, EPOLLIN, stdout_stream_new, m); if (r < 0) return log_error_errno(r, "Failed to add stdout server fd to event source: %m"); - r = sd_event_source_set_priority(s->stdout_event_source, SD_EVENT_PRIORITY_NORMAL+5); + r = sd_event_source_set_priority(m->stdout_event_source, SD_EVENT_PRIORITY_NORMAL+5); if (r < 0) return log_error_errno(r, "Failed to adjust priority of stdout server event source: %m"); @@ -948,8 +947,8 @@ void stdout_stream_send_notify(StdoutStream *s) { assert(s); assert(!s->fdstore); assert(s->in_notify_queue); - assert(s->server); - assert(s->server->notify_fd >= 0); + assert(s->manager); + assert(s->manager->notify_fd >= 0); /* Store the connection fd in PID 1, so that we get it passed * in again on next start */ @@ -964,7 +963,7 @@ void stdout_stream_send_notify(StdoutStream *s) { memcpy(CMSG_DATA(cmsg), &s->fd, sizeof(int)); - l = sendmsg(s->server->notify_fd, &msghdr, MSG_DONTWAIT|MSG_NOSIGNAL); + l = sendmsg(s->manager->notify_fd, &msghdr, MSG_DONTWAIT|MSG_NOSIGNAL); if (l < 0) { if (errno == EAGAIN) return; @@ -975,6 +974,6 @@ void stdout_stream_send_notify(StdoutStream *s) { s->fdstore = 1; } - LIST_REMOVE(stdout_stream_notify_queue, s->server->stdout_streams_notify_queue, s); + LIST_REMOVE(stdout_stream_notify_queue, s->manager->stdout_streams_notify_queue, s); s->in_notify_queue = false; } diff --git a/src/journal/journald-stream.h b/src/journal/journald-stream.h index ba15b97a372..a22b1360494 100644 --- a/src/journal/journald-stream.h +++ b/src/journal/journald-stream.h @@ -1,7 +1,7 @@ /* SPDX-License-Identifier: LGPL-2.1-or-later */ #pragma once -typedef struct Server Server; +typedef struct Manager Manager; typedef struct StdoutStream StdoutStream; typedef struct StreamSyncReq StreamSyncReq; @@ -20,7 +20,7 @@ typedef enum StdoutStreamState { } StdoutStreamState; struct StdoutStream { - Server *server; + Manager *manager; StdoutStreamState state; int fd; @@ -55,10 +55,10 @@ struct StdoutStream { LIST_HEAD(StreamSyncReq, stream_sync_reqs); }; -int server_open_stdout_socket(Server *s, const char *stdout_socket); -int server_restore_streams(Server *s, FDSet *fds); +int manager_open_stdout_socket(Manager *m, const char *stdout_socket); +int manager_restore_streams(Manager *m, FDSet *fds); StdoutStream* stdout_stream_free(StdoutStream *s); -int stdout_stream_install(Server *s, int fd, StdoutStream **ret); +int stdout_stream_install(Manager *m, int fd, StdoutStream **ret); void stdout_stream_terminate(StdoutStream *s); void stdout_stream_send_notify(StdoutStream *s); diff --git a/src/journal/journald-sync.c b/src/journal/journald-sync.c index c3b8de74129..657a4937231 100644 --- a/src/journal/journald-sync.c +++ b/src/journal/journald-sync.c @@ -6,7 +6,7 @@ #include "sd-varlink.h" #include "io-util.h" -#include "journald-server.h" +#include "journald-manager.h" #include "journald-stream.h" #include "journald-sync.h" #include "journald-varlink.h" @@ -49,7 +49,7 @@ static bool sync_req_is_complete(SyncReq *req) { int r; assert(req); - assert(req->server); + assert(req->manager); /* In case the clock jumped backwards, let's adjust the timestamp, to guarantee reasonably quick * termination */ @@ -61,18 +61,18 @@ static bool sync_req_is_complete(SyncReq *req) { /* If this sync request is still in the priority queue it means we still need to check if * incoming message timestamps are now newer than then sync request timestamp. */ - if (req->server->native_fd >= 0 && - req->server->native_timestamp < req->realtime) { - r = fd_wait_for_event(req->server->native_fd, POLLIN, /* timeout= */ 0); + if (req->manager->native_fd >= 0 && + req->manager->native_timestamp < req->realtime) { + r = fd_wait_for_event(req->manager->native_fd, POLLIN, /* timeout= */ 0); if (r < 0) log_debug_errno(r, "Failed to determine pending IO events of native socket, ignoring: %m"); else if (r != 0) /* if there's more queued we need to wait for the timestamp to pass. If it's idle though we are done here. */ return false; } - if (req->server->syslog_fd >= 0&& - req->server->syslog_timestamp < req->realtime) { - r = fd_wait_for_event(req->server->syslog_fd, POLLIN, /* timeout= */ 0); + if (req->manager->syslog_fd >= 0&& + req->manager->syslog_timestamp < req->realtime) { + r = fd_wait_for_event(req->manager->syslog_fd, POLLIN, /* timeout= */ 0); if (r < 0) log_debug_errno(r, "Failed to determine pending IO events of syslog socket, ignoring: %m"); else if (r != 0) @@ -82,22 +82,22 @@ static bool sync_req_is_complete(SyncReq *req) { /* This sync request is fulfilled for the native + syslog datagram streams? Then, let's * remove this sync request from the priority queue, so that we dont need to consider it * anymore. */ - assert(prioq_remove(req->server->sync_req_realtime_prioq, req, &req->realtime_prioq_idx) > 0); + assert(prioq_remove(req->manager->sync_req_realtime_prioq, req, &req->realtime_prioq_idx) > 0); } if (req->boottime_prioq_idx != PRIOQ_IDX_NULL) { /* Very similar to the above, but for /dev/kmsg we operate on the CLOCK_BOOTTIME clock */ - if (req->server->dev_kmsg_fd >= 0 && - req->server->dev_kmsg_timestamp < req->boottime) { - r = fd_wait_for_event(req->server->dev_kmsg_fd, POLLIN, /* timeout= */ 0); + if (req->manager->dev_kmsg_fd >= 0 && + req->manager->dev_kmsg_timestamp < req->boottime) { + r = fd_wait_for_event(req->manager->dev_kmsg_fd, POLLIN, /* timeout= */ 0); if (r < 0) log_debug_errno(r, "Failed to determine pending IO events of /dev/kmsg file descriptor, ignoring: %m"); else if (r != 0) return false; } - assert(prioq_remove(req->server->sync_req_boottime_prioq, req, &req->boottime_prioq_idx) > 0); + assert(prioq_remove(req->manager->sync_req_boottime_prioq, req, &req->boottime_prioq_idx) > 0); } /* If there are still streams with pending counters, we still need to look into things */ @@ -127,15 +127,15 @@ SyncReq* sync_req_free(SyncReq *req) { if (!req) return NULL; - if (req->server) { + if (req->manager) { if (req->realtime_prioq_idx != PRIOQ_IDX_NULL) - assert_se(prioq_remove(req->server->sync_req_realtime_prioq, req, &req->realtime_prioq_idx) > 0); + assert_se(prioq_remove(req->manager->sync_req_realtime_prioq, req, &req->realtime_prioq_idx) > 0); if (req->boottime_prioq_idx != PRIOQ_IDX_NULL) - assert_se(prioq_remove(req->server->sync_req_boottime_prioq, req, &req->boottime_prioq_idx) > 0); + assert_se(prioq_remove(req->manager->sync_req_boottime_prioq, req, &req->boottime_prioq_idx) > 0); if (req->pending_rqlen > 0) - LIST_REMOVE(pending_rqlen, req->server->sync_req_pending_rqlen, req); + LIST_REMOVE(pending_rqlen, req->manager->sync_req_pending_rqlen, req); } req->idle_event_source = sd_event_source_disable_unref(req->idle_event_source); @@ -183,10 +183,10 @@ static int sync_req_add_stream(SyncReq *req, StdoutStream *ss) { return 1; } -int sync_req_new(Server *s, sd_varlink *link, SyncReq **ret) { +int sync_req_new(Manager *m, sd_varlink *link, SyncReq **ret) { int r; - assert(s); + assert(m); assert(link); assert(ret); @@ -195,7 +195,7 @@ int sync_req_new(Server *s, sd_varlink *link, SyncReq **ret) { return -ENOMEM; *req = (SyncReq) { - .server = s, + .manager = m, .link = sd_varlink_ref(link), .realtime_prioq_idx = PRIOQ_IDX_NULL, .boottime_prioq_idx = PRIOQ_IDX_NULL, @@ -239,19 +239,19 @@ int sync_req_new(Server *s, sd_varlink *link, SyncReq **ret) { req->realtime = now(CLOCK_REALTIME); req->boottime = now(CLOCK_BOOTTIME); - if (s->native_event_source || s->syslog_event_source) { - r = prioq_ensure_put(&s->sync_req_realtime_prioq, sync_req_realtime_compare, req, &req->realtime_prioq_idx); + if (m->native_event_source || m->syslog_event_source) { + r = prioq_ensure_put(&m->sync_req_realtime_prioq, sync_req_realtime_compare, req, &req->realtime_prioq_idx); if (r < 0) return r; } - if (s->dev_kmsg_event_source) { - r = prioq_ensure_put(&s->sync_req_boottime_prioq, sync_req_boottime_compare, req, &req->boottime_prioq_idx); + if (m->dev_kmsg_event_source) { + r = prioq_ensure_put(&m->sync_req_boottime_prioq, sync_req_boottime_compare, req, &req->boottime_prioq_idx); if (r < 0) return r; } - r = sd_event_add_defer(s->event, &req->idle_event_source, on_idle, req); + r = sd_event_add_defer(m->event, &req->idle_event_source, on_idle, req); if (r < 0) return r; @@ -263,7 +263,7 @@ int sync_req_new(Server *s, sd_varlink *link, SyncReq **ret) { /* Now determine the pending byte counter for each stdout stream. If non-zero allocate a * StreamSyncReq for the stream to keep track of it */ - LIST_FOREACH(stdout_stream, ss, s->stdout_streams) { + LIST_FOREACH(stdout_stream, ss, m->stdout_streams) { r = sync_req_add_stream(req, ss); if (r < 0) return r; @@ -271,11 +271,11 @@ int sync_req_new(Server *s, sd_varlink *link, SyncReq **ret) { /* Also track how many pending, incoming stream sockets there are currently, so that we process them * too */ - r = af_unix_get_qlen(s->stdout_fd, &req->pending_rqlen); + r = af_unix_get_qlen(m->stdout_fd, &req->pending_rqlen); if (r < 0) log_warning_errno(r, "Failed to determine current incoming queue length, ignoring: %m"); if (req->pending_rqlen > 0) - LIST_PREPEND(pending_rqlen, s->sync_req_pending_rqlen, req); + LIST_PREPEND(pending_rqlen, m->sync_req_pending_rqlen, req); *ret = TAKE_PTR(req); return 0; @@ -310,7 +310,7 @@ static void sync_req_advance_rqlen_revalidate(SyncReq *req, uint32_t current_rql /* If there are no more connections to wait for, remove us from the list of synchronization * requests with non-zero pending connection counters */ if (n == 0) - LIST_REMOVE(pending_rqlen, req->server->sync_req_pending_rqlen, req); + LIST_REMOVE(pending_rqlen, req->manager->sync_req_pending_rqlen, req); } req->pending_rqlen = n; @@ -318,26 +318,26 @@ static void sync_req_advance_rqlen_revalidate(SyncReq *req, uint32_t current_rql sync_req_revalidate(req); } -void server_notify_stream(Server *s, StdoutStream *ss) { +void manager_notify_stream(Manager *m, StdoutStream *ss) { int r; - assert(s); + assert(m); /* Invoked whenever a new connection was accept()ed, i.e. dropped off the queue of pending incoming * connections. */ - if (!s->sync_req_pending_rqlen) + if (!m->sync_req_pending_rqlen) return; uint32_t current_qlen; - r = af_unix_get_qlen(s->stdout_fd, ¤t_qlen); + r = af_unix_get_qlen(m->stdout_fd, ¤t_qlen); if (r < 0) { log_warning_errno(r, "Failed to determine current AF_UNIX stream socket pending connections, ignoring: %m"); current_qlen = UINT32_MAX; } - LIST_FOREACH(pending_rqlen, sr, s->sync_req_pending_rqlen) + LIST_FOREACH(pending_rqlen, sr, m->sync_req_pending_rqlen) /* NB: this might invalidate the SyncReq object! */ sync_req_advance_rqlen_revalidate(sr, current_qlen, ss); } @@ -355,18 +355,18 @@ bool sync_req_revalidate(SyncReq *req) { return true; } -void sync_req_revalidate_by_timestamp(Server *s) { - assert(s); +void sync_req_revalidate_by_timestamp(Manager *m) { + assert(m); /* Go through the pending sync requests by timestamp, and complete those for which a sync is now * complete. */ SyncReq *req; - while ((req = prioq_peek(s->sync_req_realtime_prioq))) + while ((req = prioq_peek(m->sync_req_realtime_prioq))) if (!sync_req_revalidate(req)) break; - while ((req = prioq_peek(s->sync_req_boottime_prioq))) + while ((req = prioq_peek(m->sync_req_boottime_prioq))) if (!sync_req_revalidate(req)) break; } diff --git a/src/journal/journald-sync.h b/src/journal/journald-sync.h index 3f6d3769dbe..5f042ece96a 100644 --- a/src/journal/journald-sync.h +++ b/src/journal/journald-sync.h @@ -1,7 +1,7 @@ /* SPDX-License-Identifier: LGPL-2.1-or-later */ #pragma once -typedef struct Server Server; +typedef struct Manager Manager; typedef struct StreamSyncReq StreamSyncReq; typedef struct SyncReq SyncReq; @@ -23,7 +23,7 @@ struct StreamSyncReq { /* Encapsulates a synchronization request */ struct SyncReq { - Server *server; + Manager *manager; sd_varlink *link; bool offline; /* if true, we'll offline the journal files after sync is complete */ @@ -46,11 +46,11 @@ StreamSyncReq *stream_sync_req_free(StreamSyncReq *ssr); DEFINE_TRIVIAL_CLEANUP_FUNC(StreamSyncReq*, stream_sync_req_free); void stream_sync_req_advance_revalidate(StreamSyncReq *ssr, size_t p); -int sync_req_new(Server *s, sd_varlink *link, SyncReq **ret); +int sync_req_new(Manager *m, sd_varlink *link, SyncReq **ret); SyncReq* sync_req_free(SyncReq *req); DEFINE_TRIVIAL_CLEANUP_FUNC(SyncReq*, sync_req_free); bool sync_req_revalidate(SyncReq *req); -void sync_req_revalidate_by_timestamp(Server *s); +void sync_req_revalidate_by_timestamp(Manager *m); -void server_notify_stream(Server *s, StdoutStream *ss); +void manager_notify_stream(Manager *m, StdoutStream *ss); diff --git a/src/journal/journald-syslog.c b/src/journal/journald-syslog.c index 5e6778fbbd7..24e0755cc52 100644 --- a/src/journal/journald-syslog.c +++ b/src/journal/journald-syslog.c @@ -14,7 +14,7 @@ #include "journald-client.h" #include "journald-console.h" #include "journald-kmsg.h" -#include "journald-server.h" +#include "journald-manager.h" #include "journald-syslog.h" #include "journald-wall.h" #include "process-util.h" @@ -28,7 +28,7 @@ #define WARN_FORWARD_SYSLOG_MISSED_USEC (30 * USEC_PER_SEC) static void forward_syslog_iovec( - Server *s, + Manager *m, const struct iovec *iovec, unsigned n_iovec, const struct ucred *ucred, @@ -45,11 +45,11 @@ static void forward_syslog_iovec( const char *j; int r; - assert(s); + assert(m); assert(iovec); assert(n_iovec > 0); - j = strjoina(s->runtime_directory, "/syslog"); + j = strjoina(m->runtime_directory, "/syslog"); r = sockaddr_un_set_path(&sa.un, j); if (r < 0) { log_debug_errno(r, "Forwarding socket path %s too long for AF_UNIX, not forwarding: %m", j); @@ -75,13 +75,13 @@ static void forward_syslog_iovec( /* Forward the syslog message we received via /dev/log to /run/systemd/syslog. Unfortunately we * currently can't set the SO_TIMESTAMP auxiliary data, and hence we don't. */ - if (sendmsg(s->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0) + if (sendmsg(m->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0) return; /* The socket is full? I guess the syslog implementation is * too slow, and we shouldn't wait for that... */ if (errno == EAGAIN) { - s->n_forward_syslog_missed++; + m->n_forward_syslog_missed++; return; } @@ -96,11 +96,11 @@ static void forward_syslog_iovec( u.pid = getpid_cached(); memcpy(CMSG_DATA(cmsg), &u, sizeof(struct ucred)); - if (sendmsg(s->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0) + if (sendmsg(m->syslog_fd, &msghdr, MSG_NOSIGNAL) >= 0) return; if (errno == EAGAIN) { - s->n_forward_syslog_missed++; + m->n_forward_syslog_missed++; return; } } @@ -109,20 +109,34 @@ static void forward_syslog_iovec( log_debug_errno(errno, "Failed to forward syslog message: %m"); } -static void forward_syslog_raw(Server *s, int priority, const char *buffer, size_t buffer_len, const struct ucred *ucred, const struct timeval *tv) { +static void forward_syslog_raw( + Manager *m, + int priority, + const char *buffer, + size_t buffer_len, + const struct ucred *ucred, + const struct timeval *tv) { + struct iovec iovec; - assert(s); + assert(m); assert(buffer); - if (LOG_PRI(priority) > s->max_level_syslog) + if (LOG_PRI(priority) > m->max_level_syslog) return; iovec = IOVEC_MAKE((char *) buffer, buffer_len); - forward_syslog_iovec(s, &iovec, 1, ucred, tv); + forward_syslog_iovec(m, &iovec, 1, ucred, tv); } -void server_forward_syslog(Server *s, int priority, const char *identifier, const char *message, const struct ucred *ucred, const struct timeval *tv) { +void manager_forward_syslog( + Manager *m, + int priority, + const char *identifier, + const char *message, + const struct ucred *ucred, + const struct timeval *tv) { + struct iovec iovec[5]; char header_priority[DECIMAL_STR_MAX(priority) + 3], header_time[64], header_pid[STRLEN("[]: ") + DECIMAL_STR_MAX(pid_t) + 1]; @@ -130,12 +144,12 @@ void server_forward_syslog(Server *s, int priority, const char *identifier, cons struct tm tm; _cleanup_free_ char *ident_buf = NULL; - assert(s); + assert(m); assert(priority >= 0); assert(priority <= 999); assert(message); - if (LOG_PRI(priority) > s->max_level_syslog) + if (LOG_PRI(priority) > m->max_level_syslog) return; /* First: priority field */ @@ -170,7 +184,7 @@ void server_forward_syslog(Server *s, int priority, const char *identifier, cons /* Fourth: message */ iovec[n++] = IOVEC_MAKE_STRING(message); - forward_syslog_iovec(s, iovec, n, ucred, tv); + forward_syslog_iovec(m, iovec, n, ucred, tv); } int syslog_fixup_facility(int priority) { @@ -303,8 +317,8 @@ static int syslog_skip_timestamp(const char **buf) { return p - t; } -void server_process_syslog_message( - Server *s, +void manager_process_syslog_message( + Manager *m, const char *buf, size_t raw_len, const struct ucred *ucred, @@ -320,10 +334,10 @@ void server_process_syslog_message( int priority = LOG_USER | LOG_INFO, r; ClientContext *context = NULL; struct iovec *iovec; - size_t n = 0, m, i, leading_ws, syslog_ts_len; + size_t n = 0, mm, i, leading_ws, syslog_ts_len; bool store_raw; - assert(s); + assert(m); assert(buf); /* The message cannot be empty. */ assert(raw_len > 0); @@ -332,7 +346,7 @@ void server_process_syslog_message( assert(buf[raw_len] == '\0'); if (ucred && pid_is_valid(ucred->pid)) { - r = client_context_get(s, ucred->pid, ucred, label, label_len, NULL, &context); + r = client_context_get(m, ucred->pid, ucred, label, label_len, NULL, &context); if (r < 0) log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT, "Failed to retrieve credentials for PID " PID_FMT ", ignoring: %m", @@ -384,20 +398,20 @@ void server_process_syslog_message( syslog_parse_identifier(&msg, &identifier, &pid); - if (s->forward_to_syslog) - forward_syslog_raw(s, priority, buf, raw_len, ucred, tv); + if (m->forward_to_syslog) + forward_syslog_raw(m, priority, buf, raw_len, ucred, tv); - if (s->forward_to_kmsg) - server_forward_kmsg(s, priority, identifier, msg, ucred); + if (m->forward_to_kmsg) + manager_forward_kmsg(m, priority, identifier, msg, ucred); - if (s->forward_to_console) - server_forward_console(s, priority, identifier, msg, ucred); + if (m->forward_to_console) + manager_forward_console(m, priority, identifier, msg, ucred); - if (s->forward_to_wall) - server_forward_wall(s, priority, identifier, msg, ucred); + if (m->forward_to_wall) + manager_forward_wall(m, priority, identifier, msg, ucred); - m = N_IOVEC_META_FIELDS + 8 + client_context_extra_fields_n_iovec(context); - iovec = newa(struct iovec, m); + mm = N_IOVEC_META_FIELDS + 8 + client_context_extra_fields_n_iovec(context); + iovec = newa(struct iovec, mm); iovec[n++] = IOVEC_MAKE_STRING("_TRANSPORT=syslog"); @@ -451,16 +465,16 @@ void server_process_syslog_message( iovec[n++] = IOVEC_MAKE(msg_raw, hlen + raw_len); } - server_dispatch_message(s, iovec, n, m, context, tv, priority, 0); + manager_dispatch_message(m, iovec, n, mm, context, tv, priority, 0); } -int server_open_syslog_socket(Server *s, const char *syslog_socket) { +int manager_open_syslog_socket(Manager *m, const char *syslog_socket) { int r; - assert(s); + assert(m); assert(syslog_socket); - if (s->syslog_fd < 0) { + if (m->syslog_fd < 0) { union sockaddr_union sa; socklen_t sa_len; @@ -469,62 +483,62 @@ int server_open_syslog_socket(Server *s, const char *syslog_socket) { return log_error_errno(r, "Unable to use namespace path %s for AF_UNIX socket: %m", syslog_socket); sa_len = r; - s->syslog_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); - if (s->syslog_fd < 0) + m->syslog_fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); + if (m->syslog_fd < 0) return log_error_errno(errno, "socket() failed: %m"); (void) sockaddr_un_unlink(&sa.un); - r = bind(s->syslog_fd, &sa.sa, sa_len); + r = bind(m->syslog_fd, &sa.sa, sa_len); if (r < 0) return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path); (void) chmod(sa.un.sun_path, 0666); } else - (void) fd_nonblock(s->syslog_fd, true); + (void) fd_nonblock(m->syslog_fd, true); - r = setsockopt_int(s->syslog_fd, SOL_SOCKET, SO_PASSCRED, true); + r = setsockopt_int(m->syslog_fd, SOL_SOCKET, SO_PASSCRED, true); if (r < 0) return log_error_errno(r, "SO_PASSCRED failed: %m"); if (mac_selinux_use()) { - r = setsockopt_int(s->syslog_fd, SOL_SOCKET, SO_PASSSEC, true); + r = setsockopt_int(m->syslog_fd, SOL_SOCKET, SO_PASSSEC, true); if (r < 0) log_warning_errno(r, "SO_PASSSEC failed: %m"); } - r = setsockopt_int(s->syslog_fd, SOL_SOCKET, SO_TIMESTAMP, true); + r = setsockopt_int(m->syslog_fd, SOL_SOCKET, SO_TIMESTAMP, true); if (r < 0) return log_error_errno(r, "SO_TIMESTAMP failed: %m"); - r = sd_event_add_io(s->event, &s->syslog_event_source, s->syslog_fd, EPOLLIN, server_process_datagram, s); + r = sd_event_add_io(m->event, &m->syslog_event_source, m->syslog_fd, EPOLLIN, manager_process_datagram, m); if (r < 0) - return log_error_errno(r, "Failed to add syslog server fd to event loop: %m"); + return log_error_errno(r, "Failed to add syslog sevrer fd to event loop: %m"); - r = sd_event_source_set_priority(s->syslog_event_source, SD_EVENT_PRIORITY_NORMAL+5); + r = sd_event_source_set_priority(m->syslog_event_source, SD_EVENT_PRIORITY_NORMAL+5); if (r < 0) return log_error_errno(r, "Failed to adjust syslog event source priority: %m"); return 0; } -void server_maybe_warn_forward_syslog_missed(Server *s) { +void manager_maybe_warn_forward_syslog_missed(Manager *m) { usec_t n; - assert(s); + assert(m); - if (s->n_forward_syslog_missed <= 0) + if (m->n_forward_syslog_missed <= 0) return; n = now(CLOCK_MONOTONIC); - if (s->last_warn_forward_syslog_missed + WARN_FORWARD_SYSLOG_MISSED_USEC > n) + if (m->last_warn_forward_syslog_missed + WARN_FORWARD_SYSLOG_MISSED_USEC > n) return; - server_driver_message(s, 0, - LOG_MESSAGE_ID(SD_MESSAGE_FORWARD_SYSLOG_MISSED_STR), - LOG_MESSAGE("Forwarding to syslog missed %u messages.", - s->n_forward_syslog_missed)); + manager_driver_message(m, 0, + LOG_MESSAGE_ID(SD_MESSAGE_FORWARD_SYSLOG_MISSED_STR), + LOG_MESSAGE("Forwarding to syslog missed %u messages.", + m->n_forward_syslog_missed)); - s->n_forward_syslog_missed = 0; - s->last_warn_forward_syslog_missed = n; + m->n_forward_syslog_missed = 0; + m->last_warn_forward_syslog_missed = n; } diff --git a/src/journal/journald-syslog.h b/src/journal/journald-syslog.h index ccb913d2ca3..71bfbcbc6c3 100644 --- a/src/journal/journald-syslog.h +++ b/src/journal/journald-syslog.h @@ -5,15 +5,15 @@ #include "macro.h" -typedef struct Server Server; +typedef struct Manager Manager; int syslog_fixup_facility(int priority) _const_; size_t syslog_parse_identifier(const char **buf, char **identifier, char **pid); -void server_forward_syslog(Server *s, int priority, const char *identifier, const char *message, const struct ucred *ucred, const struct timeval *tv); +void manager_forward_syslog(Manager *m, int priority, const char *identifier, const char *message, const struct ucred *ucred, const struct timeval *tv); -void server_process_syslog_message(Server *s, const char *buf, size_t buf_len, const struct ucred *ucred, const struct timeval *tv, const char *label, size_t label_len); -int server_open_syslog_socket(Server *s, const char *syslog_socket); +void manager_process_syslog_message(Manager *m, const char *buf, size_t buf_len, const struct ucred *ucred, const struct timeval *tv, const char *label, size_t label_len); +int manager_open_syslog_socket(Manager *m, const char *syslog_socket); -void server_maybe_warn_forward_syslog_missed(Server *s); +void manager_maybe_warn_forward_syslog_missed(Manager *m); diff --git a/src/journal/journald-varlink.c b/src/journal/journald-varlink.c index 1f9ad3ad3e5..63aed28d0bb 100644 --- a/src/journal/journald-varlink.c +++ b/src/journal/journald-varlink.c @@ -1,6 +1,6 @@ /* SPDX-License-Identifier: LGPL-2.1-or-later */ -#include "journald-server.h" +#include "journald-manager.h" #include "journald-sync.h" #include "journald-varlink.h" #include "varlink-io.systemd.Journal.h" @@ -17,11 +17,11 @@ void sync_req_varlink_reply(SyncReq *req) { * anymore. */ if (req->offline) - server_full_sync(req->server, /* wait = */ true); + manager_full_sync(req->manager, /* wait = */ true); /* Disconnect the SyncReq from the Varlink connection object, and free it */ _cleanup_(sd_varlink_unrefp) sd_varlink *vl = TAKE_PTR(req->link); - sd_varlink_set_userdata(vl, req->server); /* reinstall server object */ + sd_varlink_set_userdata(vl, req->manager); /* reinstall manager object */ req = sync_req_free(req); r = sd_varlink_reply(vl, NULL); @@ -37,7 +37,7 @@ static int vl_method_synchronize(sd_varlink *link, sd_json_variant *parameters, {} }; - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); int r; assert(link); @@ -66,7 +66,7 @@ static int vl_method_synchronize(sd_varlink *link, sd_json_variant *parameters, _cleanup_(sync_req_freep) SyncReq *sr = NULL; - r = sync_req_new(s, link, &sr); + r = sync_req_new(m, link, &sr); if (r < 0) return r; @@ -78,7 +78,7 @@ static int vl_method_synchronize(sd_varlink *link, sd_json_variant *parameters, } static int vl_method_rotate(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) { - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); int r; assert(link); @@ -92,13 +92,13 @@ static int vl_method_rotate(sd_varlink *link, sd_json_variant *parameters, sd_va return r; log_info("Received client request to rotate journal, rotating."); - server_full_rotate(s); + manager_full_rotate(m); return sd_varlink_reply(link, NULL); } static int vl_method_flush_to_var(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) { - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); int r; assert(link); @@ -111,17 +111,17 @@ static int vl_method_flush_to_var(sd_varlink *link, sd_json_variant *parameters, if (r < 0) return r; - if (s->namespace) + if (m->namespace) return sd_varlink_error(link, "io.systemd.Journal.NotSupportedByNamespaces", NULL); log_info("Received client request to flush runtime journal."); - server_full_flush(s); + manager_full_flush(m); return sd_varlink_reply(link, NULL); } static int vl_method_relinquish_var(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) { - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); int r; assert(link); @@ -134,65 +134,65 @@ static int vl_method_relinquish_var(sd_varlink *link, sd_json_variant *parameter if (r < 0) return r; - if (s->namespace) + if (m->namespace) return sd_varlink_error(link, "io.systemd.Journal.NotSupportedByNamespaces", NULL); - log_info("Received client request to relinquish %s access.", s->system_storage.path); - server_relinquish_var(s); + log_info("Received client request to relinquish %s access.", m->system_storage.path); + manager_relinquish_var(m); return sd_varlink_reply(link, NULL); } static int vl_connect(sd_varlink_server *server, sd_varlink *link, void *userdata) { - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); assert(server); assert(link); - (void) server_start_or_stop_idle_timer(s); /* maybe we are no longer idle */ + (void) manager_start_or_stop_idle_timer(m); /* maybe we are no longer idle */ return 0; } static void vl_disconnect(sd_varlink_server *server, sd_varlink *link, void *userdata) { - Server *s = ASSERT_PTR(userdata); + Manager *m = ASSERT_PTR(userdata); assert(server); assert(link); void *u = sd_varlink_get_userdata(link); - if (u != s) { + if (u != m) { /* If this is a Varlink connection that does not have the Server object as userdata, then it has a SyncReq object instead. Let's finish it. */ SyncReq *req = u; - sd_varlink_set_userdata(link, s); /* reinstall server object */ + sd_varlink_set_userdata(link, m); /* reinstall server object */ sync_req_free(req); } - (void) server_start_or_stop_idle_timer(s); /* maybe we are idle now */ + (void) manager_start_or_stop_idle_timer(m); /* maybe we are idle now */ } -int server_open_varlink(Server *s, const char *socket, int fd) { +int manager_open_varlink(Manager *m, const char *socket, int fd) { int r; - assert(s); + assert(m); r = varlink_server_new( - &s->varlink_server, + &m->varlink_server, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA, - s); + m); if (r < 0) return log_error_errno(r, "Failed to allocate varlink server object: %m"); r = sd_varlink_server_add_interface_many( - s->varlink_server, + m->varlink_server, &vl_interface_io_systemd_Journal, &vl_interface_io_systemd_service); if (r < 0) return log_error_errno(r, "Failed to add Journal interface to varlink server: %m"); r = sd_varlink_server_bind_method_many( - s->varlink_server, + m->varlink_server, "io.systemd.Journal.Synchronize", vl_method_synchronize, "io.systemd.Journal.Rotate", vl_method_rotate, "io.systemd.Journal.FlushToVar", vl_method_flush_to_var, @@ -203,22 +203,22 @@ int server_open_varlink(Server *s, const char *socket, int fd) { if (r < 0) return r; - r = sd_varlink_server_bind_connect(s->varlink_server, vl_connect); + r = sd_varlink_server_bind_connect(m->varlink_server, vl_connect); if (r < 0) return r; - r = sd_varlink_server_bind_disconnect(s->varlink_server, vl_disconnect); + r = sd_varlink_server_bind_disconnect(m->varlink_server, vl_disconnect); if (r < 0) return r; if (fd < 0) - r = sd_varlink_server_listen_address(s->varlink_server, socket, 0666); + r = sd_varlink_server_listen_address(m->varlink_server, socket, 0666); else - r = sd_varlink_server_listen_fd(s->varlink_server, fd); + r = sd_varlink_server_listen_fd(m->varlink_server, fd); if (r < 0) return r; - r = sd_varlink_server_attach_event(s->varlink_server, s->event, SD_EVENT_PRIORITY_NORMAL); + r = sd_varlink_server_attach_event(m->varlink_server, m->event, SD_EVENT_PRIORITY_NORMAL); if (r < 0) return r; diff --git a/src/journal/journald-varlink.h b/src/journal/journald-varlink.h index e2c3ce40a0d..352fef1f840 100644 --- a/src/journal/journald-varlink.h +++ b/src/journal/journald-varlink.h @@ -1,9 +1,9 @@ /* SPDX-License-Identifier: LGPL-2.1-or-later */ #pragma once -#include "journald-server.h" +#include "journald-manager.h" #include "journald-sync.h" -int server_open_varlink(Server *s, const char *socket, int fd); +int manager_open_varlink(Manager *m, const char *socket, int fd); void sync_req_varlink_reply(SyncReq *req); diff --git a/src/journal/journald-wall.c b/src/journal/journald-wall.c index 79eaac1068a..b700b86a96e 100644 --- a/src/journal/journald-wall.c +++ b/src/journal/journald-wall.c @@ -2,14 +2,14 @@ #include "alloc-util.h" #include "format-util.h" -#include "journald-server.h" +#include "journald-manager.h" #include "journald-wall.h" #include "process-util.h" #include "string-util.h" #include "wall.h" -void server_forward_wall( - Server *s, +void manager_forward_wall( + Manager *m, int priority, const char *identifier, const char *message, @@ -19,10 +19,10 @@ void server_forward_wall( const char *l; int r; - assert(s); + assert(m); assert(message); - if (LOG_PRI(priority) > s->max_level_wall) + if (LOG_PRI(priority) > m->max_level_wall) return; if (ucred) { diff --git a/src/journal/journald-wall.h b/src/journal/journald-wall.h index 8c19e496f46..c9979ce6f5e 100644 --- a/src/journal/journald-wall.h +++ b/src/journal/journald-wall.h @@ -3,6 +3,6 @@ #include -typedef struct Server Server; +typedef struct Manager Manager; -void server_forward_wall(Server *s, int priority, const char *identifier, const char *message, const struct ucred *ucred); +void manager_forward_wall(Manager *m, int priority, const char *identifier, const char *message, const struct ucred *ucred); diff --git a/src/journal/journald.c b/src/journal/journald.c index 975afaa9529..3c53063c395 100644 --- a/src/journal/journald.c +++ b/src/journal/journald.c @@ -8,7 +8,7 @@ #include "format-util.h" #include "journal-authenticate.h" #include "journald-kmsg.h" -#include "journald-server.h" +#include "journald-manager.h" #include "journald-syslog.h" #include "main-func.h" #include "process-util.h" @@ -16,7 +16,7 @@ #include "terminal-util.h" static int run(int argc, char *argv[]) { - _cleanup_(server_freep) Server *s = NULL; + _cleanup_(manager_freep) Manager *m = NULL; const char *namespace; LogTarget log_target; int r; @@ -48,83 +48,83 @@ static int run(int argc, char *argv[]) { sigbus_install(); - r = server_new(&s); + r = manager_new(&m); if (r < 0) return log_oom(); - r = server_init(s, namespace); + r = manager_init(m, namespace); if (r < 0) return r; - server_vacuum(s, /* verbose = */ false); - server_flush_to_var(s, /* require_flag_file = */ true); - server_flush_dev_kmsg(s); + manager_vacuum(m, /* verbose = */ false); + manager_flush_to_var(m, /* require_flag_file = */ true); + manager_flush_dev_kmsg(m); - if (s->namespace) - log_debug("systemd-journald running as PID "PID_FMT" for namespace '%s'.", getpid_cached(), s->namespace); + if (m->namespace) + log_debug("systemd-journald running as PID "PID_FMT" for namespace '%s'.", getpid_cached(), m->namespace); else log_debug("systemd-journald running as PID "PID_FMT" for the system.", getpid_cached()); - server_driver_message(s, 0, - LOG_MESSAGE_ID(SD_MESSAGE_JOURNAL_START_STR), - LOG_MESSAGE("Journal started")); + manager_driver_message(m, 0, + LOG_MESSAGE_ID(SD_MESSAGE_JOURNAL_START_STR), + LOG_MESSAGE("Journal started")); /* Make sure to send the usage message *after* flushing the * journal so entries from the runtime journals are ordered * before this message. See #4190 for some details. */ - server_space_usage_message(s, NULL); + manager_space_usage_message(m, NULL); for (;;) { usec_t t, n; - r = sd_event_get_state(s->event); + r = sd_event_get_state(m->event); if (r < 0) return log_error_errno(r, "Failed to get event loop state: %m"); if (r == SD_EVENT_FINISHED) break; - r = sd_event_now(s->event, CLOCK_REALTIME, &n); + r = sd_event_now(m->event, CLOCK_REALTIME, &n); if (r < 0) return log_error_errno(r, "Failed to get the current time: %m"); - if (s->max_retention_usec > 0 && s->oldest_file_usec > 0) { + if (m->max_retention_usec > 0 && m->oldest_file_usec > 0) { /* Calculate when to rotate the next time */ - t = usec_sub_unsigned(usec_add(s->oldest_file_usec, s->max_retention_usec), n); + t = usec_sub_unsigned(usec_add(m->oldest_file_usec, m->max_retention_usec), n); /* The retention time is reached, so let's vacuum! */ if (t <= 0) { log_info("Retention time reached, vacuuming."); - server_vacuum(s, /* verbose = */ false); + manager_vacuum(m, /* verbose = */ false); continue; } } else t = USEC_INFINITY; #if HAVE_GCRYPT - if (s->system_journal) { + if (m->system_journal) { usec_t u; - if (journal_file_next_evolve_usec(s->system_journal, &u)) + if (journal_file_next_evolve_usec(m->system_journal, &u)) t = MIN(t, usec_sub_unsigned(u, n)); } #endif - r = sd_event_run(s->event, t); + r = sd_event_run(m->event, t); if (r < 0) return log_error_errno(r, "Failed to run event loop: %m"); - server_maybe_append_tags(s); - server_maybe_warn_forward_syslog_missed(s); + manager_maybe_append_tags(m); + manager_maybe_warn_forward_syslog_missed(m); } - if (s->namespace) - log_debug("systemd-journald stopped as PID "PID_FMT" for namespace '%s'.", getpid_cached(), s->namespace); + if (m->namespace) + log_debug("systemd-journald stopped as PID "PID_FMT" for namespace '%s'.", getpid_cached(), m->namespace); else log_debug("systemd-journald stopped as PID "PID_FMT" for the system.", getpid_cached()); - server_driver_message(s, 0, - LOG_MESSAGE_ID(SD_MESSAGE_JOURNAL_STOP_STR), - LOG_MESSAGE("Journal stopped")); + manager_driver_message(m, 0, + LOG_MESSAGE_ID(SD_MESSAGE_JOURNAL_STOP_STR), + LOG_MESSAGE("Journal stopped")); return 0; } diff --git a/src/journal/meson.build b/src/journal/meson.build index 1b8d9831c1a..d0122c84958 100644 --- a/src/journal/meson.build +++ b/src/journal/meson.build @@ -9,9 +9,9 @@ systemd_journald_extract_sources = files( 'journald-console.c', 'journald-context.c', 'journald-kmsg.c', + 'journald-manager.c', 'journald-native.c', 'journald-rate-limit.c', - 'journald-server.c', 'journald-socket.c', 'journald-stream.c', 'journald-sync.c', diff --git a/src/journal/test-journald-config.c b/src/journal/test-journald-config.c index 900b1db44ab..25433827e0c 100644 --- a/src/journal/test-journald-config.c +++ b/src/journal/test-journald-config.c @@ -5,7 +5,7 @@ #include #include -#include "journald-server.h" +#include "journald-manager.h" #include "log.h" #include "path-util.h" #include "socket-util.h" diff --git a/src/journal/test-journald-tables.c b/src/journal/test-journald-tables.c index d726c3f3e3c..60b3ed59dd4 100644 --- a/src/journal/test-journald-tables.c +++ b/src/journal/test-journald-tables.c @@ -1,6 +1,6 @@ /* SPDX-License-Identifier: LGPL-2.1-or-later */ -#include "journald-server.h" +#include "journald-manager.h" #include "test-tables.h" #include "tests.h"