Michael Vogt
bd141bd818
The updated parsing_hacks.h file uncovered a bunch of extra things that the check-pointer-deref coccinelle script flags. This commit fixes them to make the tree check-pointer-deref clean.
366 lines
12 KiB
C
366 lines
12 KiB
C
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
|
|
#include "sd-daemon.h"
|
|
|
|
#include "alloc-util.h"
|
|
#include "build-path.h"
|
|
#include "common-signal.h"
|
|
#include "env-util.h"
|
|
#include "event-util.h"
|
|
#include "fd-util.h"
|
|
#include "format-util.h"
|
|
#include "fs-util.h"
|
|
#include "log.h"
|
|
#include "mkdir.h"
|
|
#include "pidfd-util.h"
|
|
#include "pidref.h"
|
|
#include "process-util.h"
|
|
#include "set.h"
|
|
#include "signal-util.h"
|
|
#include "socket-util.h"
|
|
#include "string-util.h"
|
|
#include "strv.h"
|
|
#include "time-util.h"
|
|
#include "umask-util.h"
|
|
#include "userdbd-manager.h"
|
|
|
|
#define LISTEN_TIMEOUT_USEC (25 * USEC_PER_SEC)
|
|
|
|
static int start_workers(Manager *m, bool explicit_request);
|
|
|
|
static int on_worker_exit(sd_event_source *s, const siginfo_t *si, void *userdata) {
|
|
Manager *m = ASSERT_PTR(userdata);
|
|
|
|
assert(s);
|
|
|
|
assert_se(!set_remove(m->workers_dynamic, s) != !set_remove(m->workers_fixed, s));
|
|
sd_event_source_disable_unref(s);
|
|
|
|
if (si->si_code == CLD_EXITED) {
|
|
if (si->si_status == EXIT_SUCCESS)
|
|
log_debug("Worker " PID_FMT " exited successfully.", si->si_pid);
|
|
else
|
|
log_warning("Worker " PID_FMT " died with a failure exit status %i, ignoring.", si->si_pid, si->si_status);
|
|
} else if (si->si_code == CLD_KILLED)
|
|
log_warning("Worker " PID_FMT " was killed by signal %s, ignoring.", si->si_pid, signal_to_string(si->si_status));
|
|
else if (si->si_code == CLD_DUMPED)
|
|
log_warning("Worker " PID_FMT " dumped core by signal %s, ignoring.", si->si_pid, signal_to_string(si->si_status));
|
|
else
|
|
log_warning("Can't handle exit code of this type");
|
|
|
|
(void) start_workers(m, /* explicit_request= */ false); /* Fill up workers again if we fell below the low watermark */
|
|
return 0;
|
|
}
|
|
|
|
static int on_sigusr2(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
|
|
Manager *m = ASSERT_PTR(userdata);
|
|
|
|
assert(s);
|
|
|
|
(void) start_workers(m, /* explicit_request= */ true); /* Workers told us there's more work, let's add one more worker as long as we are below the high watermark */
|
|
return 0;
|
|
}
|
|
|
|
static int on_deferred_start_worker(sd_event_source *s, uint64_t usec, void *userdata) {
|
|
Manager *m = ASSERT_PTR(userdata);
|
|
|
|
assert(s);
|
|
|
|
m->deferred_start_worker_event_source = sd_event_source_unref(m->deferred_start_worker_event_source);
|
|
|
|
(void) start_workers(m, /* explicit_request= */ false);
|
|
return 0;
|
|
}
|
|
|
|
int manager_new(Manager **ret) {
|
|
_cleanup_(manager_freep) Manager *m = NULL;
|
|
int r;
|
|
|
|
assert(ret);
|
|
|
|
m = new(Manager, 1);
|
|
if (!m)
|
|
return -ENOMEM;
|
|
|
|
*m = (Manager) {
|
|
.listen_fd = -EBADF,
|
|
.worker_ratelimit = {
|
|
.interval = 2 * USEC_PER_SEC,
|
|
.burst = 2500,
|
|
},
|
|
};
|
|
|
|
r = sd_event_new(&m->event);
|
|
if (r < 0)
|
|
return r;
|
|
|
|
r = sd_event_set_signal_exit(m->event, true);
|
|
if (r < 0)
|
|
return r;
|
|
|
|
r = sd_event_add_signal(m->event, NULL, (SIGRTMIN+18)|SD_EVENT_SIGNAL_PROCMASK, sigrtmin18_handler, NULL);
|
|
if (r < 0)
|
|
return r;
|
|
|
|
r = sd_event_add_memory_pressure(m->event, NULL, NULL, NULL);
|
|
if (r < 0)
|
|
log_debug_errno(r, "Failed to allocate memory pressure event source, ignoring: %m");
|
|
|
|
r = sd_event_set_watchdog(m->event, true);
|
|
if (r < 0)
|
|
log_debug_errno(r, "Failed to enable watchdog handling, ignoring: %m");
|
|
|
|
r = sd_event_add_signal(m->event, NULL, SIGUSR2|SD_EVENT_SIGNAL_PROCMASK, on_sigusr2, m);
|
|
if (r < 0)
|
|
return r;
|
|
|
|
*ret = TAKE_PTR(m);
|
|
return 0;
|
|
}
|
|
|
|
Manager* manager_free(Manager *m) {
|
|
if (!m)
|
|
return NULL;
|
|
|
|
set_free(m->workers_fixed);
|
|
set_free(m->workers_dynamic);
|
|
|
|
m->deferred_start_worker_event_source = sd_event_source_unref(m->deferred_start_worker_event_source);
|
|
|
|
safe_close(m->listen_fd);
|
|
|
|
sd_event_unref(m->event);
|
|
|
|
return mfree(m);
|
|
}
|
|
|
|
static size_t manager_current_workers(Manager *m) {
|
|
assert(m);
|
|
|
|
return set_size(m->workers_fixed) + set_size(m->workers_dynamic);
|
|
}
|
|
|
|
static int start_one_worker(Manager *m) {
|
|
_cleanup_(sd_event_source_disable_unrefp) sd_event_source *source = NULL;
|
|
bool fixed;
|
|
int r;
|
|
|
|
assert(m);
|
|
|
|
fixed = set_size(m->workers_fixed) < USERDB_WORKERS_MIN;
|
|
|
|
_cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
|
|
r = pidref_safe_fork_full(
|
|
"(sd-worker)",
|
|
/* stdio_fds= */ NULL,
|
|
&m->listen_fd, 1,
|
|
FORK_RESET_SIGNALS|FORK_DEATHSIG_SIGTERM|FORK_REOPEN_LOG|FORK_LOG|FORK_CLOSE_ALL_FDS,
|
|
&pidref);
|
|
if (r < 0)
|
|
return log_error_errno(r, "Failed to fork new worker child: %m");
|
|
if (r == 0) {
|
|
/* Child */
|
|
|
|
if (m->listen_fd == 3) {
|
|
r = fd_cloexec(3, false);
|
|
if (r < 0) {
|
|
log_error_errno(r, "Failed to turn off O_CLOEXEC for fd 3: %m");
|
|
_exit(EXIT_FAILURE);
|
|
}
|
|
} else {
|
|
if (dup2(m->listen_fd, 3) < 0) { /* dup2() creates with O_CLOEXEC off */
|
|
log_error_errno(errno, "Failed to move listen fd to 3: %m");
|
|
_exit(EXIT_FAILURE);
|
|
}
|
|
|
|
safe_close(m->listen_fd);
|
|
}
|
|
|
|
r = setenvf("LISTEN_PID", /* overwrite= */ true, PID_FMT, pidref.pid);
|
|
if (r < 0) {
|
|
log_error_errno(r, "Failed to set $LISTEN_PID: %m");
|
|
_exit(EXIT_FAILURE);
|
|
}
|
|
|
|
uint64_t pidfdid;
|
|
if (pidfd_get_inode_id_self_cached(&pidfdid) >= 0) {
|
|
r = setenvf("LISTEN_PIDFDID", true, "%" PRIu64, pidfdid);
|
|
if (r < 0) {
|
|
log_error_errno(r, "Failed to set $LISTEN_PIDFDID: %m");
|
|
_exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
if (setenv("LISTEN_FDS", "1", 1) < 0) {
|
|
log_error_errno(errno, "Failed to set $LISTEN_FDS: %m");
|
|
_exit(EXIT_FAILURE);
|
|
}
|
|
|
|
if (setenv("USERDB_FIXED_WORKER", one_zero(fixed), 1) < 0) {
|
|
log_error_errno(errno, "Failed to set $USERDB_FIXED_WORKER: %m");
|
|
_exit(EXIT_FAILURE);
|
|
}
|
|
|
|
r = setenv_systemd_log_level();
|
|
if (r < 0) {
|
|
log_error_errno(r, "Failed to set $SYSTEMD_LOG_LEVEL: %m");
|
|
_exit(EXIT_FAILURE);
|
|
}
|
|
|
|
r = invoke_callout_binary(SYSTEMD_USERWORK_PATH, STRV_MAKE(SYSTEMD_USERWORK_PATH, "xxxxxxxxxxxxxxxx")); /* With some extra space rename_process() can make use of */
|
|
log_error_errno(r, "Failed to start worker process: %m");
|
|
_exit(EXIT_FAILURE);
|
|
}
|
|
|
|
r = event_add_child_pidref(m->event, &source, &pidref, WEXITED, on_worker_exit, m);
|
|
if (r < 0)
|
|
return log_error_errno(r, "Failed to watch child " PID_FMT ": %m", pidref.pid);
|
|
|
|
r = set_ensure_put(
|
|
fixed ? &m->workers_fixed : &m->workers_dynamic,
|
|
&event_source_hash_ops,
|
|
source);
|
|
if (r < 0)
|
|
return log_error_errno(r, "Failed to add child process to set: %m");
|
|
|
|
TAKE_PTR(source);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int start_workers(Manager *m, bool explicit_request) {
|
|
int r;
|
|
|
|
assert(m);
|
|
|
|
for (;;) {
|
|
size_t n;
|
|
|
|
n = manager_current_workers(m);
|
|
if (n >= USERDB_WORKERS_MIN && (!explicit_request || n >= USERDB_WORKERS_MAX))
|
|
break;
|
|
|
|
if (!ratelimit_below(&m->worker_ratelimit)) {
|
|
|
|
/* If we keep starting workers too often but none sticks, let's fail the whole
|
|
* daemon, something is wrong */
|
|
if (n == 0) {
|
|
sd_event_exit(m->event, EXIT_FAILURE);
|
|
return log_error_errno(SYNTHETIC_ERRNO(EUCLEAN), "Worker threads requested too frequently, but worker count is zero, something is wrong.");
|
|
}
|
|
|
|
/* Otherwise, let's stop spawning more for a while. */
|
|
log_warning("Worker threads requested too frequently, not starting new ones for a while.");
|
|
|
|
if (!m->deferred_start_worker_event_source) {
|
|
r = sd_event_add_time(
|
|
m->event,
|
|
&m->deferred_start_worker_event_source,
|
|
CLOCK_MONOTONIC,
|
|
ratelimit_end(&m->worker_ratelimit),
|
|
/* accuracy= */ 0,
|
|
on_deferred_start_worker,
|
|
m);
|
|
if (r < 0)
|
|
return log_error_errno(r, "Failed to allocate deferred start worker event source: %m");
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
r = start_one_worker(m);
|
|
if (r < 0)
|
|
return r;
|
|
|
|
explicit_request = false;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int manager_make_listen_socket(Manager *m) {
|
|
static const union sockaddr_union sockaddr = {
|
|
.un.sun_family = AF_UNIX,
|
|
.un.sun_path = "/run/systemd/userdb/io.systemd.Multiplexer",
|
|
};
|
|
int r;
|
|
|
|
assert(m);
|
|
|
|
if (m->listen_fd >= 0)
|
|
return 0;
|
|
|
|
r = mkdir_p("/run/systemd/userdb", 0755);
|
|
if (r < 0)
|
|
return log_error_errno(r, "Failed to create /run/systemd/userdb: %m");
|
|
|
|
m->listen_fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0);
|
|
if (m->listen_fd < 0)
|
|
return log_error_errno(errno, "Failed to bind on socket: %m");
|
|
|
|
(void) sockaddr_un_unlink(&sockaddr.un);
|
|
|
|
WITH_UMASK(0000)
|
|
if (bind(m->listen_fd, &sockaddr.sa, sockaddr_un_len(&sockaddr.un)) < 0)
|
|
return log_error_errno(errno, "Failed to bind socket: %m");
|
|
|
|
FOREACH_STRING(alias,
|
|
"/run/systemd/userdb/io.systemd.NameServiceSwitch",
|
|
"/run/systemd/userdb/io.systemd.DropIn") {
|
|
|
|
r = symlink_idempotent("io.systemd.Multiplexer", alias, /* make_relative= */ false);
|
|
if (r < 0)
|
|
return log_error_errno(r, "Failed to symlink '%s': %m", alias);
|
|
}
|
|
|
|
if (listen(m->listen_fd, SOMAXCONN_DELUXE) < 0)
|
|
return log_error_errno(errno, "Failed to listen on socket: %m");
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int manager_scan_listen_fds(Manager *m) {
|
|
int n;
|
|
|
|
assert(m);
|
|
|
|
n = sd_listen_fds(/* unset_environment= */ true);
|
|
if (n < 0)
|
|
return log_error_errno(n, "Failed to determine number of passed file descriptors: %m");
|
|
if (n > 1)
|
|
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Expected one listening fd, got %i.", n);
|
|
if (n == 1)
|
|
m->listen_fd = SD_LISTEN_FDS_START;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int manager_startup(Manager *m) {
|
|
int r;
|
|
|
|
assert(m);
|
|
assert(m->listen_fd < 0);
|
|
|
|
r = manager_scan_listen_fds(m);
|
|
if (r < 0)
|
|
return r;
|
|
|
|
r = manager_make_listen_socket(m);
|
|
if (r < 0)
|
|
return r;
|
|
|
|
/* Let's make sure every accept() call on this socket times out after 25s. This allows workers to be
|
|
* GC'ed on idle */
|
|
if (setsockopt(m->listen_fd, SOL_SOCKET, SO_RCVTIMEO, TIMEVAL_STORE(LISTEN_TIMEOUT_USEC), sizeof(struct timeval)) < 0)
|
|
return log_error_errno(errno, "Failed to se SO_RCVTIMEO: %m");
|
|
|
|
r = start_workers(m, /* explicit_request= */ false);
|
|
if (r < 0)
|
|
return r;
|
|
|
|
return 0;
|
|
}
|