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 = invoke_callout_binary(SYSTEMD_USERWORK_PATH, STRV_MAKE(SYSTEMD_USERWORK_PATH, "xxxxxxxxxxxxxxxx")); /* With some extra space rename_process() can make use of */
 196                 log_error_errno(r, "Failed start worker process: %m");
 197                 _exit(EXIT_FAILURE);
 198         }
 199
 200         r = sd_event_add_child(m->event, &source, pid, WEXITED, on_worker_exit, m);
 201         if (r < 0)
 202                 return log_error_errno(r, "Failed to watch child " PID_FMT ": %m", pid);
 203
 204         r = set_ensure_put(
 205                         fixed ? &m->workers_fixed : &m->workers_dynamic,
 206                         &event_source_hash_ops,
 207                         source);
 208         if (r < 0)
 209                 return log_error_errno(r, "Failed to add child process to set: %m");
 210
 211         TAKE_PTR(source);
 212
 213         return 0;
 214 }
 215
 216 static int start_workers(Manager *m, bool explicit_request) {
 217         int r;
 218
 219         assert(m);
 220
 221         for (;;)  {
 222                 size_t n;
 223
 224                 n = manager_current_workers(m);
 225                 if (n >= USERDB_WORKERS_MIN && (!explicit_request || n >= USERDB_WORKERS_MAX))
 226                         break;
 227
 228                 if (!ratelimit_below(&m->worker_ratelimit)) {
 229
 230                         /* If we keep starting workers too often but none sticks, let's fail the whole
 231                          * daemon, something is wrong */
 232                         if (n == 0) {
 233                                 sd_event_exit(m->event, EXIT_FAILURE);
 234                                 return log_error_errno(SYNTHETIC_ERRNO(EUCLEAN), "Worker threads requested too frequently, but worker count is zero, something is wrong.");
 235                         }
 236
 237                         /* Otherwise, let's stop spawning more for a while. */
 238                         log_warning("Worker threads requested too frequently, not starting new ones for a while.");
 239
 240                         if (!m->deferred_start_worker_event_source) {
 241                                 r = sd_event_add_time(
 242                                                 m->event,
 243                                                 &m->deferred_start_worker_event_source,
 244                                                 CLOCK_MONOTONIC,
 245                                                 ratelimit_end(&m->worker_ratelimit),
 246                                                 /* accuracy_usec= */ 0,
 247                                                 on_deferred_start_worker,
 248                                                 m);
 249                                 if (r < 0)
 250                                         return log_error_errno(r, "Failed to allocate deferred start worker event source: %m");
 251                         }
 252
 253                         break;
 254                 }
 255
 256                 r = start_one_worker(m);
 257                 if (r < 0)
 258                         return r;
 259
 260                 explicit_request = false;
 261         }
 262
 263         return 0;
 264 }
 265
 266 static int manager_make_listen_socket(Manager *m) {
 267         static const union sockaddr_union sockaddr = {
 268                 .un.sun_family = AF_UNIX,
 269                 .un.sun_path = "/run/systemd/userdb/io.systemd.Multiplexer",
 270         };
 271         int r;
 272
 273         assert(m);
 274
 275         if (m->listen_fd >= 0)
 276                 return 0;
 277
 278         r = mkdir_p("/run/systemd/userdb", 0755);
 279         if (r < 0)
 280                 return log_error_errno(r, "Failed to create /run/systemd/userdb: %m");
 281
 282         m->listen_fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0);
 283         if (m->listen_fd < 0)
 284                 return log_error_errno(errno, "Failed to bind on socket: %m");
 285
 286         (void) sockaddr_un_unlink(&sockaddr.un);
 287
 288         WITH_UMASK(0000)
 289                 if (bind(m->listen_fd, &sockaddr.sa, SOCKADDR_UN_LEN(sockaddr.un)) < 0)
 290                         return log_error_errno(errno, "Failed to bind socket: %m");
 291
 292         FOREACH_STRING(alias,
 293                        "/run/systemd/userdb/io.systemd.NameServiceSwitch",
 294                        "/run/systemd/userdb/io.systemd.DropIn") {
 295
 296                 r = symlink_idempotent("io.systemd.Multiplexer", alias, /* make_relative= */ false);
 297                 if (r < 0)
 298                         return log_error_errno(r, "Failed to symlink '%s': %m", alias);
 299         }
 300
 301         if (listen(m->listen_fd, SOMAXCONN_DELUXE) < 0)
 302                 return log_error_errno(errno, "Failed to listen on socket: %m");
 303
 304         return 1;
 305 }
 306
 307 static int manager_scan_listen_fds(Manager *m) {
 308         int n;
 309
 310         assert(m);
 311
 312         n = sd_listen_fds(/* unset_environment= */ true);
 313         if (n < 0)
 314                 return log_error_errno(n, "Failed to determine number of passed file descriptors: %m");
 315         if (n > 1)
 316                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Expected one listening fd, got %i.", n);
 317         if (n == 1)
 318                 m->listen_fd = SD_LISTEN_FDS_START;
 319
 320         return 0;
 321 }
 322
 323 int manager_startup(Manager *m) {
 324         int r;
 325
 326         assert(m);
 327         assert(m->listen_fd < 0);
 328
 329         r = manager_scan_listen_fds(m);
 330         if (r < 0)
 331                 return r;
 332
 333         r = manager_make_listen_socket(m);
 334         if (r < 0)
 335                 return r;
 336
 337         /* Let's make sure every accept() call on this socket times out after 25s. This allows workers to be
 338          * GC'ed on idle */
 339         if (setsockopt(m->listen_fd, SOL_SOCKET, SO_RCVTIMEO, TIMEVAL_STORE(LISTEN_TIMEOUT_USEC), sizeof(struct timeval)) < 0)
 340                 return log_error_errno(errno, "Failed to se SO_RCVTIMEO: %m");
 341
 342         r = start_workers(m, /* explicit_request= */ false);
 343         if (r < 0)
 344                 return r;
 345
 346         return 0;
 347 }