src/core/manager.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <linux/kd.h>
  24 #include <signal.h>
  25 #include <stdio_ext.h>
  26 #include <string.h>
  27 #include <sys/epoll.h>
  28 #include <sys/inotify.h>
  29 #include <sys/ioctl.h>
  30 #include <sys/reboot.h>
  31 #include <sys/timerfd.h>
  32 #include <sys/wait.h>
  33 #include <unistd.h>
  34
  35 #if HAVE_AUDIT
  36 #include <libaudit.h>
  37 #endif
  38
  39 #include "sd-daemon.h"
  40 #include "sd-messages.h"
  41 #include "sd-path.h"
  42
  43 #include "alloc-util.h"
  44 #include "audit-fd.h"
  45 #include "boot-timestamps.h"
  46 #include "bus-common-errors.h"
  47 #include "bus-error.h"
  48 #include "bus-kernel.h"
  49 #include "bus-util.h"
  50 #include "clean-ipc.h"
  51 #include "clock-util.h"
  52 #include "dbus-job.h"
  53 #include "dbus-manager.h"
  54 #include "dbus-unit.h"
  55 #include "dbus.h"
  56 #include "dirent-util.h"
  57 #include "env-util.h"
  58 #include "escape.h"
  59 #include "exec-util.h"
  60 #include "execute.h"
  61 #include "exit-status.h"
  62 #include "fd-util.h"
  63 #include "fileio.h"
  64 #include "fs-util.h"
  65 #include "hashmap.h"
  66 #include "io-util.h"
  67 #include "label.h"
  68 #include "locale-setup.h"
  69 #include "log.h"
  70 #include "macro.h"
  71 #include "manager.h"
  72 #include "missing.h"
  73 #include "mkdir.h"
  74 #include "parse-util.h"
  75 #include "path-lookup.h"
  76 #include "path-util.h"
  77 #include "process-util.h"
  78 #include "ratelimit.h"
  79 #include "rm-rf.h"
  80 #include "signal-util.h"
  81 #include "special.h"
  82 #include "stat-util.h"
  83 #include "string-table.h"
  84 #include "string-util.h"
  85 #include "strv.h"
  86 #include "terminal-util.h"
  87 #include "time-util.h"
  88 #include "transaction.h"
  89 #include "umask-util.h"
  90 #include "unit-name.h"
  91 #include "user-util.h"
  92 #include "util.h"
  93 #include "virt.h"
  94 #include "watchdog.h"
  95
  96 #define NOTIFY_RCVBUF_SIZE (8*1024*1024)
  97 #define CGROUPS_AGENT_RCVBUF_SIZE (8*1024*1024)
  98
  99 /* Initial delay and the interval for printing status messages about running jobs */
 100 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
 101 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
 102 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
 103
 104 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
 105 static int manager_dispatch_cgroups_agent_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
 106 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
 107 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
 108 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
 109 static int manager_dispatch_user_lookup_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
 110 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
 111 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
 112 static int manager_dispatch_sigchld(sd_event_source *source, void *userdata);
 113 static int manager_run_environment_generators(Manager *m);
 114 static int manager_run_generators(Manager *m);
 115
 116 static void manager_watch_jobs_in_progress(Manager *m) {
 117         usec_t next;
 118         int r;
 119
 120         assert(m);
 121
 122         /* We do not want to show the cylon animation if the user
 123          * needs to confirm service executions otherwise confirmation
 124          * messages will be screwed by the cylon animation. */
 125         if (!manager_is_confirm_spawn_disabled(m))
 126                 return;
 127
 128         if (m->jobs_in_progress_event_source)
 129                 return;
 130
 131         next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC;
 132         r = sd_event_add_time(
 133                         m->event,
 134                         &m->jobs_in_progress_event_source,
 135                         CLOCK_MONOTONIC,
 136                         next, 0,
 137                         manager_dispatch_jobs_in_progress, m);
 138         if (r < 0)
 139                 return;
 140
 141         (void) sd_event_source_set_description(m->jobs_in_progress_event_source, "manager-jobs-in-progress");
 142 }
 143
 144 #define CYLON_BUFFER_EXTRA (2*STRLEN(ANSI_RED) + STRLEN(ANSI_HIGHLIGHT_RED) + 2*STRLEN(ANSI_NORMAL))
 145
 146 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
 147         char *p = buffer;
 148
 149         assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
 150         assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
 151
 152         if (pos > 1) {
 153                 if (pos > 2)
 154                         p = mempset(p, ' ', pos-2);
 155                 if (log_get_show_color())
 156                         p = stpcpy(p, ANSI_RED);
 157                 *p++ = '*';
 158         }
 159
 160         if (pos > 0 && pos <= width) {
 161                 if (log_get_show_color())
 162                         p = stpcpy(p, ANSI_HIGHLIGHT_RED);
 163                 *p++ = '*';
 164         }
 165
 166         if (log_get_show_color())
 167                 p = stpcpy(p, ANSI_NORMAL);
 168
 169         if (pos < width) {
 170                 if (log_get_show_color())
 171                         p = stpcpy(p, ANSI_RED);
 172                 *p++ = '*';
 173                 if (pos < width-1)
 174                         p = mempset(p, ' ', width-1-pos);
 175                 if (log_get_show_color())
 176                         strcpy(p, ANSI_NORMAL);
 177         }
 178 }
 179
 180 void manager_flip_auto_status(Manager *m, bool enable) {
 181         assert(m);
 182
 183         if (enable) {
 184                 if (m->show_status == SHOW_STATUS_AUTO)
 185                         manager_set_show_status(m, SHOW_STATUS_TEMPORARY);
 186         } else {
 187                 if (m->show_status == SHOW_STATUS_TEMPORARY)
 188                         manager_set_show_status(m, SHOW_STATUS_AUTO);
 189         }
 190 }
 191
 192 static void manager_print_jobs_in_progress(Manager *m) {
 193         _cleanup_free_ char *job_of_n = NULL;
 194         Iterator i;
 195         Job *j;
 196         unsigned counter = 0, print_nr;
 197         char cylon[6 + CYLON_BUFFER_EXTRA + 1];
 198         unsigned cylon_pos;
 199         char time[FORMAT_TIMESPAN_MAX], limit[FORMAT_TIMESPAN_MAX] = "no limit";
 200         uint64_t x;
 201
 202         assert(m);
 203         assert(m->n_running_jobs > 0);
 204
 205         manager_flip_auto_status(m, true);
 206
 207         print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
 208
 209         HASHMAP_FOREACH(j, m->jobs, i)
 210                 if (j->state == JOB_RUNNING && counter++ == print_nr)
 211                         break;
 212
 213         /* m->n_running_jobs must be consistent with the contents of m->jobs,
 214          * so the above loop must have succeeded in finding j. */
 215         assert(counter == print_nr + 1);
 216         assert(j);
 217
 218         cylon_pos = m->jobs_in_progress_iteration % 14;
 219         if (cylon_pos >= 8)
 220                 cylon_pos = 14 - cylon_pos;
 221         draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
 222
 223         m->jobs_in_progress_iteration++;
 224
 225         if (m->n_running_jobs > 1) {
 226                 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
 227                         job_of_n = NULL;
 228         }
 229
 230         format_timespan(time, sizeof(time), now(CLOCK_MONOTONIC) - j->begin_usec, 1*USEC_PER_SEC);
 231         if (job_get_timeout(j, &x) > 0)
 232                 format_timespan(limit, sizeof(limit), x - j->begin_usec, 1*USEC_PER_SEC);
 233
 234         manager_status_printf(m, STATUS_TYPE_EPHEMERAL, cylon,
 235                               "%sA %s job is running for %s (%s / %s)",
 236                               strempty(job_of_n),
 237                               job_type_to_string(j->type),
 238                               unit_description(j->unit),
 239                               time, limit);
 240 }
 241
 242 static int have_ask_password(void) {
 243         _cleanup_closedir_ DIR *dir;
 244         struct dirent *de;
 245
 246         dir = opendir("/run/systemd/ask-password");
 247         if (!dir) {
 248                 if (errno == ENOENT)
 249                         return false;
 250                 else
 251                         return -errno;
 252         }
 253
 254         FOREACH_DIRENT_ALL(de, dir, return -errno) {
 255                 if (startswith(de->d_name, "ask."))
 256                         return true;
 257         }
 258         return false;
 259 }
 260
 261 static int manager_dispatch_ask_password_fd(sd_event_source *source,
 262                                             int fd, uint32_t revents, void *userdata) {
 263         Manager *m = userdata;
 264
 265         assert(m);
 266
 267         (void) flush_fd(fd);
 268
 269         m->have_ask_password = have_ask_password();
 270         if (m->have_ask_password < 0)
 271                 /* Log error but continue. Negative have_ask_password
 272                  * is treated as unknown status. */
 273                 log_error_errno(m->have_ask_password, "Failed to list /run/systemd/ask-password: %m");
 274
 275         return 0;
 276 }
 277
 278 static void manager_close_ask_password(Manager *m) {
 279         assert(m);
 280
 281         m->ask_password_event_source = sd_event_source_unref(m->ask_password_event_source);
 282         m->ask_password_inotify_fd = safe_close(m->ask_password_inotify_fd);
 283         m->have_ask_password = -EINVAL;
 284 }
 285
 286 static int manager_check_ask_password(Manager *m) {
 287         int r;
 288
 289         assert(m);
 290
 291         if (!m->ask_password_event_source) {
 292                 assert(m->ask_password_inotify_fd < 0);
 293
 294                 mkdir_p_label("/run/systemd/ask-password", 0755);
 295
 296                 m->ask_password_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
 297                 if (m->ask_password_inotify_fd < 0)
 298                         return log_error_errno(errno, "inotify_init1() failed: %m");
 299
 300                 if (inotify_add_watch(m->ask_password_inotify_fd, "/run/systemd/ask-password", IN_CREATE|IN_DELETE|IN_MOVE) < 0) {
 301                         log_error_errno(errno, "Failed to add watch on /run/systemd/ask-password: %m");
 302                         manager_close_ask_password(m);
 303                         return -errno;
 304                 }
 305
 306                 r = sd_event_add_io(m->event, &m->ask_password_event_source,
 307                                     m->ask_password_inotify_fd, EPOLLIN,
 308                                     manager_dispatch_ask_password_fd, m);
 309                 if (r < 0) {
 310                         log_error_errno(errno, "Failed to add event source for /run/systemd/ask-password: %m");
 311                         manager_close_ask_password(m);
 312                         return -errno;
 313                 }
 314
 315                 (void) sd_event_source_set_description(m->ask_password_event_source, "manager-ask-password");
 316
 317                 /* Queries might have been added meanwhile... */
 318                 manager_dispatch_ask_password_fd(m->ask_password_event_source,
 319                                                  m->ask_password_inotify_fd, EPOLLIN, m);
 320         }
 321
 322         return m->have_ask_password;
 323 }
 324
 325 static int manager_watch_idle_pipe(Manager *m) {
 326         int r;
 327
 328         assert(m);
 329
 330         if (m->idle_pipe_event_source)
 331                 return 0;
 332
 333         if (m->idle_pipe[2] < 0)
 334                 return 0;
 335
 336         r = sd_event_add_io(m->event, &m->idle_pipe_event_source, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m);
 337         if (r < 0)
 338                 return log_error_errno(r, "Failed to watch idle pipe: %m");
 339
 340         (void) sd_event_source_set_description(m->idle_pipe_event_source, "manager-idle-pipe");
 341
 342         return 0;
 343 }
 344
 345 static void manager_close_idle_pipe(Manager *m) {
 346         assert(m);
 347
 348         m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
 349
 350         safe_close_pair(m->idle_pipe);
 351         safe_close_pair(m->idle_pipe + 2);
 352 }
 353
 354 static int manager_setup_time_change(Manager *m) {
 355         int r;
 356
 357         /* We only care for the cancellation event, hence we set the
 358          * timeout to the latest possible value. */
 359         struct itimerspec its = {
 360                 .it_value.tv_sec = TIME_T_MAX,
 361         };
 362
 363         assert(m);
 364         assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
 365
 366         if (m->test_run_flags)
 367                 return 0;
 368
 369         /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
 370          * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
 371
 372         m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
 373         if (m->time_change_fd < 0)
 374                 return log_error_errno(errno, "Failed to create timerfd: %m");
 375
 376         if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
 377                 log_debug_errno(errno, "Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
 378                 m->time_change_fd = safe_close(m->time_change_fd);
 379                 return 0;
 380         }
 381
 382         r = sd_event_add_io(m->event, &m->time_change_event_source, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m);
 383         if (r < 0)
 384                 return log_error_errno(r, "Failed to create time change event source: %m");
 385
 386         (void) sd_event_source_set_description(m->time_change_event_source, "manager-time-change");
 387
 388         log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
 389
 390         return 0;
 391 }
 392
 393 static int enable_special_signals(Manager *m) {
 394         _cleanup_close_ int fd = -1;
 395
 396         assert(m);
 397
 398         if (m->test_run_flags)
 399                 return 0;
 400
 401         /* Enable that we get SIGINT on control-alt-del. In containers
 402          * this will fail with EPERM (older) or EINVAL (newer), so
 403          * ignore that. */
 404         if (reboot(RB_DISABLE_CAD) < 0 && !IN_SET(errno, EPERM, EINVAL))
 405                 log_warning_errno(errno, "Failed to enable ctrl-alt-del handling: %m");
 406
 407         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
 408         if (fd < 0) {
 409                 /* Support systems without virtual console */
 410                 if (fd != -ENOENT)
 411                         log_warning_errno(errno, "Failed to open /dev/tty0: %m");
 412         } else {
 413                 /* Enable that we get SIGWINCH on kbrequest */
 414                 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
 415                         log_warning_errno(errno, "Failed to enable kbrequest handling: %m");
 416         }
 417
 418         return 0;
 419 }
 420
 421 static int manager_setup_signals(Manager *m) {
 422         struct sigaction sa = {
 423                 .sa_handler = SIG_DFL,
 424                 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
 425         };
 426         sigset_t mask;
 427         int r;
 428
 429         assert(m);
 430
 431         assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
 432
 433         /* We make liberal use of realtime signals here. On
 434          * Linux/glibc we have 30 of them (with the exception of Linux
 435          * on hppa, see below), between SIGRTMIN+0 ... SIGRTMIN+30
 436          * (aka SIGRTMAX). */
 437
 438         assert_se(sigemptyset(&mask) == 0);
 439         sigset_add_many(&mask,
 440                         SIGCHLD,     /* Child died */
 441                         SIGTERM,     /* Reexecute daemon */
 442                         SIGHUP,      /* Reload configuration */
 443                         SIGUSR1,     /* systemd/upstart: reconnect to D-Bus */
 444                         SIGUSR2,     /* systemd: dump status */
 445                         SIGINT,      /* Kernel sends us this on control-alt-del */
 446                         SIGWINCH,    /* Kernel sends us this on kbrequest (alt-arrowup) */
 447                         SIGPWR,      /* Some kernel drivers and upsd send us this on power failure */
 448
 449                         SIGRTMIN+0,  /* systemd: start default.target */
 450                         SIGRTMIN+1,  /* systemd: isolate rescue.target */
 451                         SIGRTMIN+2,  /* systemd: isolate emergency.target */
 452                         SIGRTMIN+3,  /* systemd: start halt.target */
 453                         SIGRTMIN+4,  /* systemd: start poweroff.target */
 454                         SIGRTMIN+5,  /* systemd: start reboot.target */
 455                         SIGRTMIN+6,  /* systemd: start kexec.target */
 456
 457                         /* ... space for more special targets ... */
 458
 459                         SIGRTMIN+13, /* systemd: Immediate halt */
 460                         SIGRTMIN+14, /* systemd: Immediate poweroff */
 461                         SIGRTMIN+15, /* systemd: Immediate reboot */
 462                         SIGRTMIN+16, /* systemd: Immediate kexec */
 463
 464                         /* ... space for more immediate system state changes ... */
 465
 466                         SIGRTMIN+20, /* systemd: enable status messages */
 467                         SIGRTMIN+21, /* systemd: disable status messages */
 468                         SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
 469                         SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
 470                         SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
 471
 472                         /* .. one free signal here ... */
 473
 474 #if !defined(__hppa64__) && !defined(__hppa__)
 475                         /* Apparently Linux on hppa has fewer RT
 476                          * signals (SIGRTMAX is SIGRTMIN+25 there),
 477                          * hence let's not try to make use of them
 478                          * here. Since these commands are accessible
 479                          * by different means and only really a safety
 480                          * net, the missing functionality on hppa
 481                          * shouldn't matter. */
 482
 483                         SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
 484                         SIGRTMIN+27, /* systemd: set log target to console */
 485                         SIGRTMIN+28, /* systemd: set log target to kmsg */
 486                         SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg (obsolete) */
 487
 488                         /* ... one free signal here SIGRTMIN+30 ... */
 489 #endif
 490                         -1);
 491         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
 492
 493         m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
 494         if (m->signal_fd < 0)
 495                 return -errno;
 496
 497         r = sd_event_add_io(m->event, &m->signal_event_source, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m);
 498         if (r < 0)
 499                 return r;
 500
 501         (void) sd_event_source_set_description(m->signal_event_source, "manager-signal");
 502
 503         /* Process signals a bit earlier than the rest of things, but later than notify_fd processing, so that the
 504          * notify processing can still figure out to which process/service a message belongs, before we reap the
 505          * process. Also, process this before handling cgroup notifications, so that we always collect child exit
 506          * status information before detecting that there's no process in a cgroup. */
 507         r = sd_event_source_set_priority(m->signal_event_source, SD_EVENT_PRIORITY_NORMAL-6);
 508         if (r < 0)
 509                 return r;
 510
 511         if (MANAGER_IS_SYSTEM(m))
 512                 return enable_special_signals(m);
 513
 514         return 0;
 515 }
 516
 517 static void manager_sanitize_environment(Manager *m) {
 518         assert(m);
 519
 520         /* Let's remove some environment variables that we need ourselves to communicate with our clients */
 521         strv_env_unset_many(
 522                         m->environment,
 523                         "EXIT_CODE",
 524                         "EXIT_STATUS",
 525                         "INVOCATION_ID",
 526                         "JOURNAL_STREAM",
 527                         "LISTEN_FDNAMES",
 528                         "LISTEN_FDS",
 529                         "LISTEN_PID",
 530                         "MAINPID",
 531                         "MANAGERPID",
 532                         "NOTIFY_SOCKET",
 533                         "REMOTE_ADDR",
 534                         "REMOTE_PORT",
 535                         "SERVICE_RESULT",
 536                         "WATCHDOG_PID",
 537                         "WATCHDOG_USEC",
 538                         NULL);
 539
 540         /* Let's order the environment alphabetically, just to make it pretty */
 541         strv_sort(m->environment);
 542 }
 543
 544 static int manager_default_environment(Manager *m) {
 545         assert(m);
 546
 547         if (MANAGER_IS_SYSTEM(m)) {
 548                 /* The system manager always starts with a clean
 549                  * environment for its children. It does not import
 550                  * the kernel's or the parents' exported variables.
 551                  *
 552                  * The initial passed environment is untouched to keep
 553                  * /proc/self/environ valid; it is used for tagging
 554                  * the init process inside containers. */
 555                 m->environment = strv_new("PATH=" DEFAULT_PATH,
 556                                           NULL);
 557
 558                 /* Import locale variables LC_*= from configuration */
 559                 locale_setup(&m->environment);
 560         } else
 561                 /* The user manager passes its own environment
 562                  * along to its children. */
 563                 m->environment = strv_copy(environ);
 564
 565         if (!m->environment)
 566                 return -ENOMEM;
 567
 568         manager_sanitize_environment(m);
 569
 570         return 0;
 571 }
 572
 573 static int manager_setup_prefix(Manager *m) {
 574         struct table_entry {
 575                 uint64_t type;
 576                 const char *suffix;
 577         };
 578
 579         static const struct table_entry paths_system[_EXEC_DIRECTORY_TYPE_MAX] = {
 580                 [EXEC_DIRECTORY_RUNTIME] = { SD_PATH_SYSTEM_RUNTIME, NULL },
 581                 [EXEC_DIRECTORY_STATE] = { SD_PATH_SYSTEM_STATE_PRIVATE, NULL },
 582                 [EXEC_DIRECTORY_CACHE] = { SD_PATH_SYSTEM_STATE_CACHE, NULL },
 583                 [EXEC_DIRECTORY_LOGS] = { SD_PATH_SYSTEM_STATE_LOGS, NULL },
 584                 [EXEC_DIRECTORY_CONFIGURATION] = { SD_PATH_SYSTEM_CONFIGURATION, NULL },
 585         };
 586
 587         static const struct table_entry paths_user[_EXEC_DIRECTORY_TYPE_MAX] = {
 588                 [EXEC_DIRECTORY_RUNTIME] = { SD_PATH_USER_RUNTIME, NULL },
 589                 [EXEC_DIRECTORY_STATE] = { SD_PATH_USER_CONFIGURATION, NULL },
 590                 [EXEC_DIRECTORY_CACHE] = { SD_PATH_USER_STATE_CACHE, NULL },
 591                 [EXEC_DIRECTORY_LOGS] = { SD_PATH_USER_CONFIGURATION, "log" },
 592                 [EXEC_DIRECTORY_CONFIGURATION] = { SD_PATH_USER_CONFIGURATION, NULL },
 593         };
 594
 595         const struct table_entry *p;
 596         ExecDirectoryType i;
 597         int r;
 598
 599         assert(m);
 600
 601         if (MANAGER_IS_SYSTEM(m))
 602                 p = paths_system;
 603         else
 604                 p = paths_user;
 605
 606         for (i = 0; i < _EXEC_DIRECTORY_TYPE_MAX; i++) {
 607                 r = sd_path_home(p[i].type, p[i].suffix, &m->prefix[i]);
 608                 if (r < 0)
 609                         return r;
 610         }
 611
 612         return 0;
 613 }
 614
 615 static int manager_setup_run_queue(Manager *m) {
 616         int r;
 617
 618         assert(m);
 619         assert(!m->run_queue_event_source);
 620
 621         r = sd_event_add_defer(m->event, &m->run_queue_event_source, manager_dispatch_run_queue, m);
 622         if (r < 0)
 623                 return r;
 624
 625         r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
 626         if (r < 0)
 627                 return r;
 628
 629         r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
 630         if (r < 0)
 631                 return r;
 632
 633         (void) sd_event_source_set_description(m->run_queue_event_source, "manager-run-queue");
 634
 635         return 0;
 636 }
 637
 638 static int manager_setup_sigchld_event_source(Manager *m) {
 639         int r;
 640
 641         assert(m);
 642         assert(!m->sigchld_event_source);
 643
 644         r = sd_event_add_defer(m->event, &m->sigchld_event_source, manager_dispatch_sigchld, m);
 645         if (r < 0)
 646                 return r;
 647
 648         r = sd_event_source_set_priority(m->sigchld_event_source, SD_EVENT_PRIORITY_NORMAL-7);
 649         if (r < 0)
 650                 return r;
 651
 652         r = sd_event_source_set_enabled(m->sigchld_event_source, SD_EVENT_OFF);
 653         if (r < 0)
 654                 return r;
 655
 656         (void) sd_event_source_set_description(m->sigchld_event_source, "manager-sigchld");
 657
 658         return 0;
 659 }
 660
 661 int manager_new(UnitFileScope scope, unsigned test_run_flags, Manager **_m) {
 662         Manager *m;
 663         int r;
 664
 665         assert(_m);
 666         assert(IN_SET(scope, UNIT_FILE_SYSTEM, UNIT_FILE_USER));
 667
 668         m = new0(Manager, 1);
 669         if (!m)
 670                 return -ENOMEM;
 671
 672         m->unit_file_scope = scope;
 673         m->exit_code = _MANAGER_EXIT_CODE_INVALID;
 674         m->default_timer_accuracy_usec = USEC_PER_MINUTE;
 675         m->default_tasks_accounting = true;
 676         m->default_tasks_max = UINT64_MAX;
 677         m->default_timeout_start_usec = DEFAULT_TIMEOUT_USEC;
 678         m->default_timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
 679         m->default_restart_usec = DEFAULT_RESTART_USEC;
 680
 681 #if ENABLE_EFI
 682         if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0)
 683                 boot_timestamps(m->timestamps + MANAGER_TIMESTAMP_USERSPACE,
 684                                 m->timestamps + MANAGER_TIMESTAMP_FIRMWARE,
 685                                 m->timestamps + MANAGER_TIMESTAMP_LOADER);
 686 #endif
 687
 688         /* Prepare log fields we can use for structured logging */
 689         if (MANAGER_IS_SYSTEM(m)) {
 690                 m->unit_log_field = "UNIT=";
 691                 m->unit_log_format_string = "UNIT=%s";
 692
 693                 m->invocation_log_field = "INVOCATION_ID=";
 694                 m->invocation_log_format_string = "INVOCATION_ID=%s";
 695         } else {
 696                 m->unit_log_field = "USER_UNIT=";
 697                 m->unit_log_format_string = "USER_UNIT=%s";
 698
 699                 m->invocation_log_field = "USER_INVOCATION_ID=";
 700                 m->invocation_log_format_string = "USER_INVOCATION_ID=%s";
 701         }
 702
 703         m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
 704
 705         m->pin_cgroupfs_fd = m->notify_fd = m->cgroups_agent_fd = m->signal_fd = m->time_change_fd =
 706                 m->dev_autofs_fd = m->private_listen_fd = m->cgroup_inotify_fd =
 707                 m->ask_password_inotify_fd = -1;
 708
 709         m->user_lookup_fds[0] = m->user_lookup_fds[1] = -1;
 710
 711         m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
 712
 713         m->have_ask_password = -EINVAL; /* we don't know */
 714         m->first_boot = -1;
 715
 716         m->test_run_flags = test_run_flags;
 717
 718         /* Reboot immediately if the user hits C-A-D more often than 7x per 2s */
 719         RATELIMIT_INIT(m->ctrl_alt_del_ratelimit, 2 * USEC_PER_SEC, 7);
 720
 721         r = manager_default_environment(m);
 722         if (r < 0)
 723                 goto fail;
 724
 725         r = hashmap_ensure_allocated(&m->units, &string_hash_ops);
 726         if (r < 0)
 727                 goto fail;
 728
 729         r = hashmap_ensure_allocated(&m->jobs, NULL);
 730         if (r < 0)
 731                 goto fail;
 732
 733         r = hashmap_ensure_allocated(&m->cgroup_unit, &string_hash_ops);
 734         if (r < 0)
 735                 goto fail;
 736
 737         r = hashmap_ensure_allocated(&m->watch_bus, &string_hash_ops);
 738         if (r < 0)
 739                 goto fail;
 740
 741         r = sd_event_default(&m->event);
 742         if (r < 0)
 743                 goto fail;
 744
 745         r = manager_setup_run_queue(m);
 746         if (r < 0)
 747                 goto fail;
 748
 749         r = manager_setup_signals(m);
 750         if (r < 0)
 751                 goto fail;
 752
 753         r = manager_setup_cgroup(m);
 754         if (r < 0)
 755                 goto fail;
 756
 757         r = manager_setup_time_change(m);
 758         if (r < 0)
 759                 goto fail;
 760
 761         r = manager_setup_sigchld_event_source(m);
 762         if (r < 0)
 763                 goto fail;
 764
 765         m->udev = udev_new();
 766         if (!m->udev) {
 767                 r = -ENOMEM;
 768                 goto fail;
 769         }
 770
 771         r = manager_setup_prefix(m);
 772         if (r < 0)
 773                 goto fail;
 774
 775         if (MANAGER_IS_SYSTEM(m) && test_run_flags == 0) {
 776                 r = mkdir_label("/run/systemd/units", 0755);
 777                 if (r < 0 && r != -EEXIST)
 778                         goto fail;
 779         }
 780
 781         m->taint_usr =
 782                 !in_initrd() &&
 783                 dir_is_empty("/usr") > 0;
 784
 785         /* Note that we do not set up the notify fd here. We do that after deserialization,
 786          * since they might have gotten serialized across the reexec. */
 787
 788         *_m = m;
 789         return 0;
 790
 791 fail:
 792         manager_free(m);
 793         return r;
 794 }
 795
 796 static int manager_setup_notify(Manager *m) {
 797         int r;
 798
 799         if (m->test_run_flags)
 800                 return 0;
 801
 802         if (m->notify_fd < 0) {
 803                 _cleanup_close_ int fd = -1;
 804                 union sockaddr_union sa = {
 805                         .sa.sa_family = AF_UNIX,
 806                 };
 807                 static const int one = 1;
 808
 809                 /* First free all secondary fields */
 810                 m->notify_socket = mfree(m->notify_socket);
 811                 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
 812
 813                 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 814                 if (fd < 0)
 815                         return log_error_errno(errno, "Failed to allocate notification socket: %m");
 816
 817                 fd_inc_rcvbuf(fd, NOTIFY_RCVBUF_SIZE);
 818
 819                 m->notify_socket = strappend(m->prefix[EXEC_DIRECTORY_RUNTIME], "/systemd/notify");
 820                 if (!m->notify_socket)
 821                         return log_oom();
 822
 823                 (void) mkdir_parents_label(m->notify_socket, 0755);
 824                 (void) unlink(m->notify_socket);
 825
 826                 strncpy(sa.un.sun_path, m->notify_socket, sizeof(sa.un.sun_path)-1);
 827                 r = bind(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un));
 828                 if (r < 0)
 829                         return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
 830
 831                 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
 832                 if (r < 0)
 833                         return log_error_errno(errno, "SO_PASSCRED failed: %m");
 834
 835                 m->notify_fd = fd;
 836                 fd = -1;
 837
 838                 log_debug("Using notification socket %s", m->notify_socket);
 839         }
 840
 841         if (!m->notify_event_source) {
 842                 r = sd_event_add_io(m->event, &m->notify_event_source, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m);
 843                 if (r < 0)
 844                         return log_error_errno(r, "Failed to allocate notify event source: %m");
 845
 846                 /* Process notification messages a bit earlier than SIGCHLD, so that we can still identify to which
 847                  * service an exit message belongs. */
 848                 r = sd_event_source_set_priority(m->notify_event_source, SD_EVENT_PRIORITY_NORMAL-8);
 849                 if (r < 0)
 850                         return log_error_errno(r, "Failed to set priority of notify event source: %m");
 851
 852                 (void) sd_event_source_set_description(m->notify_event_source, "manager-notify");
 853         }
 854
 855         return 0;
 856 }
 857
 858 static int manager_setup_cgroups_agent(Manager *m) {
 859
 860         static const union sockaddr_union sa = {
 861                 .un.sun_family = AF_UNIX,
 862                 .un.sun_path = "/run/systemd/cgroups-agent",
 863         };
 864         int r;
 865
 866         /* This creates a listening socket we receive cgroups agent messages on. We do not use D-Bus for delivering
 867          * these messages from the cgroups agent binary to PID 1, as the cgroups agent binary is very short-living, and
 868          * each instance of it needs a new D-Bus connection. Since D-Bus connections are SOCK_STREAM/AF_UNIX, on
 869          * overloaded systems the backlog of the D-Bus socket becomes relevant, as not more than the configured number
 870          * of D-Bus connections may be queued until the kernel will start dropping further incoming connections,
 871          * possibly resulting in lost cgroups agent messages. To avoid this, we'll use a private SOCK_DGRAM/AF_UNIX
 872          * socket, where no backlog is relevant as communication may take place without an actual connect() cycle, and
 873          * we thus won't lose messages.
 874          *
 875          * Note that PID 1 will forward the agent message to system bus, so that the user systemd instance may listen
 876          * to it. The system instance hence listens on this special socket, but the user instances listen on the system
 877          * bus for these messages. */
 878
 879         if (m->test_run_flags)
 880                 return 0;
 881
 882         if (!MANAGER_IS_SYSTEM(m))
 883                 return 0;
 884
 885         r = cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER);
 886         if (r < 0)
 887                 return log_error_errno(r, "Failed to determine whether unified cgroups hierarchy is used: %m");
 888         if (r > 0) /* We don't need this anymore on the unified hierarchy */
 889                 return 0;
 890
 891         if (m->cgroups_agent_fd < 0) {
 892                 _cleanup_close_ int fd = -1;
 893
 894                 /* First free all secondary fields */
 895                 m->cgroups_agent_event_source = sd_event_source_unref(m->cgroups_agent_event_source);
 896
 897                 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 898                 if (fd < 0)
 899                         return log_error_errno(errno, "Failed to allocate cgroups agent socket: %m");
 900
 901                 fd_inc_rcvbuf(fd, CGROUPS_AGENT_RCVBUF_SIZE);
 902
 903                 (void) unlink(sa.un.sun_path);
 904
 905                 /* Only allow root to connect to this socket */
 906                 RUN_WITH_UMASK(0077)
 907                         r = bind(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un));
 908                 if (r < 0)
 909                         return log_error_errno(errno, "bind(%s) failed: %m", sa.un.sun_path);
 910
 911                 m->cgroups_agent_fd = fd;
 912                 fd = -1;
 913         }
 914
 915         if (!m->cgroups_agent_event_source) {
 916                 r = sd_event_add_io(m->event, &m->cgroups_agent_event_source, m->cgroups_agent_fd, EPOLLIN, manager_dispatch_cgroups_agent_fd, m);
 917                 if (r < 0)
 918                         return log_error_errno(r, "Failed to allocate cgroups agent event source: %m");
 919
 920                 /* Process cgroups notifications early, but after having processed service notification messages or
 921                  * SIGCHLD signals, so that a cgroup running empty is always just the last safety net of notification,
 922                  * and we collected the metadata the notification and SIGCHLD stuff offers first. Also see handling of
 923                  * cgroup inotify for the unified cgroup stuff. */
 924                 r = sd_event_source_set_priority(m->cgroups_agent_event_source, SD_EVENT_PRIORITY_NORMAL-4);
 925                 if (r < 0)
 926                         return log_error_errno(r, "Failed to set priority of cgroups agent event source: %m");
 927
 928                 (void) sd_event_source_set_description(m->cgroups_agent_event_source, "manager-cgroups-agent");
 929         }
 930
 931         return 0;
 932 }
 933
 934 static int manager_setup_user_lookup_fd(Manager *m) {
 935         int r;
 936
 937         assert(m);
 938
 939         /* Set up the socket pair used for passing UID/GID resolution results from forked off processes to PID
 940          * 1. Background: we can't do name lookups (NSS) from PID 1, since it might involve IPC and thus activation,
 941          * and we might hence deadlock on ourselves. Hence we do all user/group lookups asynchronously from the forked
 942          * off processes right before executing the binaries to start. In order to be able to clean up any IPC objects
 943          * created by a unit (see RemoveIPC=) we need to know in PID 1 the used UID/GID of the executed processes,
 944          * hence we establish this communication channel so that forked off processes can pass their UID/GID
 945          * information back to PID 1. The forked off processes send their resolved UID/GID to PID 1 in a simple
 946          * datagram, along with their unit name, so that we can share one communication socket pair among all units for
 947          * this purpose.
 948          *
 949          * You might wonder why we need a communication channel for this that is independent of the usual notification
 950          * socket scheme (i.e. $NOTIFY_SOCKET). The primary difference is about trust: data sent via the $NOTIFY_SOCKET
 951          * channel is only accepted if it originates from the right unit and if reception was enabled for it. The user
 952          * lookup socket OTOH is only accessible by PID 1 and its children until they exec(), and always available.
 953          *
 954          * Note that this function is called under two circumstances: when we first initialize (in which case we
 955          * allocate both the socket pair and the event source to listen on it), and when we deserialize after a reload
 956          * (in which case the socket pair already exists but we still need to allocate the event source for it). */
 957
 958         if (m->user_lookup_fds[0] < 0) {
 959
 960                 /* Free all secondary fields */
 961                 safe_close_pair(m->user_lookup_fds);
 962                 m->user_lookup_event_source = sd_event_source_unref(m->user_lookup_event_source);
 963
 964                 if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, m->user_lookup_fds) < 0)
 965                         return log_error_errno(errno, "Failed to allocate user lookup socket: %m");
 966
 967                 (void) fd_inc_rcvbuf(m->user_lookup_fds[0], NOTIFY_RCVBUF_SIZE);
 968         }
 969
 970         if (!m->user_lookup_event_source) {
 971                 r = sd_event_add_io(m->event, &m->user_lookup_event_source, m->user_lookup_fds[0], EPOLLIN, manager_dispatch_user_lookup_fd, m);
 972                 if (r < 0)
 973                         return log_error_errno(errno, "Failed to allocate user lookup event source: %m");
 974
 975                 /* Process even earlier than the notify event source, so that we always know first about valid UID/GID
 976                  * resolutions */
 977                 r = sd_event_source_set_priority(m->user_lookup_event_source, SD_EVENT_PRIORITY_NORMAL-11);
 978                 if (r < 0)
 979                         return log_error_errno(errno, "Failed to set priority ot user lookup event source: %m");
 980
 981                 (void) sd_event_source_set_description(m->user_lookup_event_source, "user-lookup");
 982         }
 983
 984         return 0;
 985 }
 986
 987 static int manager_connect_bus(Manager *m, bool reexecuting) {
 988         bool try_bus_connect;
 989         Unit *u = NULL;
 990
 991         assert(m);
 992
 993         if (m->test_run_flags)
 994                 return 0;
 995
 996         u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
 997
 998         try_bus_connect =
 999                 (u && SERVICE(u)->deserialized_state == SERVICE_RUNNING) &&
1000                 (reexecuting ||
1001                  (MANAGER_IS_USER(m) && getenv("DBUS_SESSION_BUS_ADDRESS")));
1002
1003         /* Try to connect to the buses, if possible. */
1004         return bus_init(m, try_bus_connect);
1005 }
1006
1007 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
1008         Unit *u;
1009         unsigned n = 0;
1010
1011         assert(m);
1012
1013         while ((u = m->cleanup_queue)) {
1014                 assert(u->in_cleanup_queue);
1015
1016                 unit_free(u);
1017                 n++;
1018         }
1019
1020         return n;
1021 }
1022
1023 enum {
1024         GC_OFFSET_IN_PATH,  /* This one is on the path we were traveling */
1025         GC_OFFSET_UNSURE,   /* No clue */
1026         GC_OFFSET_GOOD,     /* We still need this unit */
1027         GC_OFFSET_BAD,      /* We don't need this unit anymore */
1028         _GC_OFFSET_MAX
1029 };
1030
1031 static void unit_gc_mark_good(Unit *u, unsigned gc_marker) {
1032         Unit *other;
1033         Iterator i;
1034         void *v;
1035
1036         u->gc_marker = gc_marker + GC_OFFSET_GOOD;
1037
1038         /* Recursively mark referenced units as GOOD as well */
1039         HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REFERENCES], i)
1040                 if (other->gc_marker == gc_marker + GC_OFFSET_UNSURE)
1041                         unit_gc_mark_good(other, gc_marker);
1042 }
1043
1044 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
1045         Unit *other;
1046         bool is_bad;
1047         Iterator i;
1048         void *v;
1049
1050         assert(u);
1051
1052         if (IN_SET(u->gc_marker - gc_marker,
1053                    GC_OFFSET_GOOD, GC_OFFSET_BAD, GC_OFFSET_UNSURE, GC_OFFSET_IN_PATH))
1054                 return;
1055
1056         if (u->in_cleanup_queue)
1057                 goto bad;
1058
1059         if (unit_check_gc(u))
1060                 goto good;
1061
1062         u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
1063
1064         is_bad = true;
1065
1066         HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REFERENCED_BY], i) {
1067                 unit_gc_sweep(other, gc_marker);
1068
1069                 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
1070                         goto good;
1071
1072                 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
1073                         is_bad = false;
1074         }
1075
1076         if (is_bad)
1077                 goto bad;
1078
1079         /* We were unable to find anything out about this entry, so
1080          * let's investigate it later */
1081         u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
1082         unit_add_to_gc_queue(u);
1083         return;
1084
1085 bad:
1086         /* We definitely know that this one is not useful anymore, so
1087          * let's mark it for deletion */
1088         u->gc_marker = gc_marker + GC_OFFSET_BAD;
1089         unit_add_to_cleanup_queue(u);
1090         return;
1091
1092 good:
1093         unit_gc_mark_good(u, gc_marker);
1094 }
1095
1096 static unsigned manager_dispatch_gc_unit_queue(Manager *m) {
1097         unsigned n = 0, gc_marker;
1098         Unit *u;
1099
1100         assert(m);
1101
1102         /* log_debug("Running GC..."); */
1103
1104         m->gc_marker += _GC_OFFSET_MAX;
1105         if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
1106                 m->gc_marker = 1;
1107
1108         gc_marker = m->gc_marker;
1109
1110         while ((u = m->gc_unit_queue)) {
1111                 assert(u->in_gc_queue);
1112
1113                 unit_gc_sweep(u, gc_marker);
1114
1115                 LIST_REMOVE(gc_queue, m->gc_unit_queue, u);
1116                 u->in_gc_queue = false;
1117
1118                 n++;
1119
1120                 if (IN_SET(u->gc_marker - gc_marker,
1121                            GC_OFFSET_BAD, GC_OFFSET_UNSURE)) {
1122                         if (u->id)
1123                                 log_unit_debug(u, "Collecting.");
1124                         u->gc_marker = gc_marker + GC_OFFSET_BAD;
1125                         unit_add_to_cleanup_queue(u);
1126                 }
1127         }
1128
1129         return n;
1130 }
1131
1132 static unsigned manager_dispatch_gc_job_queue(Manager *m) {
1133         unsigned n = 0;
1134         Job *j;
1135
1136         assert(m);
1137
1138         while ((j = m->gc_job_queue)) {
1139                 assert(j->in_gc_queue);
1140
1141                 LIST_REMOVE(gc_queue, m->gc_job_queue, j);
1142                 j->in_gc_queue = false;
1143
1144                 n++;
1145
1146                 if (job_check_gc(j))
1147                         continue;
1148
1149                 log_unit_debug(j->unit, "Collecting job.");
1150                 (void) job_finish_and_invalidate(j, JOB_COLLECTED, false, false);
1151         }
1152
1153         return n;
1154 }
1155
1156 static void manager_clear_jobs_and_units(Manager *m) {
1157         Unit *u;
1158
1159         assert(m);
1160
1161         while ((u = hashmap_first(m->units)))
1162                 unit_free(u);
1163
1164         manager_dispatch_cleanup_queue(m);
1165
1166         assert(!m->load_queue);
1167         assert(!m->run_queue);
1168         assert(!m->dbus_unit_queue);
1169         assert(!m->dbus_job_queue);
1170         assert(!m->cleanup_queue);
1171         assert(!m->gc_unit_queue);
1172         assert(!m->gc_job_queue);
1173
1174         assert(hashmap_isempty(m->jobs));
1175         assert(hashmap_isempty(m->units));
1176
1177         m->n_on_console = 0;
1178         m->n_running_jobs = 0;
1179 }
1180
1181 Manager* manager_free(Manager *m) {
1182         UnitType c;
1183         int i;
1184         ExecDirectoryType dt;
1185
1186         if (!m)
1187                 return NULL;
1188
1189         manager_clear_jobs_and_units(m);
1190
1191         for (c = 0; c < _UNIT_TYPE_MAX; c++)
1192                 if (unit_vtable[c]->shutdown)
1193                         unit_vtable[c]->shutdown(m);
1194
1195         /* If we reexecute ourselves, we keep the root cgroup around */
1196         manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
1197
1198         lookup_paths_flush_generator(&m->lookup_paths);
1199
1200         bus_done(m);
1201
1202         dynamic_user_vacuum(m, false);
1203         hashmap_free(m->dynamic_users);
1204
1205         hashmap_free(m->units);
1206         hashmap_free(m->units_by_invocation_id);
1207         hashmap_free(m->jobs);
1208         hashmap_free(m->watch_pids);
1209         hashmap_free(m->watch_bus);
1210
1211         set_free(m->startup_units);
1212         set_free(m->failed_units);
1213
1214         sd_event_source_unref(m->signal_event_source);
1215         sd_event_source_unref(m->sigchld_event_source);
1216         sd_event_source_unref(m->notify_event_source);
1217         sd_event_source_unref(m->cgroups_agent_event_source);
1218         sd_event_source_unref(m->time_change_event_source);
1219         sd_event_source_unref(m->jobs_in_progress_event_source);
1220         sd_event_source_unref(m->run_queue_event_source);
1221         sd_event_source_unref(m->user_lookup_event_source);
1222
1223         safe_close(m->signal_fd);
1224         safe_close(m->notify_fd);
1225         safe_close(m->cgroups_agent_fd);
1226         safe_close(m->time_change_fd);
1227         safe_close_pair(m->user_lookup_fds);
1228
1229         manager_close_ask_password(m);
1230
1231         manager_close_idle_pipe(m);
1232
1233         udev_unref(m->udev);
1234         sd_event_unref(m->event);
1235
1236         free(m->notify_socket);
1237
1238         lookup_paths_free(&m->lookup_paths);
1239         strv_free(m->environment);
1240
1241         hashmap_free(m->cgroup_unit);
1242         set_free_free(m->unit_path_cache);
1243
1244         free(m->switch_root);
1245         free(m->switch_root_init);
1246
1247         for (i = 0; i < _RLIMIT_MAX; i++)
1248                 m->rlimit[i] = mfree(m->rlimit[i]);
1249
1250         assert(hashmap_isempty(m->units_requiring_mounts_for));
1251         hashmap_free(m->units_requiring_mounts_for);
1252
1253         hashmap_free(m->uid_refs);
1254         hashmap_free(m->gid_refs);
1255
1256         for (dt = 0; dt < _EXEC_DIRECTORY_TYPE_MAX; dt++)
1257                 m->prefix[dt] = mfree(m->prefix[dt]);
1258
1259         return mfree(m);
1260 }
1261
1262 void manager_enumerate(Manager *m) {
1263         UnitType c;
1264
1265         assert(m);
1266
1267         /* Let's ask every type to load all units from disk/kernel
1268          * that it might know */
1269         for (c = 0; c < _UNIT_TYPE_MAX; c++) {
1270                 if (!unit_type_supported(c)) {
1271                         log_debug("Unit type .%s is not supported on this system.", unit_type_to_string(c));
1272                         continue;
1273                 }
1274
1275                 if (!unit_vtable[c]->enumerate)
1276                         continue;
1277
1278                 unit_vtable[c]->enumerate(m);
1279         }
1280
1281         manager_dispatch_load_queue(m);
1282 }
1283
1284 static void manager_coldplug(Manager *m) {
1285         Iterator i;
1286         Unit *u;
1287         char *k;
1288         int r;
1289
1290         assert(m);
1291
1292         /* Then, let's set up their initial state. */
1293         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
1294
1295                 /* ignore aliases */
1296                 if (u->id != k)
1297                         continue;
1298
1299                 r = unit_coldplug(u);
1300                 if (r < 0)
1301                         log_warning_errno(r, "We couldn't coldplug %s, proceeding anyway: %m", u->id);
1302         }
1303 }
1304
1305 static void manager_build_unit_path_cache(Manager *m) {
1306         char **i;
1307         int r;
1308
1309         assert(m);
1310
1311         set_free_free(m->unit_path_cache);
1312
1313         m->unit_path_cache = set_new(&string_hash_ops);
1314         if (!m->unit_path_cache) {
1315                 r = -ENOMEM;
1316                 goto fail;
1317         }
1318
1319         /* This simply builds a list of files we know exist, so that
1320          * we don't always have to go to disk */
1321
1322         STRV_FOREACH(i, m->lookup_paths.search_path) {
1323                 _cleanup_closedir_ DIR *d = NULL;
1324                 struct dirent *de;
1325
1326                 d = opendir(*i);
1327                 if (!d) {
1328                         if (errno != ENOENT)
1329                                 log_warning_errno(errno, "Failed to open directory %s, ignoring: %m", *i);
1330                         continue;
1331                 }
1332
1333                 FOREACH_DIRENT(de, d, r = -errno; goto fail) {
1334                         char *p;
1335
1336                         p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name);
1337                         if (!p) {
1338                                 r = -ENOMEM;
1339                                 goto fail;
1340                         }
1341
1342                         r = set_consume(m->unit_path_cache, p);
1343                         if (r < 0)
1344                                 goto fail;
1345                 }
1346         }
1347
1348         return;
1349
1350 fail:
1351         log_warning_errno(r, "Failed to build unit path cache, proceeding without: %m");
1352         m->unit_path_cache = set_free_free(m->unit_path_cache);
1353 }
1354
1355 static void manager_distribute_fds(Manager *m, FDSet *fds) {
1356         Iterator i;
1357         Unit *u;
1358
1359         assert(m);
1360
1361         HASHMAP_FOREACH(u, m->units, i) {
1362
1363                 if (fdset_size(fds) <= 0)
1364                         break;
1365
1366                 if (!UNIT_VTABLE(u)->distribute_fds)
1367                         continue;
1368
1369                 UNIT_VTABLE(u)->distribute_fds(u, fds);
1370         }
1371 }
1372
1373 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
1374         int r;
1375
1376         assert(m);
1377
1378         /* If we are running in test mode, we still want to run the generators,
1379          * but we should not touch the real generator directories. */
1380         r = lookup_paths_init(&m->lookup_paths, m->unit_file_scope,
1381                               m->test_run_flags ? LOOKUP_PATHS_TEMPORARY_GENERATED : 0,
1382                               NULL);
1383         if (r < 0)
1384                 return r;
1385
1386         r = manager_run_environment_generators(m);
1387         if (r < 0)
1388                 return r;
1389
1390         dual_timestamp_get(m->timestamps + MANAGER_TIMESTAMP_GENERATORS_START);
1391         r = manager_run_generators(m);
1392         dual_timestamp_get(m->timestamps + MANAGER_TIMESTAMP_GENERATORS_FINISH);
1393         if (r < 0)
1394                 return r;
1395
1396         /* If this is the first boot, and we are in the host system, then preset everything */
1397         if (m->first_boot > 0 &&
1398             MANAGER_IS_SYSTEM(m) &&
1399             !m->test_run_flags) {
1400
1401                 r = unit_file_preset_all(UNIT_FILE_SYSTEM, 0, NULL, UNIT_FILE_PRESET_ENABLE_ONLY, NULL, 0);
1402                 if (r < 0)
1403                         log_full_errno(r == -EEXIST ? LOG_NOTICE : LOG_WARNING, r,
1404                                        "Failed to populate /etc with preset unit settings, ignoring: %m");
1405                 else
1406                         log_info("Populated /etc with preset unit settings.");
1407         }
1408
1409         lookup_paths_reduce(&m->lookup_paths);
1410         manager_build_unit_path_cache(m);
1411
1412         /* If we will deserialize make sure that during enumeration
1413          * this is already known, so we increase the counter here
1414          * already */
1415         if (serialization)
1416                 m->n_reloading++;
1417
1418         /* First, enumerate what we can from all config files */
1419         dual_timestamp_get(m->timestamps + MANAGER_TIMESTAMP_UNITS_LOAD_START);
1420         manager_enumerate(m);
1421         dual_timestamp_get(m->timestamps + MANAGER_TIMESTAMP_UNITS_LOAD_FINISH);
1422
1423         /* Second, deserialize if there is something to deserialize */
1424         if (serialization) {
1425                 r = manager_deserialize(m, serialization, fds);
1426                 if (r < 0)
1427                         return log_error_errno(r, "Deserialization failed: %m");
1428         }
1429
1430         /* Any fds left? Find some unit which wants them. This is
1431          * useful to allow container managers to pass some file
1432          * descriptors to us pre-initialized. This enables
1433          * socket-based activation of entire containers. */
1434         manager_distribute_fds(m, fds);
1435
1436         /* We might have deserialized the notify fd, but if we didn't
1437          * then let's create the bus now */
1438         r = manager_setup_notify(m);
1439         if (r < 0)
1440                 /* No sense to continue without notifications, our children would fail anyway. */
1441                 return r;
1442
1443         r = manager_setup_cgroups_agent(m);
1444         if (r < 0)
1445                 /* Likewise, no sense to continue without empty cgroup notifications. */
1446                 return r;
1447
1448         r = manager_setup_user_lookup_fd(m);
1449         if (r < 0)
1450                 /* This shouldn't fail, except if things are really broken. */
1451                 return r;
1452
1453         /* Let's connect to the bus now. */
1454         (void) manager_connect_bus(m, !!serialization);
1455
1456         (void) bus_track_coldplug(m, &m->subscribed, false, m->deserialized_subscribed);
1457         m->deserialized_subscribed = strv_free(m->deserialized_subscribed);
1458
1459         /* Third, fire things up! */
1460         manager_coldplug(m);
1461
1462         /* Release any dynamic users no longer referenced */
1463         dynamic_user_vacuum(m, true);
1464
1465         /* Release any references to UIDs/GIDs no longer referenced, and destroy any IPC owned by them */
1466         manager_vacuum_uid_refs(m);
1467         manager_vacuum_gid_refs(m);
1468
1469         if (serialization) {
1470                 assert(m->n_reloading > 0);
1471                 m->n_reloading--;
1472
1473                 /* Let's wait for the UnitNew/JobNew messages being
1474                  * sent, before we notify that the reload is
1475                  * finished */
1476                 m->send_reloading_done = true;
1477         }
1478
1479         return 0;
1480 }
1481
1482 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, sd_bus_error *e, Job **_ret) {
1483         int r;
1484         Transaction *tr;
1485
1486         assert(m);
1487         assert(type < _JOB_TYPE_MAX);
1488         assert(unit);
1489         assert(mode < _JOB_MODE_MAX);
1490
1491         if (mode == JOB_ISOLATE && type != JOB_START)
1492                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1493
1494         if (mode == JOB_ISOLATE && !unit->allow_isolate)
1495                 return sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1496
1497         log_unit_debug(unit, "Trying to enqueue job %s/%s/%s", unit->id, job_type_to_string(type), job_mode_to_string(mode));
1498
1499         type = job_type_collapse(type, unit);
1500
1501         tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1502         if (!tr)
1503                 return -ENOMEM;
1504
1505         r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, false,
1506                                                  IN_SET(mode, JOB_IGNORE_DEPENDENCIES, JOB_IGNORE_REQUIREMENTS),
1507                                                  mode == JOB_IGNORE_DEPENDENCIES, e);
1508         if (r < 0)
1509                 goto tr_abort;
1510
1511         if (mode == JOB_ISOLATE) {
1512                 r = transaction_add_isolate_jobs(tr, m);
1513                 if (r < 0)
1514                         goto tr_abort;
1515         }
1516
1517         r = transaction_activate(tr, m, mode, e);
1518         if (r < 0)
1519                 goto tr_abort;
1520
1521         log_unit_debug(unit,
1522                        "Enqueued job %s/%s as %u", unit->id,
1523                        job_type_to_string(type), (unsigned) tr->anchor_job->id);
1524
1525         if (_ret)
1526                 *_ret = tr->anchor_job;
1527
1528         transaction_free(tr);
1529         return 0;
1530
1531 tr_abort:
1532         transaction_abort(tr);
1533         transaction_free(tr);
1534         return r;
1535 }
1536
1537 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, sd_bus_error *e, Job **ret) {
1538         Unit *unit = NULL;  /* just to appease gcc, initialization is not really necessary */
1539         int r;
1540
1541         assert(m);
1542         assert(type < _JOB_TYPE_MAX);
1543         assert(name);
1544         assert(mode < _JOB_MODE_MAX);
1545
1546         r = manager_load_unit(m, name, NULL, NULL, &unit);
1547         if (r < 0)
1548                 return r;
1549         assert(unit);
1550
1551         return manager_add_job(m, type, unit, mode, e, ret);
1552 }
1553
1554 int manager_add_job_by_name_and_warn(Manager *m, JobType type, const char *name, JobMode mode, Job **ret) {
1555         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1556         int r;
1557
1558         assert(m);
1559         assert(type < _JOB_TYPE_MAX);
1560         assert(name);
1561         assert(mode < _JOB_MODE_MAX);
1562
1563         r = manager_add_job_by_name(m, type, name, mode, &error, ret);
1564         if (r < 0)
1565                 return log_warning_errno(r, "Failed to enqueue %s job for %s: %s", job_mode_to_string(mode), name, bus_error_message(&error, r));
1566
1567         return r;
1568 }
1569
1570 int manager_propagate_reload(Manager *m, Unit *unit, JobMode mode, sd_bus_error *e) {
1571         int r;
1572         Transaction *tr;
1573
1574         assert(m);
1575         assert(unit);
1576         assert(mode < _JOB_MODE_MAX);
1577         assert(mode != JOB_ISOLATE); /* Isolate is only valid for start */
1578
1579         tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1580         if (!tr)
1581                 return -ENOMEM;
1582
1583         /* We need an anchor job */
1584         r = transaction_add_job_and_dependencies(tr, JOB_NOP, unit, NULL, false, false, true, true, e);
1585         if (r < 0)
1586                 goto tr_abort;
1587
1588         /* Failure in adding individual dependencies is ignored, so this always succeeds. */
1589         transaction_add_propagate_reload_jobs(tr, unit, tr->anchor_job, mode == JOB_IGNORE_DEPENDENCIES, e);
1590
1591         r = transaction_activate(tr, m, mode, e);
1592         if (r < 0)
1593                 goto tr_abort;
1594
1595         transaction_free(tr);
1596         return 0;
1597
1598 tr_abort:
1599         transaction_abort(tr);
1600         transaction_free(tr);
1601         return r;
1602 }
1603
1604 Job *manager_get_job(Manager *m, uint32_t id) {
1605         assert(m);
1606
1607         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1608 }
1609
1610 Unit *manager_get_unit(Manager *m, const char *name) {
1611         assert(m);
1612         assert(name);
1613
1614         return hashmap_get(m->units, name);
1615 }
1616
1617 unsigned manager_dispatch_load_queue(Manager *m) {
1618         Unit *u;
1619         unsigned n = 0;
1620
1621         assert(m);
1622
1623         /* Make sure we are not run recursively */
1624         if (m->dispatching_load_queue)
1625                 return 0;
1626
1627         m->dispatching_load_queue = true;
1628
1629         /* Dispatches the load queue. Takes a unit from the queue and
1630          * tries to load its data until the queue is empty */
1631
1632         while ((u = m->load_queue)) {
1633                 assert(u->in_load_queue);
1634
1635                 unit_load(u);
1636                 n++;
1637         }
1638
1639         m->dispatching_load_queue = false;
1640         return n;
1641 }
1642
1643 int manager_load_unit_prepare(
1644                 Manager *m,
1645                 const char *name,
1646                 const char *path,
1647                 sd_bus_error *e,
1648                 Unit **_ret) {
1649
1650         Unit *ret;
1651         UnitType t;
1652         int r;
1653
1654         assert(m);
1655         assert(name || path);
1656         assert(_ret);
1657
1658         /* This will prepare the unit for loading, but not actually
1659          * load anything from disk. */
1660
1661         if (path && !is_path(path))
1662                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1663
1664         if (!name)
1665                 name = basename(path);
1666
1667         t = unit_name_to_type(name);
1668
1669         if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE)) {
1670                 if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE))
1671                         return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is missing the instance name.", name);
1672
1673                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1674         }
1675
1676         ret = manager_get_unit(m, name);
1677         if (ret) {
1678                 *_ret = ret;
1679                 return 1;
1680         }
1681
1682         ret = unit_new(m, unit_vtable[t]->object_size);
1683         if (!ret)
1684                 return -ENOMEM;
1685
1686         if (path) {
1687                 ret->fragment_path = strdup(path);
1688                 if (!ret->fragment_path) {
1689                         unit_free(ret);
1690                         return -ENOMEM;
1691                 }
1692         }
1693
1694         r = unit_add_name(ret, name);
1695         if (r < 0) {
1696                 unit_free(ret);
1697                 return r;
1698         }
1699
1700         unit_add_to_load_queue(ret);
1701         unit_add_to_dbus_queue(ret);
1702         unit_add_to_gc_queue(ret);
1703
1704         *_ret = ret;
1705
1706         return 0;
1707 }
1708
1709 int manager_load_unit(
1710                 Manager *m,
1711                 const char *name,
1712                 const char *path,
1713                 sd_bus_error *e,
1714                 Unit **_ret) {
1715
1716         int r;
1717
1718         assert(m);
1719         assert(_ret);
1720
1721         /* This will load the service information files, but not actually
1722          * start any services or anything. */
1723
1724         r = manager_load_unit_prepare(m, name, path, e, _ret);
1725         if (r != 0)
1726                 return r;
1727
1728         manager_dispatch_load_queue(m);
1729
1730         *_ret = unit_follow_merge(*_ret);
1731
1732         return 0;
1733 }
1734
1735 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1736         Iterator i;
1737         Job *j;
1738
1739         assert(s);
1740         assert(f);
1741
1742         HASHMAP_FOREACH(j, s->jobs, i)
1743                 job_dump(j, f, prefix);
1744 }
1745
1746 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1747         Iterator i;
1748         Unit *u;
1749         const char *t;
1750
1751         assert(s);
1752         assert(f);
1753
1754         HASHMAP_FOREACH_KEY(u, t, s->units, i)
1755                 if (u->id == t)
1756                         unit_dump(u, f, prefix);
1757 }
1758
1759 void manager_dump(Manager *m, FILE *f, const char *prefix) {
1760         ManagerTimestamp q;
1761
1762         assert(m);
1763         assert(f);
1764
1765         for (q = 0; q < _MANAGER_TIMESTAMP_MAX; q++) {
1766                 char buf[FORMAT_TIMESTAMP_MAX];
1767
1768                 if (dual_timestamp_is_set(m->timestamps + q))
1769                         fprintf(f, "%sTimestamp %s: %s\n",
1770                                 strempty(prefix),
1771                                 manager_timestamp_to_string(q),
1772                                 format_timestamp(buf, sizeof(buf), m->timestamps[q].realtime));
1773         }
1774
1775         manager_dump_units(m, f, prefix);
1776         manager_dump_jobs(m, f, prefix);
1777 }
1778
1779 int manager_get_dump_string(Manager *m, char **ret) {
1780         _cleanup_free_ char *dump = NULL;
1781         _cleanup_fclose_ FILE *f = NULL;
1782         size_t size;
1783         int r;
1784
1785         assert(m);
1786         assert(ret);
1787
1788         f = open_memstream(&dump, &size);
1789         if (!f)
1790                 return -errno;
1791
1792         (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
1793
1794         manager_dump(m, f, NULL);
1795
1796         r = fflush_and_check(f);
1797         if (r < 0)
1798                 return r;
1799
1800         f = safe_fclose(f);
1801
1802         *ret = dump;
1803         dump = NULL;
1804
1805         return 0;
1806 }
1807
1808 void manager_clear_jobs(Manager *m) {
1809         Job *j;
1810
1811         assert(m);
1812
1813         while ((j = hashmap_first(m->jobs)))
1814                 /* No need to recurse. We're cancelling all jobs. */
1815                 job_finish_and_invalidate(j, JOB_CANCELED, false, false);
1816 }
1817
1818 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1819         Manager *m = userdata;
1820         Job *j;
1821
1822         assert(source);
1823         assert(m);
1824
1825         while ((j = m->run_queue)) {
1826                 assert(j->installed);
1827                 assert(j->in_run_queue);
1828
1829                 job_run_and_invalidate(j);
1830         }
1831
1832         if (m->n_running_jobs > 0)
1833                 manager_watch_jobs_in_progress(m);
1834
1835         if (m->n_on_console > 0)
1836                 manager_watch_idle_pipe(m);
1837
1838         return 1;
1839 }
1840
1841 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1842         Job *j;
1843         Unit *u;
1844         unsigned n = 0;
1845
1846         assert(m);
1847
1848         if (m->dispatching_dbus_queue)
1849                 return 0;
1850
1851         m->dispatching_dbus_queue = true;
1852
1853         while ((u = m->dbus_unit_queue)) {
1854                 assert(u->in_dbus_queue);
1855
1856                 bus_unit_send_change_signal(u);
1857                 n++;
1858         }
1859
1860         while ((j = m->dbus_job_queue)) {
1861                 assert(j->in_dbus_queue);
1862
1863                 bus_job_send_change_signal(j);
1864                 n++;
1865         }
1866
1867         m->dispatching_dbus_queue = false;
1868
1869         if (m->send_reloading_done) {
1870                 m->send_reloading_done = false;
1871
1872                 bus_manager_send_reloading(m, false);
1873         }
1874
1875         if (m->queued_message)
1876                 bus_send_queued_message(m);
1877
1878         return n;
1879 }
1880
1881 static int manager_dispatch_cgroups_agent_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1882         Manager *m = userdata;
1883         char buf[PATH_MAX+1];
1884         ssize_t n;
1885
1886         n = recv(fd, buf, sizeof(buf), 0);
1887         if (n < 0)
1888                 return log_error_errno(errno, "Failed to read cgroups agent message: %m");
1889         if (n == 0) {
1890                 log_error("Got zero-length cgroups agent message, ignoring.");
1891                 return 0;
1892         }
1893         if ((size_t) n >= sizeof(buf)) {
1894                 log_error("Got overly long cgroups agent message, ignoring.");
1895                 return 0;
1896         }
1897
1898         if (memchr(buf, 0, n)) {
1899                 log_error("Got cgroups agent message with embedded NUL byte, ignoring.");
1900                 return 0;
1901         }
1902         buf[n] = 0;
1903
1904         manager_notify_cgroup_empty(m, buf);
1905         (void) bus_forward_agent_released(m, buf);
1906
1907         return 0;
1908 }
1909
1910 static void manager_invoke_notify_message(
1911                 Manager *m,
1912                 Unit *u,
1913                 const struct ucred *ucred,
1914                 const char *buf,
1915                 FDSet *fds) {
1916
1917         assert(m);
1918         assert(u);
1919         assert(ucred);
1920         assert(buf);
1921
1922         if (u->notifygen == m->notifygen) /* Already invoked on this same unit in this same iteration? */
1923                 return;
1924         u->notifygen = m->notifygen;
1925
1926         if (UNIT_VTABLE(u)->notify_message) {
1927                 _cleanup_strv_free_ char **tags = NULL;
1928
1929                 tags = strv_split(buf, NEWLINE);
1930                 if (!tags) {
1931                         log_oom();
1932                         return;
1933                 }
1934
1935                 UNIT_VTABLE(u)->notify_message(u, ucred, tags, fds);
1936
1937         } else if (DEBUG_LOGGING) {
1938                 _cleanup_free_ char *x = NULL, *y = NULL;
1939
1940                 x = ellipsize(buf, 20, 90);
1941                 if (x)
1942                         y = cescape(x);
1943
1944                 log_unit_debug(u, "Got notification message \"%s\", ignoring.", strnull(y));
1945         }
1946 }
1947
1948 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1949
1950         _cleanup_fdset_free_ FDSet *fds = NULL;
1951         Manager *m = userdata;
1952         char buf[NOTIFY_BUFFER_MAX+1];
1953         struct iovec iovec = {
1954                 .iov_base = buf,
1955                 .iov_len = sizeof(buf)-1,
1956         };
1957         union {
1958                 struct cmsghdr cmsghdr;
1959                 uint8_t buf[CMSG_SPACE(sizeof(struct ucred)) +
1960                             CMSG_SPACE(sizeof(int) * NOTIFY_FD_MAX)];
1961         } control = {};
1962         struct msghdr msghdr = {
1963                 .msg_iov = &iovec,
1964                 .msg_iovlen = 1,
1965                 .msg_control = &control,
1966                 .msg_controllen = sizeof(control),
1967         };
1968
1969         struct cmsghdr *cmsg;
1970         struct ucred *ucred = NULL;
1971         _cleanup_free_ Unit **array_copy = NULL;
1972         Unit *u1, *u2, **array;
1973         int r, *fd_array = NULL;
1974         unsigned n_fds = 0;
1975         bool found = false;
1976         ssize_t n;
1977
1978         assert(m);
1979         assert(m->notify_fd == fd);
1980
1981         if (revents != EPOLLIN) {
1982                 log_warning("Got unexpected poll event for notify fd.");
1983                 return 0;
1984         }
1985
1986         n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT|MSG_CMSG_CLOEXEC|MSG_TRUNC);
1987         if (n < 0) {
1988                 if (IN_SET(errno, EAGAIN, EINTR))
1989                         return 0; /* Spurious wakeup, try again */
1990
1991                 /* If this is any other, real error, then let's stop processing this socket. This of course means we
1992                  * won't take notification messages anymore, but that's still better than busy looping around this:
1993                  * being woken up over and over again but being unable to actually read the message off the socket. */
1994                 return log_error_errno(errno, "Failed to receive notification message: %m");
1995         }
1996
1997         CMSG_FOREACH(cmsg, &msghdr) {
1998                 if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
1999
2000                         fd_array = (int*) CMSG_DATA(cmsg);
2001                         n_fds = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
2002
2003                 } else if (cmsg->cmsg_level == SOL_SOCKET &&
2004                            cmsg->cmsg_type == SCM_CREDENTIALS &&
2005                            cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
2006
2007                         ucred = (struct ucred*) CMSG_DATA(cmsg);
2008                 }
2009         }
2010
2011         if (n_fds > 0) {
2012                 assert(fd_array);
2013
2014                 r = fdset_new_array(&fds, fd_array, n_fds);
2015                 if (r < 0) {
2016                         close_many(fd_array, n_fds);
2017                         log_oom();
2018                         return 0;
2019                 }
2020         }
2021
2022         if (!ucred || !pid_is_valid(ucred->pid)) {
2023                 log_warning("Received notify message without valid credentials. Ignoring.");
2024                 return 0;
2025         }
2026
2027         if ((size_t) n >= sizeof(buf) || (msghdr.msg_flags & MSG_TRUNC)) {
2028                 log_warning("Received notify message exceeded maximum size. Ignoring.");
2029                 return 0;
2030         }
2031
2032         /* As extra safety check, let's make sure the string we get doesn't contain embedded NUL bytes. We permit one
2033          * trailing NUL byte in the message, but don't expect it. */
2034         if (n > 1 && memchr(buf, 0, n-1)) {
2035                 log_warning("Received notify message with embedded NUL bytes. Ignoring.");
2036                 return 0;
2037         }
2038
2039         /* Make sure it's NUL-terminated. */
2040         buf[n] = 0;
2041
2042         /* Increase the generation counter used for filtering out duplicate unit invocations. */
2043         m->notifygen++;
2044
2045         /* Notify every unit that might be interested, which might be multiple. */
2046         u1 = manager_get_unit_by_pid_cgroup(m, ucred->pid);
2047         u2 = hashmap_get(m->watch_pids, PID_TO_PTR(ucred->pid));
2048         array = hashmap_get(m->watch_pids, PID_TO_PTR(-ucred->pid));
2049         if (array) {
2050                 size_t k = 0;
2051
2052                 while (array[k])
2053                         k++;
2054
2055                 array_copy = newdup(Unit*, array, k+1);
2056                 if (!array_copy)
2057                         log_oom();
2058         }
2059         /* And now invoke the per-unit callbacks. Note that manager_invoke_notify_message() will handle duplicate units
2060          * make sure we only invoke each unit's handler once. */
2061         if (u1) {
2062                 manager_invoke_notify_message(m, u1, ucred, buf, fds);
2063                 found = true;
2064         }
2065         if (u2) {
2066                 manager_invoke_notify_message(m, u2, ucred, buf, fds);
2067                 found = true;
2068         }
2069         if (array_copy)
2070                 for (size_t i = 0; array_copy[i]; i++) {
2071                         manager_invoke_notify_message(m, array_copy[i], ucred, buf, fds);
2072                         found = true;
2073                 }
2074
2075         if (!found)
2076                 log_warning("Cannot find unit for notify message of PID "PID_FMT", ignoring.", ucred->pid);
2077
2078         if (fdset_size(fds) > 0)
2079                 log_warning("Got extra auxiliary fds with notification message, closing them.");
2080
2081         return 0;
2082 }
2083
2084 static void manager_invoke_sigchld_event(
2085                 Manager *m,
2086                 Unit *u,
2087                 const siginfo_t *si) {
2088
2089         assert(m);
2090         assert(u);
2091         assert(si);
2092
2093         /* Already invoked the handler of this unit in this iteration? Then don't process this again */
2094         if (u->sigchldgen == m->sigchldgen)
2095                 return;
2096         u->sigchldgen = m->sigchldgen;
2097
2098         log_unit_debug(u, "Child "PID_FMT" belongs to %s.", si->si_pid, u->id);
2099         unit_unwatch_pid(u, si->si_pid);
2100
2101         if (UNIT_VTABLE(u)->sigchld_event)
2102                 UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
2103 }
2104
2105 static int manager_dispatch_sigchld(sd_event_source *source, void *userdata) {
2106         Manager *m = userdata;
2107         siginfo_t si = {};
2108         int r;
2109
2110         assert(source);
2111         assert(m);
2112
2113         /* First we call waitd() for a PID and do not reap the zombie. That way we can still access /proc/$PID for it
2114          * while it is a zombie. */
2115
2116         if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
2117
2118                 if (errno == ECHILD)
2119                         goto turn_off;
2120
2121                 log_error_errno(errno, "Failed to peek for child with waitid(), ignoring: %m");
2122                 return 0;
2123         }
2124
2125         if (si.si_pid <= 0)
2126                 goto turn_off;
2127
2128         if (IN_SET(si.si_code, CLD_EXITED, CLD_KILLED, CLD_DUMPED)) {
2129                 _cleanup_free_ Unit **array_copy = NULL;
2130                 _cleanup_free_ char *name = NULL;
2131                 Unit *u1, *u2, **array;
2132
2133                 (void) get_process_comm(si.si_pid, &name);
2134
2135                 log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
2136                           si.si_pid, strna(name),
2137                           sigchld_code_to_string(si.si_code),
2138                           si.si_status,
2139                           strna(si.si_code == CLD_EXITED
2140                                 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
2141                                 : signal_to_string(si.si_status)));
2142
2143                 /* Increase the generation counter used for filtering out duplicate unit invocations */
2144                 m->sigchldgen++;
2145
2146                 /* And now figure out the unit this belongs to, it might be multiple... */
2147                 u1 = manager_get_unit_by_pid_cgroup(m, si.si_pid);
2148                 u2 = hashmap_get(m->watch_pids, PID_TO_PTR(si.si_pid));
2149                 array = hashmap_get(m->watch_pids, PID_TO_PTR(-si.si_pid));
2150                 if (array) {
2151                         size_t n = 0;
2152
2153                         /* Cound how many entries the array has */
2154                         while (array[n])
2155                                 n++;
2156
2157                         /* Make a copy of the array so that we don't trip up on the array changing beneath us */
2158                         array_copy = newdup(Unit*, array, n+1);
2159                         if (!array_copy)
2160                                 log_oom();
2161                 }
2162
2163                 /* Finally, execute them all. Note that u1, u2 and the array might contain duplicates, but
2164                  * that's fine, manager_invoke_sigchld_event() will ensure we only invoke the handlers once for
2165                  * each iteration. */
2166                 if (u1)
2167                         manager_invoke_sigchld_event(m, u1, &si);
2168                 if (u2)
2169                         manager_invoke_sigchld_event(m, u2, &si);
2170                 if (array_copy)
2171                         for (size_t i = 0; array_copy[i]; i++)
2172                                 manager_invoke_sigchld_event(m, array_copy[i], &si);
2173         }
2174
2175         /* And now, we actually reap the zombie. */
2176         if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
2177                 log_error_errno(errno, "Failed to dequeue child, ignoring: %m");
2178                 return 0;
2179         }
2180
2181         return 0;
2182
2183 turn_off:
2184         /* All children processed for now, turn off event source */
2185
2186         r = sd_event_source_set_enabled(m->sigchld_event_source, SD_EVENT_OFF);
2187         if (r < 0)
2188                 return log_error_errno(r, "Failed to disable SIGCHLD event source: %m");
2189
2190         return 0;
2191 }
2192
2193 static void manager_start_target(Manager *m, const char *name, JobMode mode) {
2194         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2195         int r;
2196
2197         log_debug("Activating special unit %s", name);
2198
2199         r = manager_add_job_by_name(m, JOB_START, name, mode, &error, NULL);
2200         if (r < 0)
2201                 log_error("Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
2202 }
2203
2204 static void manager_handle_ctrl_alt_del(Manager *m) {
2205         /* If the user presses C-A-D more than
2206          * 7 times within 2s, we reboot/shutdown immediately,
2207          * unless it was disabled in system.conf */
2208
2209         if (ratelimit_test(&m->ctrl_alt_del_ratelimit) || m->cad_burst_action == EMERGENCY_ACTION_NONE)
2210                 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
2211         else
2212                 emergency_action(m, m->cad_burst_action, NULL,
2213                                 "Ctrl-Alt-Del was pressed more than 7 times within 2s");
2214 }
2215
2216 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2217         Manager *m = userdata;
2218         ssize_t n;
2219         struct signalfd_siginfo sfsi;
2220         int r;
2221
2222         assert(m);
2223         assert(m->signal_fd == fd);
2224
2225         if (revents != EPOLLIN) {
2226                 log_warning("Got unexpected events from signal file descriptor.");
2227                 return 0;
2228         }
2229
2230         n = read(m->signal_fd, &sfsi, sizeof(sfsi));
2231         if (n != sizeof(sfsi)) {
2232                 if (n >= 0) {
2233                         log_warning("Truncated read from signal fd (%zu bytes), ignoring!", n);
2234                         return 0;
2235                 }
2236
2237                 if (IN_SET(errno, EINTR, EAGAIN))
2238                         return 0;
2239
2240                 /* We return an error here, which will kill this handler,
2241                  * to avoid a busy loop on read error. */
2242                 return log_error_errno(errno, "Reading from signal fd failed: %m");
2243         }
2244
2245         log_received_signal(sfsi.ssi_signo == SIGCHLD ||
2246                             (sfsi.ssi_signo == SIGTERM && MANAGER_IS_USER(m))
2247                             ? LOG_DEBUG : LOG_INFO,
2248                             &sfsi);
2249
2250         switch (sfsi.ssi_signo) {
2251
2252         case SIGCHLD:
2253                 r = sd_event_source_set_enabled(m->sigchld_event_source, SD_EVENT_ON);
2254                 if (r < 0)
2255                         log_warning_errno(r, "Failed to enable SIGCHLD even source, ignoring: %m");
2256
2257                 break;
2258
2259         case SIGTERM:
2260                 if (MANAGER_IS_SYSTEM(m)) {
2261                         /* This is for compatibility with the
2262                          * original sysvinit */
2263                         r = verify_run_space_and_log("Refusing to reexecute");
2264                         if (r >= 0)
2265                                 m->exit_code = MANAGER_REEXECUTE;
2266                         break;
2267                 }
2268
2269                 _fallthrough_;
2270         case SIGINT:
2271                 if (MANAGER_IS_SYSTEM(m))
2272                         manager_handle_ctrl_alt_del(m);
2273                 else
2274                         manager_start_target(m, SPECIAL_EXIT_TARGET,
2275                                              JOB_REPLACE_IRREVERSIBLY);
2276                 break;
2277
2278         case SIGWINCH:
2279                 if (MANAGER_IS_SYSTEM(m))
2280                         manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
2281
2282                 /* This is a nop on non-init */
2283                 break;
2284
2285         case SIGPWR:
2286                 if (MANAGER_IS_SYSTEM(m))
2287                         manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
2288
2289                 /* This is a nop on non-init */
2290                 break;
2291
2292         case SIGUSR1: {
2293                 Unit *u;
2294
2295                 u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
2296
2297                 if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
2298                         log_info("Trying to reconnect to bus...");
2299                         bus_init(m, true);
2300                 }
2301
2302                 if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
2303                         log_info("Loading D-Bus service...");
2304                         manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
2305                 }
2306
2307                 break;
2308         }
2309
2310         case SIGUSR2: {
2311                 _cleanup_free_ char *dump = NULL;
2312
2313                 r = manager_get_dump_string(m, &dump);
2314                 if (r < 0) {
2315                         log_warning_errno(errno, "Failed to acquire manager dump: %m");
2316                         break;
2317                 }
2318
2319                 log_dump(LOG_INFO, dump);
2320                 break;
2321         }
2322
2323         case SIGHUP:
2324                 r = verify_run_space_and_log("Refusing to reload");
2325                 if (r >= 0)
2326                         m->exit_code = MANAGER_RELOAD;
2327                 break;
2328
2329         default: {
2330
2331                 /* Starting SIGRTMIN+0 */
2332                 static const struct {
2333                         const char *target;
2334                         JobMode mode;
2335                 } target_table[] = {
2336                         [0] = { SPECIAL_DEFAULT_TARGET,   JOB_ISOLATE },
2337                         [1] = { SPECIAL_RESCUE_TARGET,    JOB_ISOLATE },
2338                         [2] = { SPECIAL_EMERGENCY_TARGET, JOB_ISOLATE },
2339                         [3] = { SPECIAL_HALT_TARGET,      JOB_REPLACE_IRREVERSIBLY },
2340                         [4] = { SPECIAL_POWEROFF_TARGET,  JOB_REPLACE_IRREVERSIBLY },
2341                         [5] = { SPECIAL_REBOOT_TARGET,    JOB_REPLACE_IRREVERSIBLY },
2342                         [6] = { SPECIAL_KEXEC_TARGET,     JOB_REPLACE_IRREVERSIBLY },
2343                 };
2344
2345                 /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
2346                 static const ManagerExitCode code_table[] = {
2347                         [0] = MANAGER_HALT,
2348                         [1] = MANAGER_POWEROFF,
2349                         [2] = MANAGER_REBOOT,
2350                         [3] = MANAGER_KEXEC,
2351                 };
2352
2353                 if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
2354                     (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
2355                         int idx = (int) sfsi.ssi_signo - SIGRTMIN;
2356                         manager_start_target(m, target_table[idx].target,
2357                                              target_table[idx].mode);
2358                         break;
2359                 }
2360
2361                 if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
2362                     (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
2363                         m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
2364                         break;
2365                 }
2366
2367                 switch (sfsi.ssi_signo - SIGRTMIN) {
2368
2369                 case 20:
2370                         manager_set_show_status(m, SHOW_STATUS_YES);
2371                         break;
2372
2373                 case 21:
2374                         manager_set_show_status(m, SHOW_STATUS_NO);
2375                         break;
2376
2377                 case 22:
2378                         log_set_max_level(LOG_DEBUG);
2379                         log_info("Setting log level to debug.");
2380                         break;
2381
2382                 case 23:
2383                         log_set_max_level(LOG_INFO);
2384                         log_info("Setting log level to info.");
2385                         break;
2386
2387                 case 24:
2388                         if (MANAGER_IS_USER(m)) {
2389                                 m->exit_code = MANAGER_EXIT;
2390                                 return 0;
2391                         }
2392
2393                         /* This is a nop on init */
2394                         break;
2395
2396                 case 26:
2397                 case 29: /* compatibility: used to be mapped to LOG_TARGET_SYSLOG_OR_KMSG */
2398                         log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
2399                         log_notice("Setting log target to journal-or-kmsg.");
2400                         break;
2401
2402                 case 27:
2403                         log_set_target(LOG_TARGET_CONSOLE);
2404                         log_notice("Setting log target to console.");
2405                         break;
2406
2407                 case 28:
2408                         log_set_target(LOG_TARGET_KMSG);
2409                         log_notice("Setting log target to kmsg.");
2410                         break;
2411
2412                 default:
2413                         log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
2414                 }
2415         }}
2416
2417         return 0;
2418 }
2419
2420 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2421         Manager *m = userdata;
2422         Iterator i;
2423         Unit *u;
2424
2425         assert(m);
2426         assert(m->time_change_fd == fd);
2427
2428         log_struct(LOG_DEBUG,
2429                    "MESSAGE_ID=" SD_MESSAGE_TIME_CHANGE_STR,
2430                    LOG_MESSAGE("Time has been changed"),
2431                    NULL);
2432
2433         /* Restart the watch */
2434         m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
2435         m->time_change_fd = safe_close(m->time_change_fd);
2436
2437         manager_setup_time_change(m);
2438
2439         HASHMAP_FOREACH(u, m->units, i)
2440                 if (UNIT_VTABLE(u)->time_change)
2441                         UNIT_VTABLE(u)->time_change(u);
2442
2443         return 0;
2444 }
2445
2446 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2447         Manager *m = userdata;
2448
2449         assert(m);
2450         assert(m->idle_pipe[2] == fd);
2451
2452         m->no_console_output = m->n_on_console > 0;
2453
2454         manager_close_idle_pipe(m);
2455
2456         return 0;
2457 }
2458
2459 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
2460         Manager *m = userdata;
2461         int r;
2462         uint64_t next;
2463
2464         assert(m);
2465         assert(source);
2466
2467         manager_print_jobs_in_progress(m);
2468
2469         next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
2470         r = sd_event_source_set_time(source, next);
2471         if (r < 0)
2472                 return r;
2473
2474         return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
2475 }
2476
2477 int manager_loop(Manager *m) {
2478         int r;
2479
2480         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
2481
2482         assert(m);
2483         m->exit_code = MANAGER_OK;
2484
2485         /* Release the path cache */
2486         m->unit_path_cache = set_free_free(m->unit_path_cache);
2487
2488         manager_check_finished(m);
2489
2490         /* There might still be some zombies hanging around from before we were exec()'ed. Let's reap them. */
2491         r = sd_event_source_set_enabled(m->sigchld_event_source, SD_EVENT_ON);
2492         if (r < 0)
2493                 return log_error_errno(r, "Failed to enable SIGCHLD event source: %m");
2494
2495         while (m->exit_code == MANAGER_OK) {
2496                 usec_t wait_usec;
2497
2498                 if (m->runtime_watchdog > 0 && m->runtime_watchdog != USEC_INFINITY && MANAGER_IS_SYSTEM(m))
2499                         watchdog_ping();
2500
2501                 if (!ratelimit_test(&rl)) {
2502                         /* Yay, something is going seriously wrong, pause a little */
2503                         log_warning("Looping too fast. Throttling execution a little.");
2504                         sleep(1);
2505                 }
2506
2507                 if (manager_dispatch_load_queue(m) > 0)
2508                         continue;
2509
2510                 if (manager_dispatch_gc_job_queue(m) > 0)
2511                         continue;
2512
2513                 if (manager_dispatch_gc_unit_queue(m) > 0)
2514                         continue;
2515
2516                 if (manager_dispatch_cleanup_queue(m) > 0)
2517                         continue;
2518
2519                 if (manager_dispatch_cgroup_realize_queue(m) > 0)
2520                         continue;
2521
2522                 if (manager_dispatch_dbus_queue(m) > 0)
2523                         continue;
2524
2525                 /* Sleep for half the watchdog time */
2526                 if (m->runtime_watchdog > 0 && m->runtime_watchdog != USEC_INFINITY && MANAGER_IS_SYSTEM(m)) {
2527                         wait_usec = m->runtime_watchdog / 2;
2528                         if (wait_usec <= 0)
2529                                 wait_usec = 1;
2530                 } else
2531                         wait_usec = USEC_INFINITY;
2532
2533                 r = sd_event_run(m->event, wait_usec);
2534                 if (r < 0)
2535                         return log_error_errno(r, "Failed to run event loop: %m");
2536         }
2537
2538         return m->exit_code;
2539 }
2540
2541 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
2542         _cleanup_free_ char *n = NULL;
2543         sd_id128_t invocation_id;
2544         Unit *u;
2545         int r;
2546
2547         assert(m);
2548         assert(s);
2549         assert(_u);
2550
2551         r = unit_name_from_dbus_path(s, &n);
2552         if (r < 0)
2553                 return r;
2554
2555         /* Permit addressing units by invocation ID: if the passed bus path is suffixed by a 128bit ID then we use it
2556          * as invocation ID. */
2557         r = sd_id128_from_string(n, &invocation_id);
2558         if (r >= 0) {
2559                 u = hashmap_get(m->units_by_invocation_id, &invocation_id);
2560                 if (u) {
2561                         *_u = u;
2562                         return 0;
2563                 }
2564
2565                 return sd_bus_error_setf(e, BUS_ERROR_NO_UNIT_FOR_INVOCATION_ID, "No unit with the specified invocation ID " SD_ID128_FORMAT_STR " known.", SD_ID128_FORMAT_VAL(invocation_id));
2566         }
2567
2568         /* If this didn't work, we check if this is a unit name */
2569         if (!unit_name_is_valid(n, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))
2570                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is neither a valid invocation ID nor unit name.", n);
2571
2572         r = manager_load_unit(m, n, NULL, e, &u);
2573         if (r < 0)
2574                 return r;
2575
2576         *_u = u;
2577         return 0;
2578 }
2579
2580 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
2581         const char *p;
2582         unsigned id;
2583         Job *j;
2584         int r;
2585
2586         assert(m);
2587         assert(s);
2588         assert(_j);
2589
2590         p = startswith(s, "/org/freedesktop/systemd1/job/");
2591         if (!p)
2592                 return -EINVAL;
2593
2594         r = safe_atou(p, &id);
2595         if (r < 0)
2596                 return r;
2597
2598         j = manager_get_job(m, id);
2599         if (!j)
2600                 return -ENOENT;
2601
2602         *_j = j;
2603
2604         return 0;
2605 }
2606
2607 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
2608
2609 #if HAVE_AUDIT
2610         _cleanup_free_ char *p = NULL;
2611         const char *msg;
2612         int audit_fd, r;
2613
2614         if (!MANAGER_IS_SYSTEM(m))
2615                 return;
2616
2617         audit_fd = get_audit_fd();
2618         if (audit_fd < 0)
2619                 return;
2620
2621         /* Don't generate audit events if the service was already
2622          * started and we're just deserializing */
2623         if (MANAGER_IS_RELOADING(m))
2624                 return;
2625
2626         if (u->type != UNIT_SERVICE)
2627                 return;
2628
2629         r = unit_name_to_prefix_and_instance(u->id, &p);
2630         if (r < 0) {
2631                 log_error_errno(r, "Failed to extract prefix and instance of unit name: %m");
2632                 return;
2633         }
2634
2635         msg = strjoina("unit=", p);
2636         if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2637                 if (errno == EPERM)
2638                         /* We aren't allowed to send audit messages?
2639                          * Then let's not retry again. */
2640                         close_audit_fd();
2641                 else
2642                         log_warning_errno(errno, "Failed to send audit message: %m");
2643         }
2644 #endif
2645
2646 }
2647
2648 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2649         static const union sockaddr_union sa = PLYMOUTH_SOCKET;
2650         _cleanup_free_ char *message = NULL;
2651         _cleanup_close_ int fd = -1;
2652         int n = 0;
2653
2654         /* Don't generate plymouth events if the service was already
2655          * started and we're just deserializing */
2656         if (MANAGER_IS_RELOADING(m))
2657                 return;
2658
2659         if (!MANAGER_IS_SYSTEM(m))
2660                 return;
2661
2662         if (detect_container() > 0)
2663                 return;
2664
2665         if (!IN_SET(u->type, UNIT_SERVICE, UNIT_MOUNT, UNIT_SWAP))
2666                 return;
2667
2668         /* We set SOCK_NONBLOCK here so that we rather drop the
2669          * message then wait for plymouth */
2670         fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2671         if (fd < 0) {
2672                 log_error_errno(errno, "socket() failed: %m");
2673                 return;
2674         }
2675
2676         if (connect(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un)) < 0) {
2677
2678                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2679                         log_error_errno(errno, "connect() failed: %m");
2680                 return;
2681         }
2682
2683         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2684                 log_oom();
2685                 return;
2686         }
2687
2688         errno = 0;
2689         if (write(fd, message, n + 1) != n + 1)
2690                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2691                         log_error_errno(errno, "Failed to write Plymouth message: %m");
2692 }
2693
2694 int manager_open_serialization(Manager *m, FILE **_f) {
2695         int fd;
2696         FILE *f;
2697
2698         assert(_f);
2699
2700         fd = open_serialization_fd("systemd-state");
2701         if (fd < 0)
2702                 return fd;
2703
2704         f = fdopen(fd, "w+");
2705         if (!f) {
2706                 safe_close(fd);
2707                 return -errno;
2708         }
2709
2710         *_f = f;
2711         return 0;
2712 }
2713
2714 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2715         ManagerTimestamp q;
2716         const char *t;
2717         Iterator i;
2718         Unit *u;
2719         int r;
2720
2721         assert(m);
2722         assert(f);
2723         assert(fds);
2724
2725         m->n_reloading++;
2726
2727         fprintf(f, "current-job-id=%"PRIu32"\n", m->current_job_id);
2728         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2729         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2730         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2731         fprintf(f, "ready-sent=%s\n", yes_no(m->ready_sent));
2732         fprintf(f, "taint-logged=%s\n", yes_no(m->taint_logged));
2733         fprintf(f, "service-watchdogs=%s\n", yes_no(m->service_watchdogs));
2734
2735         for (q = 0; q < _MANAGER_TIMESTAMP_MAX; q++) {
2736                 /* The userspace and finish timestamps only apply to the host system, hence only serialize them there */
2737                 if (in_initrd() && IN_SET(q, MANAGER_TIMESTAMP_USERSPACE, MANAGER_TIMESTAMP_FINISH))
2738                         continue;
2739
2740                 t = manager_timestamp_to_string(q);
2741                 {
2742                         char field[strlen(t) + STRLEN("-timestamp") + 1];
2743                         strcpy(stpcpy(field, t), "-timestamp");
2744                         dual_timestamp_serialize(f, field, m->timestamps + q);
2745                 }
2746         }
2747
2748         if (!switching_root)
2749                 (void) serialize_environment(f, m->environment);
2750
2751         if (m->notify_fd >= 0) {
2752                 int copy;
2753
2754                 copy = fdset_put_dup(fds, m->notify_fd);
2755                 if (copy < 0)
2756                         return copy;
2757
2758                 fprintf(f, "notify-fd=%i\n", copy);
2759                 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2760         }
2761
2762         if (m->cgroups_agent_fd >= 0) {
2763                 int copy;
2764
2765                 copy = fdset_put_dup(fds, m->cgroups_agent_fd);
2766                 if (copy < 0)
2767                         return copy;
2768
2769                 fprintf(f, "cgroups-agent-fd=%i\n", copy);
2770         }
2771
2772         if (m->user_lookup_fds[0] >= 0) {
2773                 int copy0, copy1;
2774
2775                 copy0 = fdset_put_dup(fds, m->user_lookup_fds[0]);
2776                 if (copy0 < 0)
2777                         return copy0;
2778
2779                 copy1 = fdset_put_dup(fds, m->user_lookup_fds[1]);
2780                 if (copy1 < 0)
2781                         return copy1;
2782
2783                 fprintf(f, "user-lookup=%i %i\n", copy0, copy1);
2784         }
2785
2786         bus_track_serialize(m->subscribed, f, "subscribed");
2787
2788         r = dynamic_user_serialize(m, f, fds);
2789         if (r < 0)
2790                 return r;
2791
2792         manager_serialize_uid_refs(m, f);
2793         manager_serialize_gid_refs(m, f);
2794
2795         (void) fputc('\n', f);
2796
2797         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2798                 if (u->id != t)
2799                         continue;
2800
2801                 /* Start marker */
2802                 fputs(u->id, f);
2803                 fputc('\n', f);
2804
2805                 r = unit_serialize(u, f, fds, !switching_root);
2806                 if (r < 0) {
2807                         m->n_reloading--;
2808                         return r;
2809                 }
2810         }
2811
2812         assert(m->n_reloading > 0);
2813         m->n_reloading--;
2814
2815         if (ferror(f))
2816                 return -EIO;
2817
2818         r = bus_fdset_add_all(m, fds);
2819         if (r < 0)
2820                 return r;
2821
2822         return 0;
2823 }
2824
2825 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2826         int r = 0;
2827
2828         assert(m);
2829         assert(f);
2830
2831         log_debug("Deserializing state...");
2832
2833         m->n_reloading++;
2834
2835         for (;;) {
2836                 char line[LINE_MAX];
2837                 const char *val, *l;
2838
2839                 if (!fgets(line, sizeof(line), f)) {
2840                         if (feof(f))
2841                                 r = 0;
2842                         else
2843                                 r = -errno;
2844
2845                         goto finish;
2846                 }
2847
2848                 char_array_0(line);
2849                 l = strstrip(line);
2850
2851                 if (l[0] == 0)
2852                         break;
2853
2854                 if ((val = startswith(l, "current-job-id="))) {
2855                         uint32_t id;
2856
2857                         if (safe_atou32(val, &id) < 0)
2858                                 log_notice("Failed to parse current job id value %s", val);
2859                         else
2860                                 m->current_job_id = MAX(m->current_job_id, id);
2861
2862                 } else if ((val = startswith(l, "n-installed-jobs="))) {
2863                         uint32_t n;
2864
2865                         if (safe_atou32(val, &n) < 0)
2866                                 log_notice("Failed to parse installed jobs counter %s", val);
2867                         else
2868                                 m->n_installed_jobs += n;
2869
2870                 } else if ((val = startswith(l, "n-failed-jobs="))) {
2871                         uint32_t n;
2872
2873                         if (safe_atou32(val, &n) < 0)
2874                                 log_notice("Failed to parse failed jobs counter %s", val);
2875                         else
2876                                 m->n_failed_jobs += n;
2877
2878                 } else if ((val = startswith(l, "taint-usr="))) {
2879                         int b;
2880
2881                         b = parse_boolean(val);
2882                         if (b < 0)
2883                                 log_notice("Failed to parse taint /usr flag %s", val);
2884                         else
2885                                 m->taint_usr = m->taint_usr || b;
2886
2887                 } else if ((val = startswith(l, "ready-sent="))) {
2888                         int b;
2889
2890                         b = parse_boolean(val);
2891                         if (b < 0)
2892                                 log_notice("Failed to parse ready-sent flag %s", val);
2893                         else
2894                                 m->ready_sent = m->ready_sent || b;
2895
2896                 } else if ((val = startswith(l, "taint-logged="))) {
2897                         int b;
2898
2899                         b = parse_boolean(val);
2900                         if (b < 0)
2901                                 log_notice("Failed to parse taint-logged flag %s", val);
2902                         else
2903                                 m->taint_logged = m->taint_logged || b;
2904
2905                 } else if ((val = startswith(l, "service-watchdogs="))) {
2906                         int b;
2907
2908                         b = parse_boolean(val);
2909                         if (b < 0)
2910                                 log_notice("Failed to parse service-watchdogs flag %s", val);
2911                         else
2912                                 m->service_watchdogs = b;
2913
2914                 } else if (startswith(l, "env=")) {
2915                         r = deserialize_environment(&m->environment, l);
2916                         if (r == -ENOMEM)
2917                                 goto finish;
2918                         if (r < 0)
2919                                 log_notice_errno(r, "Failed to parse environment entry: \"%s\": %m", l);
2920
2921                 } else if ((val = startswith(l, "notify-fd="))) {
2922                         int fd;
2923
2924                         if (safe_atoi(val, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2925                                 log_notice("Failed to parse notify fd: \"%s\"", val);
2926                         else {
2927                                 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2928                                 safe_close(m->notify_fd);
2929                                 m->notify_fd = fdset_remove(fds, fd);
2930                         }
2931
2932                 } else if ((val = startswith(l, "notify-socket="))) {
2933                         char *n;
2934
2935                         n = strdup(val);
2936                         if (!n) {
2937                                 r = -ENOMEM;
2938                                 goto finish;
2939                         }
2940
2941                         free(m->notify_socket);
2942                         m->notify_socket = n;
2943
2944                 } else if ((val = startswith(l, "cgroups-agent-fd="))) {
2945                         int fd;
2946
2947                         if (safe_atoi(val, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2948                                 log_notice("Failed to parse cgroups agent fd: %s", val);
2949                         else {
2950                                 m->cgroups_agent_event_source = sd_event_source_unref(m->cgroups_agent_event_source);
2951                                 safe_close(m->cgroups_agent_fd);
2952                                 m->cgroups_agent_fd = fdset_remove(fds, fd);
2953                         }
2954
2955                 } else if ((val = startswith(l, "user-lookup="))) {
2956                         int fd0, fd1;
2957
2958                         if (sscanf(val, "%i %i", &fd0, &fd1) != 2 || fd0 < 0 || fd1 < 0 || fd0 == fd1 || !fdset_contains(fds, fd0) || !fdset_contains(fds, fd1))
2959                                 log_notice("Failed to parse user lookup fd: %s", val);
2960                         else {
2961                                 m->user_lookup_event_source = sd_event_source_unref(m->user_lookup_event_source);
2962                                 safe_close_pair(m->user_lookup_fds);
2963                                 m->user_lookup_fds[0] = fdset_remove(fds, fd0);
2964                                 m->user_lookup_fds[1] = fdset_remove(fds, fd1);
2965                         }
2966
2967                 } else if ((val = startswith(l, "dynamic-user=")))
2968                         dynamic_user_deserialize_one(m, val, fds);
2969                 else if ((val = startswith(l, "destroy-ipc-uid=")))
2970                         manager_deserialize_uid_refs_one(m, val);
2971                 else if ((val = startswith(l, "destroy-ipc-gid=")))
2972                         manager_deserialize_gid_refs_one(m, val);
2973                 else if ((val = startswith(l, "subscribed="))) {
2974
2975                         if (strv_extend(&m->deserialized_subscribed, val) < 0)
2976                                 log_oom();
2977                 } else {
2978                         ManagerTimestamp q;
2979
2980                         for (q = 0; q < _MANAGER_TIMESTAMP_MAX; q++) {
2981                                 val = startswith(l, manager_timestamp_to_string(q));
2982                                 if (!val)
2983                                         continue;
2984
2985                                 val = startswith(val, "-timestamp=");
2986                                 if (val)
2987                                         break;
2988                         }
2989
2990                         if (q < _MANAGER_TIMESTAMP_MAX) /* found it */
2991                                 dual_timestamp_deserialize(val, m->timestamps + q);
2992                         else if (!startswith(l, "kdbus-fd=")) /* ignore kdbus */
2993                                 log_notice("Unknown serialization item '%s'", l);
2994                 }
2995         }
2996
2997         for (;;) {
2998                 Unit *u;
2999                 char name[UNIT_NAME_MAX+2];
3000                 const char* unit_name;
3001
3002                 /* Start marker */
3003                 if (!fgets(name, sizeof(name), f)) {
3004                         if (feof(f))
3005                                 r = 0;
3006                         else
3007                                 r = -errno;
3008
3009                         goto finish;
3010                 }
3011
3012                 char_array_0(name);
3013                 unit_name = strstrip(name);
3014
3015                 r = manager_load_unit(m, unit_name, NULL, NULL, &u);
3016                 if (r < 0) {
3017                         log_notice_errno(r, "Failed to load unit \"%s\", skipping deserialization: %m", unit_name);
3018                         if (r == -ENOMEM)
3019                                 goto finish;
3020                         unit_deserialize_skip(f);
3021                         continue;
3022                 }
3023
3024                 r = unit_deserialize(u, f, fds);
3025                 if (r < 0) {
3026                         log_notice_errno(r, "Failed to deserialize unit \"%s\": %m", unit_name);
3027                         if (r == -ENOMEM)
3028                                 goto finish;
3029                 }
3030         }
3031
3032 finish:
3033         if (ferror(f))
3034                 r = -EIO;
3035
3036         assert(m->n_reloading > 0);
3037         m->n_reloading--;
3038
3039         return r;
3040 }
3041
3042 int manager_reload(Manager *m) {
3043         int r, q;
3044         _cleanup_fclose_ FILE *f = NULL;
3045         _cleanup_fdset_free_ FDSet *fds = NULL;
3046
3047         assert(m);
3048
3049         r = manager_open_serialization(m, &f);
3050         if (r < 0)
3051                 return r;
3052
3053         m->n_reloading++;
3054         bus_manager_send_reloading(m, true);
3055
3056         fds = fdset_new();
3057         if (!fds) {
3058                 m->n_reloading--;
3059                 return -ENOMEM;
3060         }
3061
3062         r = manager_serialize(m, f, fds, false);
3063         if (r < 0) {
3064                 m->n_reloading--;
3065                 return r;
3066         }
3067
3068         if (fseeko(f, 0, SEEK_SET) < 0) {
3069                 m->n_reloading--;
3070                 return -errno;
3071         }
3072
3073         /* From here on there is no way back. */
3074         manager_clear_jobs_and_units(m);
3075         lookup_paths_flush_generator(&m->lookup_paths);
3076         lookup_paths_free(&m->lookup_paths);
3077         dynamic_user_vacuum(m, false);
3078         m->uid_refs = hashmap_free(m->uid_refs);
3079         m->gid_refs = hashmap_free(m->gid_refs);
3080
3081         q = lookup_paths_init(&m->lookup_paths, m->unit_file_scope, 0, NULL);
3082         if (q < 0 && r >= 0)
3083                 r = q;
3084
3085         q = manager_run_environment_generators(m);
3086         if (q < 0 && r >= 0)
3087                 r = q;
3088
3089         /* Find new unit paths */
3090         q = manager_run_generators(m);
3091         if (q < 0 && r >= 0)
3092                 r = q;
3093
3094         lookup_paths_reduce(&m->lookup_paths);
3095         manager_build_unit_path_cache(m);
3096
3097         /* First, enumerate what we can from all config files */
3098         manager_enumerate(m);
3099
3100         /* Second, deserialize our stored data */
3101         q = manager_deserialize(m, f, fds);
3102         if (q < 0) {
3103                 log_error_errno(q, "Deserialization failed: %m");
3104
3105                 if (r >= 0)
3106                         r = q;
3107         }
3108
3109         fclose(f);
3110         f = NULL;
3111
3112         /* Re-register notify_fd as event source */
3113         q = manager_setup_notify(m);
3114         if (q < 0 && r >= 0)
3115                 r = q;
3116
3117         q = manager_setup_cgroups_agent(m);
3118         if (q < 0 && r >= 0)
3119                 r = q;
3120
3121         q = manager_setup_user_lookup_fd(m);
3122         if (q < 0 && r >= 0)
3123                 r = q;
3124
3125         /* Third, fire things up! */
3126         manager_coldplug(m);
3127
3128         /* Release any dynamic users no longer referenced */
3129         dynamic_user_vacuum(m, true);
3130
3131         /* Release any references to UIDs/GIDs no longer referenced, and destroy any IPC owned by them */
3132         manager_vacuum_uid_refs(m);
3133         manager_vacuum_gid_refs(m);
3134
3135         /* Sync current state of bus names with our set of listening units */
3136         if (m->api_bus)
3137                 manager_sync_bus_names(m, m->api_bus);
3138
3139         assert(m->n_reloading > 0);
3140         m->n_reloading--;
3141
3142         m->send_reloading_done = true;
3143
3144         return r;
3145 }
3146
3147 void manager_reset_failed(Manager *m) {
3148         Unit *u;
3149         Iterator i;
3150
3151         assert(m);
3152
3153         HASHMAP_FOREACH(u, m->units, i)
3154                 unit_reset_failed(u);
3155 }
3156
3157 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
3158         Unit *u;
3159
3160         assert(m);
3161         assert(name);
3162
3163         /* Returns true if the unit is inactive or going down */
3164         u = manager_get_unit(m, name);
3165         if (!u)
3166                 return true;
3167
3168         return unit_inactive_or_pending(u);
3169 }
3170
3171 static void log_taint_string(Manager *m) {
3172         _cleanup_free_ char *taint = NULL;
3173
3174         assert(m);
3175
3176         if (MANAGER_IS_USER(m) || m->taint_logged)
3177                 return;
3178
3179         m->taint_logged = true; /* only check for taint once */
3180
3181         taint = manager_taint_string(m);
3182         if (isempty(taint))
3183                 return;
3184
3185         log_struct(LOG_NOTICE,
3186                    LOG_MESSAGE("System is tainted: %s", taint),
3187                    "TAINT=%s", taint,
3188                    "MESSAGE_ID=" SD_MESSAGE_TAINTED_STR,
3189                    NULL);
3190 }
3191
3192 static void manager_notify_finished(Manager *m) {
3193         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
3194         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
3195
3196         if (m->test_run_flags)
3197                 return;
3198
3199         if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0) {
3200
3201                 /* Note that MANAGER_TIMESTAMP_KERNEL's monotonic value is always at 0, and
3202                  * MANAGER_TIMESTAMP_FIRMWARE's and MANAGER_TIMESTAMP_LOADER's monotonic value should be considered
3203                  * negative values. */
3204
3205                 firmware_usec = m->timestamps[MANAGER_TIMESTAMP_FIRMWARE].monotonic - m->timestamps[MANAGER_TIMESTAMP_LOADER].monotonic;
3206                 loader_usec = m->timestamps[MANAGER_TIMESTAMP_LOADER].monotonic - m->timestamps[MANAGER_TIMESTAMP_KERNEL].monotonic;
3207                 userspace_usec = m->timestamps[MANAGER_TIMESTAMP_FINISH].monotonic - m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic;
3208                 total_usec = m->timestamps[MANAGER_TIMESTAMP_FIRMWARE].monotonic + m->timestamps[MANAGER_TIMESTAMP_FINISH].monotonic;
3209
3210                 if (dual_timestamp_is_set(&m->timestamps[MANAGER_TIMESTAMP_INITRD])) {
3211
3212                         /* The initrd case on bare-metal*/
3213                         kernel_usec = m->timestamps[MANAGER_TIMESTAMP_INITRD].monotonic - m->timestamps[MANAGER_TIMESTAMP_KERNEL].monotonic;
3214                         initrd_usec = m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic - m->timestamps[MANAGER_TIMESTAMP_INITRD].monotonic;
3215
3216                         log_struct(LOG_INFO,
3217                                    "MESSAGE_ID=" SD_MESSAGE_STARTUP_FINISHED_STR,
3218                                    "KERNEL_USEC="USEC_FMT, kernel_usec,
3219                                    "INITRD_USEC="USEC_FMT, initrd_usec,
3220                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
3221                                    LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
3222                                                format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
3223                                                format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
3224                                                format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
3225                                                format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
3226                                    NULL);
3227                 } else {
3228                         /* The initrd-less case on bare-metal*/
3229
3230                         kernel_usec = m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic - m->timestamps[MANAGER_TIMESTAMP_KERNEL].monotonic;
3231                         initrd_usec = 0;
3232
3233                         log_struct(LOG_INFO,
3234                                    "MESSAGE_ID=" SD_MESSAGE_STARTUP_FINISHED_STR,
3235                                    "KERNEL_USEC="USEC_FMT, kernel_usec,
3236                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
3237                                    LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
3238                                                format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
3239                                                format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
3240                                                format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
3241                                    NULL);
3242                 }
3243         } else {
3244                 /* The container and --user case */
3245                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
3246                 total_usec = userspace_usec = m->timestamps[MANAGER_TIMESTAMP_FINISH].monotonic - m->timestamps[MANAGER_TIMESTAMP_USERSPACE].monotonic;
3247
3248                 log_struct(LOG_INFO,
3249                            "MESSAGE_ID=" SD_MESSAGE_USER_STARTUP_FINISHED_STR,
3250                            "USERSPACE_USEC="USEC_FMT, userspace_usec,
3251                            LOG_MESSAGE("Startup finished in %s.",
3252                                        format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
3253                            NULL);
3254         }
3255
3256         bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
3257
3258         sd_notifyf(false,
3259                    m->ready_sent ? "STATUS=Startup finished in %s."
3260                                  : "READY=1\n"
3261                                    "STATUS=Startup finished in %s.",
3262                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
3263         m->ready_sent = true;
3264
3265         log_taint_string(m);
3266 }
3267
3268 static void manager_send_ready(Manager *m) {
3269         assert(m);
3270
3271         /* We send READY=1 on reaching basic.target only when running in --user mode. */
3272         if (!MANAGER_IS_USER(m) || m->ready_sent)
3273                 return;
3274
3275         m->ready_sent = true;
3276
3277         sd_notifyf(false,
3278                    "READY=1\n"
3279                    "STATUS=Reached " SPECIAL_BASIC_TARGET ".");
3280 }
3281
3282 static void manager_check_basic_target(Manager *m) {
3283         Unit *u;
3284
3285         assert(m);
3286
3287         /* Small shortcut */
3288         if (m->ready_sent && m->taint_logged)
3289                 return;
3290
3291         u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3292         if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3293                 return;
3294
3295         /* For user managers, send out READY=1 as soon as we reach basic.target */
3296         manager_send_ready(m);
3297
3298         /* Log the taint string as soon as we reach basic.target */
3299         log_taint_string(m);
3300 }
3301
3302 void manager_check_finished(Manager *m) {
3303         assert(m);
3304
3305         if (MANAGER_IS_RELOADING(m))
3306                 return;
3307
3308         /* Verify that we have entered the event loop already, and not left it again. */
3309         if (!MANAGER_IS_RUNNING(m))
3310                 return;
3311
3312         manager_check_basic_target(m);
3313
3314         if (hashmap_size(m->jobs) > 0) {
3315                 if (m->jobs_in_progress_event_source)
3316                         /* Ignore any failure, this is only for feedback */
3317                         (void) sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
3318
3319                 return;
3320         }
3321
3322         manager_flip_auto_status(m, false);
3323
3324         /* Notify Type=idle units that we are done now */
3325         manager_close_idle_pipe(m);
3326
3327         /* Turn off confirm spawn now */
3328         m->confirm_spawn = NULL;
3329
3330         /* No need to update ask password status when we're going non-interactive */
3331         manager_close_ask_password(m);
3332
3333         /* This is no longer the first boot */
3334         manager_set_first_boot(m, false);
3335
3336         if (MANAGER_IS_FINISHED(m))
3337                 return;
3338
3339         dual_timestamp_get(m->timestamps + MANAGER_TIMESTAMP_FINISH);
3340
3341         manager_notify_finished(m);
3342
3343         manager_invalidate_startup_units(m);
3344 }
3345
3346 static bool generator_path_any(const char* const* paths) {
3347         char **path;
3348         bool found = false;
3349
3350         /* Optimize by skipping the whole process by not creating output directories
3351          * if no generators are found. */
3352         STRV_FOREACH(path, (char**) paths)
3353                 if (access(*path, F_OK) == 0)
3354                         found = true;
3355                 else if (errno != ENOENT)
3356                         log_warning_errno(errno, "Failed to open generator directory %s: %m", *path);
3357
3358         return found;
3359 }
3360
3361 static const char* system_env_generator_binary_paths[] = {
3362         "/run/systemd/system-environment-generators",
3363         "/etc/systemd/system-environment-generators",
3364         "/usr/local/lib/systemd/system-environment-generators",
3365         SYSTEM_ENV_GENERATOR_PATH,
3366         NULL
3367 };
3368
3369 static const char* user_env_generator_binary_paths[] = {
3370         "/run/systemd/user-environment-generators",
3371         "/etc/systemd/user-environment-generators",
3372         "/usr/local/lib/systemd/user-environment-generators",
3373         USER_ENV_GENERATOR_PATH,
3374         NULL
3375 };
3376
3377 static int manager_run_environment_generators(Manager *m) {
3378         char **tmp = NULL; /* this is only used in the forked process, no cleanup here */
3379         const char **paths;
3380         void* args[] = {&tmp, &tmp, &m->environment};
3381
3382         if (m->test_run_flags && !(m->test_run_flags & MANAGER_TEST_RUN_ENV_GENERATORS))
3383                 return 0;
3384
3385         paths = MANAGER_IS_SYSTEM(m) ? system_env_generator_binary_paths : user_env_generator_binary_paths;
3386
3387         if (!generator_path_any(paths))
3388                 return 0;
3389
3390         return execute_directories(paths, DEFAULT_TIMEOUT_USEC, gather_environment, args, NULL);
3391 }
3392
3393 static int manager_run_generators(Manager *m) {
3394         _cleanup_strv_free_ char **paths = NULL;
3395         const char *argv[5];
3396         int r;
3397
3398         assert(m);
3399
3400         if (m->test_run_flags && !(m->test_run_flags & MANAGER_TEST_RUN_GENERATORS))
3401                 return 0;
3402
3403         paths = generator_binary_paths(m->unit_file_scope);
3404         if (!paths)
3405                 return log_oom();
3406
3407         if (!generator_path_any((const char* const*) paths))
3408                 return 0;
3409
3410         r = lookup_paths_mkdir_generator(&m->lookup_paths);
3411         if (r < 0)
3412                 goto finish;
3413
3414         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
3415         argv[1] = m->lookup_paths.generator;
3416         argv[2] = m->lookup_paths.generator_early;
3417         argv[3] = m->lookup_paths.generator_late;
3418         argv[4] = NULL;
3419
3420         RUN_WITH_UMASK(0022)
3421                 execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC,
3422                                     NULL, NULL, (char**) argv);
3423
3424 finish:
3425         lookup_paths_trim_generator(&m->lookup_paths);
3426         return r;
3427 }
3428
3429 int manager_environment_add(Manager *m, char **minus, char **plus) {
3430         char **a = NULL, **b = NULL, **l;
3431         assert(m);
3432
3433         l = m->environment;
3434
3435         if (!strv_isempty(minus)) {
3436                 a = strv_env_delete(l, 1, minus);
3437                 if (!a)
3438                         return -ENOMEM;
3439
3440                 l = a;
3441         }
3442
3443         if (!strv_isempty(plus)) {
3444                 b = strv_env_merge(2, l, plus);
3445                 if (!b) {
3446                         strv_free(a);
3447                         return -ENOMEM;
3448                 }
3449
3450                 l = b;
3451         }
3452
3453         if (m->environment != l)
3454                 strv_free(m->environment);
3455         if (a != l)
3456                 strv_free(a);
3457         if (b != l)
3458                 strv_free(b);
3459
3460         m->environment = l;
3461         manager_sanitize_environment(m);
3462
3463         return 0;
3464 }
3465
3466 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
3467         int i;
3468
3469         assert(m);
3470
3471         for (i = 0; i < _RLIMIT_MAX; i++) {
3472                 m->rlimit[i] = mfree(m->rlimit[i]);
3473
3474                 if (!default_rlimit[i])
3475                         continue;
3476
3477                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
3478                 if (!m->rlimit[i])
3479                         return log_oom();
3480         }
3481
3482         return 0;
3483 }
3484
3485 void manager_recheck_journal(Manager *m) {
3486         Unit *u;
3487
3488         assert(m);
3489
3490         if (!MANAGER_IS_SYSTEM(m))
3491                 return;
3492
3493         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
3494         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
3495                 log_close_journal();
3496                 return;
3497         }
3498
3499         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
3500         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
3501                 log_close_journal();
3502                 return;
3503         }
3504
3505         /* Hmm, OK, so the socket is fully up and the service is up
3506          * too, then let's make use of the thing. */
3507         log_open();
3508 }
3509
3510 void manager_set_show_status(Manager *m, ShowStatus mode) {
3511         assert(m);
3512         assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
3513
3514         if (!MANAGER_IS_SYSTEM(m))
3515                 return;
3516
3517         if (m->show_status != mode)
3518                 log_debug("%s showing of status.",
3519                           mode == SHOW_STATUS_NO ? "Disabling" : "Enabling");
3520         m->show_status = mode;
3521
3522         if (mode > 0)
3523                 (void) touch("/run/systemd/show-status");
3524         else
3525                 (void) unlink("/run/systemd/show-status");
3526 }
3527
3528 static bool manager_get_show_status(Manager *m, StatusType type) {
3529         assert(m);
3530
3531         if (!MANAGER_IS_SYSTEM(m))
3532                 return false;
3533
3534         if (m->no_console_output)
3535                 return false;
3536
3537         if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
3538                 return false;
3539
3540         /* If we cannot find out the status properly, just proceed. */
3541         if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
3542                 return false;
3543
3544         if (m->show_status > 0)
3545                 return true;
3546
3547         return false;
3548 }
3549
3550 const char *manager_get_confirm_spawn(Manager *m) {
3551         static int last_errno = 0;
3552         const char *vc = m->confirm_spawn;
3553         struct stat st;
3554         int r;
3555
3556         /* Here's the deal: we want to test the validity of the console but don't want
3557          * PID1 to go through the whole console process which might block. But we also
3558          * want to warn the user only once if something is wrong with the console so we
3559          * cannot do the sanity checks after spawning our children. So here we simply do
3560          * really basic tests to hopefully trap common errors.
3561          *
3562          * If the console suddenly disappear at the time our children will really it
3563          * then they will simply fail to acquire it and a positive answer will be
3564          * assumed. New children will fallback to /dev/console though.
3565          *
3566          * Note: TTYs are devices that can come and go any time, and frequently aren't
3567          * available yet during early boot (consider a USB rs232 dongle...). If for any
3568          * reason the configured console is not ready, we fallback to the default
3569          * console. */
3570
3571         if (!vc || path_equal(vc, "/dev/console"))
3572                 return vc;
3573
3574         r = stat(vc, &st);
3575         if (r < 0)
3576                 goto fail;
3577
3578         if (!S_ISCHR(st.st_mode)) {
3579                 errno = ENOTTY;
3580                 goto fail;
3581         }
3582
3583         last_errno = 0;
3584         return vc;
3585 fail:
3586         if (last_errno != errno) {
3587                 last_errno = errno;
3588                 log_warning_errno(errno, "Failed to open %s: %m, using default console", vc);
3589         }
3590         return "/dev/console";
3591 }
3592
3593 void manager_set_first_boot(Manager *m, bool b) {
3594         assert(m);
3595
3596         if (!MANAGER_IS_SYSTEM(m))
3597                 return;
3598
3599         if (m->first_boot != (int) b) {
3600                 if (b)
3601                         (void) touch("/run/systemd/first-boot");
3602                 else
3603                         (void) unlink("/run/systemd/first-boot");
3604         }
3605
3606         m->first_boot = b;
3607 }
3608
3609 void manager_disable_confirm_spawn(void) {
3610         (void) touch("/run/systemd/confirm_spawn_disabled");
3611 }
3612
3613 bool manager_is_confirm_spawn_disabled(Manager *m) {
3614         if (!m->confirm_spawn)
3615                 return true;
3616
3617         return access("/run/systemd/confirm_spawn_disabled", F_OK) >= 0;
3618 }
3619
3620 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
3621         va_list ap;
3622
3623         /* If m is NULL, assume we're after shutdown and let the messages through. */
3624
3625         if (m && !manager_get_show_status(m, type))
3626                 return;
3627
3628         /* XXX We should totally drop the check for ephemeral here
3629          * and thus effectively make 'Type=idle' pointless. */
3630         if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
3631                 return;
3632
3633         va_start(ap, format);
3634         status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
3635         va_end(ap);
3636 }
3637
3638 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3639         char p[strlen(path)+1];
3640
3641         assert(m);
3642         assert(path);
3643
3644         strcpy(p, path);
3645         path_kill_slashes(p);
3646
3647         return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3648 }
3649
3650 void manager_set_exec_params(Manager *m, ExecParameters *p) {
3651         assert(m);
3652         assert(p);
3653
3654         p->environment = m->environment;
3655         p->confirm_spawn = manager_get_confirm_spawn(m);
3656         p->cgroup_supported = m->cgroup_supported;
3657         p->prefix = m->prefix;
3658
3659         SET_FLAG(p->flags, EXEC_PASS_LOG_UNIT|EXEC_CHOWN_DIRECTORIES, MANAGER_IS_SYSTEM(m));
3660 }
3661
3662 int manager_update_failed_units(Manager *m, Unit *u, bool failed) {
3663         unsigned size;
3664         int r;
3665
3666         assert(m);
3667         assert(u->manager == m);
3668
3669         size = set_size(m->failed_units);
3670
3671         if (failed) {
3672                 r = set_ensure_allocated(&m->failed_units, NULL);
3673                 if (r < 0)
3674                         return log_oom();
3675
3676                 if (set_put(m->failed_units, u) < 0)
3677                         return log_oom();
3678         } else
3679                 (void) set_remove(m->failed_units, u);
3680
3681         if (set_size(m->failed_units) != size)
3682                 bus_manager_send_change_signal(m);
3683
3684         return 0;
3685 }
3686
3687 ManagerState manager_state(Manager *m) {
3688         Unit *u;
3689
3690         assert(m);
3691
3692         /* Did we ever finish booting? If not then we are still starting up */
3693         if (!MANAGER_IS_FINISHED(m)) {
3694
3695                 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3696                 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3697                         return MANAGER_INITIALIZING;
3698
3699                 return MANAGER_STARTING;
3700         }
3701
3702         /* Is the special shutdown target active or queued? If so, we are in shutdown state */
3703         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3704         if (u && unit_active_or_pending(u))
3705                 return MANAGER_STOPPING;
3706
3707         if (MANAGER_IS_SYSTEM(m)) {
3708                 /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3709                 u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3710                 if (u && unit_active_or_pending(u))
3711                         return MANAGER_MAINTENANCE;
3712
3713                 u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3714                 if (u && unit_active_or_pending(u))
3715                         return MANAGER_MAINTENANCE;
3716         }
3717
3718         /* Are there any failed units? If so, we are in degraded mode */
3719         if (set_size(m->failed_units) > 0)
3720                 return MANAGER_DEGRADED;
3721
3722         return MANAGER_RUNNING;
3723 }
3724
3725 #define DESTROY_IPC_FLAG (UINT32_C(1) << 31)
3726
3727 static void manager_unref_uid_internal(
3728                 Manager *m,
3729                 Hashmap **uid_refs,
3730                 uid_t uid,
3731                 bool destroy_now,
3732                 int (*_clean_ipc)(uid_t uid)) {
3733
3734         uint32_t c, n;
3735
3736         assert(m);
3737         assert(uid_refs);
3738         assert(uid_is_valid(uid));
3739         assert(_clean_ipc);
3740
3741         /* A generic implementation, covering both manager_unref_uid() and manager_unref_gid(), under the assumption
3742          * that uid_t and gid_t are actually defined the same way, with the same validity rules.
3743          *
3744          * We store a hashmap where the UID/GID is they key and the value is a 32bit reference counter, whose highest
3745          * bit is used as flag for marking UIDs/GIDs whose IPC objects to remove when the last reference to the UID/GID
3746          * is dropped. The flag is set to on, once at least one reference from a unit where RemoveIPC= is set is added
3747          * on a UID/GID. It is reset when the UID's/GID's reference counter drops to 0 again. */
3748
3749         assert_cc(sizeof(uid_t) == sizeof(gid_t));
3750         assert_cc(UID_INVALID == (uid_t) GID_INVALID);
3751
3752         if (uid == 0) /* We don't keep track of root, and will never destroy it */
3753                 return;
3754
3755         c = PTR_TO_UINT32(hashmap_get(*uid_refs, UID_TO_PTR(uid)));
3756
3757         n = c & ~DESTROY_IPC_FLAG;
3758         assert(n > 0);
3759         n--;
3760
3761         if (destroy_now && n == 0) {
3762                 hashmap_remove(*uid_refs, UID_TO_PTR(uid));
3763
3764                 if (c & DESTROY_IPC_FLAG) {
3765                         log_debug("%s " UID_FMT " is no longer referenced, cleaning up its IPC.",
3766                                   _clean_ipc == clean_ipc_by_uid ? "UID" : "GID",
3767                                   uid);
3768                         (void) _clean_ipc(uid);
3769                 }
3770         } else {
3771                 c = n | (c & DESTROY_IPC_FLAG);
3772                 assert_se(hashmap_update(*uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c)) >= 0);
3773         }
3774 }
3775
3776 void manager_unref_uid(Manager *m, uid_t uid, bool destroy_now) {
3777         manager_unref_uid_internal(m, &m->uid_refs, uid, destroy_now, clean_ipc_by_uid);
3778 }
3779
3780 void manager_unref_gid(Manager *m, gid_t gid, bool destroy_now) {
3781         manager_unref_uid_internal(m, &m->gid_refs, (uid_t) gid, destroy_now, clean_ipc_by_gid);
3782 }
3783
3784 static int manager_ref_uid_internal(
3785                 Manager *m,
3786                 Hashmap **uid_refs,
3787                 uid_t uid,
3788                 bool clean_ipc) {
3789
3790         uint32_t c, n;
3791         int r;
3792
3793         assert(m);
3794         assert(uid_refs);
3795         assert(uid_is_valid(uid));
3796
3797         /* A generic implementation, covering both manager_ref_uid() and manager_ref_gid(), under the assumption
3798          * that uid_t and gid_t are actually defined the same way, with the same validity rules. */
3799
3800         assert_cc(sizeof(uid_t) == sizeof(gid_t));
3801         assert_cc(UID_INVALID == (uid_t) GID_INVALID);
3802
3803         if (uid == 0) /* We don't keep track of root, and will never destroy it */
3804                 return 0;
3805
3806         r = hashmap_ensure_allocated(uid_refs, &trivial_hash_ops);
3807         if (r < 0)
3808                 return r;
3809
3810         c = PTR_TO_UINT32(hashmap_get(*uid_refs, UID_TO_PTR(uid)));
3811
3812         n = c & ~DESTROY_IPC_FLAG;
3813         n++;
3814
3815         if (n & DESTROY_IPC_FLAG) /* check for overflow */
3816                 return -EOVERFLOW;
3817
3818         c = n | (c & DESTROY_IPC_FLAG) | (clean_ipc ? DESTROY_IPC_FLAG : 0);
3819
3820         return hashmap_replace(*uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c));
3821 }
3822
3823 int manager_ref_uid(Manager *m, uid_t uid, bool clean_ipc) {
3824         return manager_ref_uid_internal(m, &m->uid_refs, uid, clean_ipc);
3825 }
3826
3827 int manager_ref_gid(Manager *m, gid_t gid, bool clean_ipc) {
3828         return manager_ref_uid_internal(m, &m->gid_refs, (uid_t) gid, clean_ipc);
3829 }
3830
3831 static void manager_vacuum_uid_refs_internal(
3832                 Manager *m,
3833                 Hashmap **uid_refs,
3834                 int (*_clean_ipc)(uid_t uid)) {
3835
3836         Iterator i;
3837         void *p, *k;
3838
3839         assert(m);
3840         assert(uid_refs);
3841         assert(_clean_ipc);
3842
3843         HASHMAP_FOREACH_KEY(p, k, *uid_refs, i) {
3844                 uint32_t c, n;
3845                 uid_t uid;
3846
3847                 uid = PTR_TO_UID(k);
3848                 c = PTR_TO_UINT32(p);
3849
3850                 n = c & ~DESTROY_IPC_FLAG;
3851                 if (n > 0)
3852                         continue;
3853
3854                 if (c & DESTROY_IPC_FLAG) {
3855                         log_debug("Found unreferenced %s " UID_FMT " after reload/reexec. Cleaning up.",
3856                                   _clean_ipc == clean_ipc_by_uid ? "UID" : "GID",
3857                                   uid);
3858                         (void) _clean_ipc(uid);
3859                 }
3860
3861                 assert_se(hashmap_remove(*uid_refs, k) == p);
3862         }
3863 }
3864
3865 void manager_vacuum_uid_refs(Manager *m) {
3866         manager_vacuum_uid_refs_internal(m, &m->uid_refs, clean_ipc_by_uid);
3867 }
3868
3869 void manager_vacuum_gid_refs(Manager *m) {
3870         manager_vacuum_uid_refs_internal(m, &m->gid_refs, clean_ipc_by_gid);
3871 }
3872
3873 static void manager_serialize_uid_refs_internal(
3874                 Manager *m,
3875                 FILE *f,
3876                 Hashmap **uid_refs,
3877                 const char *field_name) {
3878
3879         Iterator i;
3880         void *p, *k;
3881
3882         assert(m);
3883         assert(f);
3884         assert(uid_refs);
3885         assert(field_name);
3886
3887         /* Serialize the UID reference table. Or actually, just the IPC destruction flag of it, as the actual counter
3888          * of it is better rebuild after a reload/reexec. */
3889
3890         HASHMAP_FOREACH_KEY(p, k, *uid_refs, i) {
3891                 uint32_t c;
3892                 uid_t uid;
3893
3894                 uid = PTR_TO_UID(k);
3895                 c = PTR_TO_UINT32(p);
3896
3897                 if (!(c & DESTROY_IPC_FLAG))
3898                         continue;
3899
3900                 fprintf(f, "%s=" UID_FMT "\n", field_name, uid);
3901         }
3902 }
3903
3904 void manager_serialize_uid_refs(Manager *m, FILE *f) {
3905         manager_serialize_uid_refs_internal(m, f, &m->uid_refs, "destroy-ipc-uid");
3906 }
3907
3908 void manager_serialize_gid_refs(Manager *m, FILE *f) {
3909         manager_serialize_uid_refs_internal(m, f, &m->gid_refs, "destroy-ipc-gid");
3910 }
3911
3912 static void manager_deserialize_uid_refs_one_internal(
3913                 Manager *m,
3914                 Hashmap** uid_refs,
3915                 const char *value) {
3916
3917         uid_t uid;
3918         uint32_t c;
3919         int r;
3920
3921         assert(m);
3922         assert(uid_refs);
3923         assert(value);
3924
3925         r = parse_uid(value, &uid);
3926         if (r < 0 || uid == 0) {
3927                 log_debug("Unable to parse UID reference serialization");
3928                 return;
3929         }
3930
3931         r = hashmap_ensure_allocated(uid_refs, &trivial_hash_ops);
3932         if (r < 0) {
3933                 log_oom();
3934                 return;
3935         }
3936
3937         c = PTR_TO_UINT32(hashmap_get(*uid_refs, UID_TO_PTR(uid)));
3938         if (c & DESTROY_IPC_FLAG)
3939                 return;
3940
3941         c |= DESTROY_IPC_FLAG;
3942
3943         r = hashmap_replace(*uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c));
3944         if (r < 0) {
3945                 log_debug("Failed to add UID reference entry");
3946                 return;
3947         }
3948 }
3949
3950 void manager_deserialize_uid_refs_one(Manager *m, const char *value) {
3951         manager_deserialize_uid_refs_one_internal(m, &m->uid_refs, value);
3952 }
3953
3954 void manager_deserialize_gid_refs_one(Manager *m, const char *value) {
3955         manager_deserialize_uid_refs_one_internal(m, &m->gid_refs, value);
3956 }
3957
3958 int manager_dispatch_user_lookup_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
3959         struct buffer {
3960                 uid_t uid;
3961                 gid_t gid;
3962                 char unit_name[UNIT_NAME_MAX+1];
3963         } _packed_ buffer;
3964
3965         Manager *m = userdata;
3966         ssize_t l;
3967         size_t n;
3968         Unit *u;
3969
3970         assert_se(source);
3971         assert_se(m);
3972
3973         /* Invoked whenever a child process succeeded resolving its user/group to use and sent us the resulting UID/GID
3974          * in a datagram. We parse the datagram here and pass it off to the unit, so that it can add a reference to the
3975          * UID/GID so that it can destroy the UID/GID's IPC objects when the reference counter drops to 0. */
3976
3977         l = recv(fd, &buffer, sizeof(buffer), MSG_DONTWAIT);
3978         if (l < 0) {
3979                 if (IN_SET(errno, EINTR, EAGAIN))
3980                         return 0;
3981
3982                 return log_error_errno(errno, "Failed to read from user lookup fd: %m");
3983         }
3984
3985         if ((size_t) l <= offsetof(struct buffer, unit_name)) {
3986                 log_warning("Received too short user lookup message, ignoring.");
3987                 return 0;
3988         }
3989
3990         if ((size_t) l > offsetof(struct buffer, unit_name) + UNIT_NAME_MAX) {
3991                 log_warning("Received too long user lookup message, ignoring.");
3992                 return 0;
3993         }
3994
3995         if (!uid_is_valid(buffer.uid) && !gid_is_valid(buffer.gid)) {
3996                 log_warning("Got user lookup message with invalid UID/GID pair, ignoring.");
3997                 return 0;
3998         }
3999
4000         n = (size_t) l - offsetof(struct buffer, unit_name);
4001         if (memchr(buffer.unit_name, 0, n)) {
4002                 log_warning("Received lookup message with embedded NUL character, ignoring.");
4003                 return 0;
4004         }
4005
4006         buffer.unit_name[n] = 0;
4007         u = manager_get_unit(m, buffer.unit_name);
4008         if (!u) {
4009                 log_debug("Got user lookup message but unit doesn't exist, ignoring.");
4010                 return 0;
4011         }
4012
4013         log_unit_debug(u, "User lookup succeeded: uid=" UID_FMT " gid=" GID_FMT, buffer.uid, buffer.gid);
4014
4015         unit_notify_user_lookup(u, buffer.uid, buffer.gid);
4016         return 0;
4017 }
4018
4019 char *manager_taint_string(Manager *m) {
4020         _cleanup_free_ char *destination = NULL, *overflowuid = NULL, *overflowgid = NULL;
4021         char *buf, *e;
4022         int r;
4023
4024         /* Returns a "taint string", e.g. "local-hwclock:var-run-bad".
4025          * Only things that are detected at runtime should be tagged
4026          * here. For stuff that is set during compilation, emit a warning
4027          * in the configuration phase. */
4028
4029         assert(m);
4030
4031         buf = new(char, sizeof("split-usr:"
4032                                "cgroups-missing:"
4033                                "local-hwclock:"
4034                                "var-run-bad:"
4035                                "overflowuid-not-65534:"
4036                                "overflowgid-not-65534:"));
4037         if (!buf)
4038                 return NULL;
4039
4040         e = buf;
4041         buf[0] = 0;
4042
4043         if (m->taint_usr)
4044                 e = stpcpy(e, "split-usr:");
4045
4046         if (access("/proc/cgroups", F_OK) < 0)
4047                 e = stpcpy(e, "cgroups-missing:");
4048
4049         if (clock_is_localtime(NULL) > 0)
4050                 e = stpcpy(e, "local-hwclock:");
4051
4052         r = readlink_malloc("/var/run", &destination);
4053         if (r < 0 || !PATH_IN_SET(destination, "../run", "/run"))
4054                 e = stpcpy(e, "var-run-bad:");
4055
4056         r = read_one_line_file("/proc/sys/kernel/overflowuid", &overflowuid);
4057         if (r >= 0 && !streq(overflowuid, "65534"))
4058                 e = stpcpy(e, "overflowuid-not-65534:");
4059
4060         r = read_one_line_file("/proc/sys/kernel/overflowgid", &overflowgid);
4061         if (r >= 0 && !streq(overflowgid, "65534"))
4062                 e = stpcpy(e, "overflowgid-not-65534:");
4063
4064         /* remove the last ':' */
4065         if (e != buf)
4066                 e[-1] = 0;
4067
4068         return buf;
4069 }
4070
4071 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
4072         [MANAGER_INITIALIZING] = "initializing",
4073         [MANAGER_STARTING] = "starting",
4074         [MANAGER_RUNNING] = "running",
4075         [MANAGER_DEGRADED] = "degraded",
4076         [MANAGER_MAINTENANCE] = "maintenance",
4077         [MANAGER_STOPPING] = "stopping",
4078 };
4079
4080 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);
4081
4082 static const char *const manager_timestamp_table[_MANAGER_TIMESTAMP_MAX] = {
4083         [MANAGER_TIMESTAMP_FIRMWARE] = "firmware",
4084         [MANAGER_TIMESTAMP_LOADER] = "loader",
4085         [MANAGER_TIMESTAMP_KERNEL] = "kernel",
4086         [MANAGER_TIMESTAMP_INITRD] = "initrd",
4087         [MANAGER_TIMESTAMP_USERSPACE] = "userspace",
4088         [MANAGER_TIMESTAMP_FINISH] = "finish",
4089         [MANAGER_TIMESTAMP_SECURITY_START] = "security-start",
4090         [MANAGER_TIMESTAMP_SECURITY_FINISH] = "security-finish",
4091         [MANAGER_TIMESTAMP_GENERATORS_START] = "generators-start",
4092         [MANAGER_TIMESTAMP_GENERATORS_FINISH] = "generators-finish",
4093         [MANAGER_TIMESTAMP_UNITS_LOAD_START] = "units-load-start",
4094         [MANAGER_TIMESTAMP_UNITS_LOAD_FINISH] = "units-load-finish",
4095 };
4096
4097 DEFINE_STRING_TABLE_LOOKUP(manager_timestamp, ManagerTimestamp);