src/userdb/userdbd-manager.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <sys/wait.h>
   4
   5 #include "sd-daemon.h"
   6
   7 #include "build-path.h"
   8 #include "common-signal.h"
   9 #include "env-util.h"
  10 #include "fd-util.h"
  11 #include "fs-util.h"
  12 #include "mkdir.h"
  13 #include "process-util.h"
  14 #include "set.h"
  15 #include "signal-util.h"
  16 #include "socket-util.h"
  17 #include "stdio-util.h"
  18 #include "strv.h"
  19 #include "umask-util.h"
  20 #include "userdbd-manager.h"
  21
  22 #define LISTEN_TIMEOUT_USEC (25 * USEC_PER_SEC)
  23
  24 static int start_workers(Manager *m, bool explicit_request);
  25
  26 static int on_worker_exit(sd_event_source *s, const siginfo_t *si, void *userdata) {
  27         Manager *m = ASSERT_PTR(userdata);
  28
  29         assert(s);
  30
  31         assert_se(!set_remove(m->workers_dynamic, s) != !set_remove(m->workers_fixed, s));
  32         sd_event_source_disable_unref(s);
  33
  34         if (si->si_code == CLD_EXITED) {
  35                 if (si->si_status == EXIT_SUCCESS)
  36                         log_debug("Worker " PID_FMT " exited successfully.", si->si_pid);
  37                 else
  38                         log_warning("Worker " PID_FMT " died with a failure exit status %i, ignoring.", si->si_pid, si->si_status);
  39         } else if (si->si_code == CLD_KILLED)
  40                 log_warning("Worker " PID_FMT " was killed by signal %s, ignoring.", si->si_pid, signal_to_string(si->si_status));
  41         else if (si->si_code == CLD_DUMPED)
  42                 log_warning("Worker " PID_FMT " dumped core by signal %s, ignoring.", si->si_pid, signal_to_string(si->si_status));
  43         else
  44                 log_warning("Can't handle SIGCHLD of this type");
  45
  46         (void) start_workers(m, /* explicit_request= */ false); /* Fill up workers again if we fell below the low watermark */
  47         return 0;
  48 }
  49
  50 static int on_sigusr2(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
  51         Manager *m = ASSERT_PTR(userdata);
  52
  53         assert(s);
  54
  55         (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 */
  56         return 0;
  57 }
  58
  59 static int on_deferred_start_worker(sd_event_source *s, uint64_t usec, void *userdata) {
  60         Manager *m = ASSERT_PTR(userdata);
  61
  62         assert(s);
  63
  64         m->deferred_start_worker_event_source = sd_event_source_unref(m->deferred_start_worker_event_source);
  65
  66         (void) start_workers(m, /* explicit_request=*/ false);
  67         return 0;
  68 }
  69
  70 DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(
  71                 event_source_hash_ops,
  72                 sd_event_source,
  73                 (void (*)(const sd_event_source*, struct siphash*)) trivial_hash_func,
  74                 (int (*)(const sd_event_source*, const sd_event_source*)) trivial_compare_func,
  75                 sd_event_source_disable_unref);
  76
  77 int manager_new(Manager **ret) {
  78         _cleanup_(manager_freep) Manager *m = NULL;
  79         int r;
  80
  81         m = new(Manager, 1);
  82         if (!m)
  83                 return -ENOMEM;
  84
  85         *m = (Manager) {
  86                 .listen_fd = -EBADF,
  87                 .worker_ratelimit = {
  88                         .interval = 2 * USEC_PER_SEC,
  89                         .burst = 2500,
  90                 },
  91         };
  92
  93         r = sd_event_new(&m->event);
  94         if (r < 0)
  95                 return r;
  96
  97         r = sd_event_set_signal_exit(m->event, true);
  98         if (r < 0)
  99                 return r;
 100
 101         r = sd_event_add_signal(m->event, NULL, (SIGRTMIN+18)|SD_EVENT_SIGNAL_PROCMASK, sigrtmin18_handler, NULL);
 102         if (r < 0)
 103                 return r;
 104
 105         r = sd_event_add_memory_pressure(m->event, NULL, NULL, NULL);
 106         if (r < 0)
 107                 log_debug_errno(r, "Failed allocate memory pressure event source, ignoring: %m");
 108
 109         r = sd_event_set_watchdog(m->event, true);
 110         if (r < 0)
 111                 log_debug_errno(r, "Failed to enable watchdog handling, ignoring: %m");
 112
 113         r = sd_event_add_signal(m->event, NULL, SIGUSR2|SD_EVENT_SIGNAL_PROCMASK, on_sigusr2, m);
 114         if (r < 0)
 115                 return r;
 116
 117         *ret = TAKE_PTR(m);
 118         return 0;
 119 }
 120
 121 Manager* manager_free(Manager *m) {
 122         if (!m)
 123                 return NULL;
 124
 125         set_free(m->workers_fixed);
 126         set_free(m->workers_dynamic);
 127
 128         m->deferred_start_worker_event_source = sd_event_source_unref(m->deferred_start_worker_event_source);
 129
 130         safe_close(m->listen_fd);
 131
 132         sd_event_unref(m->event);
 133
 134         return mfree(m);
 135 }
 136
 137 static size_t manager_current_workers(Manager *m) {
 138         assert(m);
 139
 140         return set_size(m->workers_fixed) + set_size(m->workers_dynamic);
 141 }
 142
 143 static int start_one_worker(Manager *m) {
 144         _cleanup_(sd_event_source_disable_unrefp) sd_event_source *source = NULL;
 145         bool fixed;
 146         pid_t pid;
 147         int r;
 148
 149         assert(m);
 150
 151         fixed = set_size(m->workers_fixed) < USERDB_WORKERS_MIN;
 152
 153         r = safe_fork_full(
 154                         "(sd-worker)",
 155                         /* stdio_fds= */ NULL,
 156                         &m->listen_fd, 1,
 157                         FORK_RESET_SIGNALS|FORK_DEATHSIG_SIGTERM|FORK_REOPEN_LOG|FORK_LOG|FORK_CLOSE_ALL_FDS,
 158                         &pid);
 159         if (r < 0)
 160                 return log_error_errno(r, "Failed to fork new worker child: %m");
 161         if (r == 0) {
 162                 /* Child */
 163
 164                 if (m->listen_fd == 3) {
 165                         r = fd_cloexec(3, false);
 166                         if (r < 0) {
 167                                 log_error_errno(r, "Failed to turn off O_CLOEXEC for fd 3: %m");
 168                                 _exit(EXIT_FAILURE);
 169                         }
 170                 } else {
 171                         if (dup2(m->listen_fd, 3) < 0) { /* dup2() creates with O_CLOEXEC off */
 172                                 log_error_errno(errno, "Failed to move listen fd to 3: %m");
 173                                 _exit(EXIT_FAILURE);
 174                         }
 175
 176                         safe_close(m->listen_fd);
 177                 }
 178
 179                 r = setenvf("LISTEN_PID", /* overwrite= */ true, PID_FMT, pid);
 180                 if (r < 0) {
 181                         log_error_errno(r, "Failed to set $LISTEN_PID: %m");
 182                         _exit(EXIT_FAILURE);
 183                 }
 184
 185                 if (setenv("LISTEN_FDS", "1", 1) < 0) {
 186                         log_error_errno(errno, "Failed to set $LISTEN_FDS: %m");
 187                         _exit(EXIT_FAILURE);
 188                 }
 189
 190                 if (setenv("USERDB_FIXED_WORKER", one_zero(fixed), 1) < 0) {
 191                         log_error_errno(errno, "Failed to set $USERDB_FIXED_WORKER: %m");
 192                         _exit(EXIT_FAILURE);
 193                 }
 194
 195                 r = setenv_systemd_log_level();
 196                 if (r < 0) {
 197                         log_error_errno(r, "Failed to set $SYSTEMD_LOG_LEVEL: %m");
 198                         _exit(EXIT_FAILURE);
 199                 }
 200
 201                 r = invoke_callout_binary(SYSTEMD_USERWORK_PATH, STRV_MAKE(SYSTEMD_USERWORK_PATH, "xxxxxxxxxxxxxxxx")); /* With some extra space rename_process() can make use of */
 202                 log_error_errno(r, "Failed start worker process: %m");
 203                 _exit(EXIT_FAILURE);
 204         }
 205
 206         r = sd_event_add_child(m->event, &source, pid, WEXITED, on_worker_exit, m);
 207         if (r < 0)
 208                 return log_error_errno(r, "Failed to watch child " PID_FMT ": %m", pid);
 209
 210         r = set_ensure_put(
 211                         fixed ? &m->workers_fixed : &m->workers_dynamic,
 212                         &event_source_hash_ops,
 213                         source);
 214         if (r < 0)
 215                 return log_error_errno(r, "Failed to add child process to set: %m");
 216
 217         TAKE_PTR(source);
 218
 219         return 0;
 220 }
 221
 222 static int start_workers(Manager *m, bool explicit_request) {
 223         int r;
 224
 225         assert(m);
 226
 227         for (;;)  {
 228                 size_t n;
 229
 230                 n = manager_current_workers(m);
 231                 if (n >= USERDB_WORKERS_MIN && (!explicit_request || n >= USERDB_WORKERS_MAX))
 232                         break;
 233
 234                 if (!ratelimit_below(&m->worker_ratelimit)) {
 235
 236                         /* If we keep starting workers too often but none sticks, let's fail the whole
 237                          * daemon, something is wrong */
 238                         if (n == 0) {
 239                                 sd_event_exit(m->event, EXIT_FAILURE);
 240                                 return log_error_errno(SYNTHETIC_ERRNO(EUCLEAN), "Worker threads requested too frequently, but worker count is zero, something is wrong.");
 241                         }
 242
 243                         /* Otherwise, let's stop spawning more for a while. */
 244                         log_warning("Worker threads requested too frequently, not starting new ones for a while.");
 245
 246                         if (!m->deferred_start_worker_event_source) {
 247                                 r = sd_event_add_time(
 248                                                 m->event,
 249                                                 &m->deferred_start_worker_event_source,
 250                                                 CLOCK_MONOTONIC,
 251                                                 ratelimit_end(&m->worker_ratelimit),
 252                                                 /* accuracy_usec= */ 0,
 253                                                 on_deferred_start_worker,
 254                                                 m);
 255                                 if (r < 0)
 256                                         return log_error_errno(r, "Failed to allocate deferred start worker event source: %m");
 257                         }
 258
 259                         break;
 260                 }
 261
 262                 r = start_one_worker(m);
 263                 if (r < 0)
 264                         return r;
 265
 266                 explicit_request = false;
 267         }
 268
 269         return 0;
 270 }
 271
 272 static int manager_make_listen_socket(Manager *m) {
 273         static const union sockaddr_union sockaddr = {
 274                 .un.sun_family = AF_UNIX,
 275                 .un.sun_path = "/run/systemd/userdb/io.systemd.Multiplexer",
 276         };
 277         int r;
 278
 279         assert(m);
 280
 281         if (m->listen_fd >= 0)
 282                 return 0;
 283
 284         r = mkdir_p("/run/systemd/userdb", 0755);
 285         if (r < 0)
 286                 return log_error_errno(r, "Failed to create /run/systemd/userdb: %m");
 287
 288         m->listen_fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0);
 289         if (m->listen_fd < 0)
 290                 return log_error_errno(errno, "Failed to bind on socket: %m");
 291
 292         (void) sockaddr_un_unlink(&sockaddr.un);
 293
 294         WITH_UMASK(0000)
 295                 if (bind(m->listen_fd, &sockaddr.sa, SOCKADDR_UN_LEN(sockaddr.un)) < 0)
 296                         return log_error_errno(errno, "Failed to bind socket: %m");
 297
 298         FOREACH_STRING(alias,
 299                        "/run/systemd/userdb/io.systemd.NameServiceSwitch",
 300                        "/run/systemd/userdb/io.systemd.DropIn") {
 301
 302                 r = symlink_idempotent("io.systemd.Multiplexer", alias, /* make_relative= */ false);
 303                 if (r < 0)
 304                         return log_error_errno(r, "Failed to symlink '%s': %m", alias);
 305         }
 306
 307         if (listen(m->listen_fd, SOMAXCONN_DELUXE) < 0)
 308                 return log_error_errno(errno, "Failed to listen on socket: %m");
 309
 310         return 1;
 311 }
 312
 313 static int manager_scan_listen_fds(Manager *m) {
 314         int n;
 315
 316         assert(m);
 317
 318         n = sd_listen_fds(/* unset_environment= */ true);
 319         if (n < 0)
 320                 return log_error_errno(n, "Failed to determine number of passed file descriptors: %m");
 321         if (n > 1)
 322                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Expected one listening fd, got %i.", n);
 323         if (n == 1)
 324                 m->listen_fd = SD_LISTEN_FDS_START;
 325
 326         return 0;
 327 }
 328
 329 int manager_startup(Manager *m) {
 330         int r;
 331
 332         assert(m);
 333         assert(m->listen_fd < 0);
 334
 335         r = manager_scan_listen_fds(m);
 336         if (r < 0)
 337                 return r;
 338
 339         r = manager_make_listen_socket(m);
 340         if (r < 0)
 341                 return r;
 342
 343         /* Let's make sure every accept() call on this socket times out after 25s. This allows workers to be
 344          * GC'ed on idle */
 345         if (setsockopt(m->listen_fd, SOL_SOCKET, SO_RCVTIMEO, TIMEVAL_STORE(LISTEN_TIMEOUT_USEC), sizeof(struct timeval)) < 0)
 346                 return log_error_errno(errno, "Failed to se SO_RCVTIMEO: %m");
 347
 348         r = start_workers(m, /* explicit_request= */ false);
 349         if (r < 0)
 350                 return r;
 351
 352         return 0;
 353 }