src/core/manager.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <assert.h>
  23 #include <errno.h>
  24 #include <string.h>
  25 #include <signal.h>
  26 #include <sys/wait.h>
  27 #include <unistd.h>
  28 #include <sys/poll.h>
  29 #include <sys/reboot.h>
  30 #include <sys/ioctl.h>
  31 #include <linux/kd.h>
  32 #include <termios.h>
  33 #include <fcntl.h>
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <dirent.h>
  37 #include <sys/timerfd.h>
  38
  39 #ifdef HAVE_AUDIT
  40 #include <libaudit.h>
  41 #endif
  42
  43 #include "sd-daemon.h"
  44 #include "sd-id128.h"
  45 #include "sd-messages.h"
  46
  47 #include "manager.h"
  48 #include "transaction.h"
  49 #include "hashmap.h"
  50 #include "macro.h"
  51 #include "strv.h"
  52 #include "log.h"
  53 #include "util.h"
  54 #include "mkdir.h"
  55 #include "ratelimit.h"
  56 #include "locale-setup.h"
  57 #include "mount-setup.h"
  58 #include "unit-name.h"
  59 #include "missing.h"
  60 #include "path-lookup.h"
  61 #include "special.h"
  62 #include "exit-status.h"
  63 #include "virt.h"
  64 #include "watchdog.h"
  65 #include "cgroup-util.h"
  66 #include "path-util.h"
  67 #include "audit-fd.h"
  68 #include "boot-timestamps.h"
  69 #include "env-util.h"
  70 #include "bus-errors.h"
  71 #include "bus-error.h"
  72 #include "bus-util.h"
  73 #include "dbus.h"
  74 #include "dbus-unit.h"
  75 #include "dbus-job.h"
  76 #include "dbus-manager.h"
  77 #include "bus-kernel.h"
  78
  79 /* As soon as 5s passed since a unit was added to our GC queue, make sure to run a gc sweep */
  80 #define GC_QUEUE_USEC_MAX (10*USEC_PER_SEC)
  81
  82 /* Initial delay and the interval for printing status messages about running jobs */
  83 #define JOBS_IN_PROGRESS_WAIT_SEC 5
  84 #define JOBS_IN_PROGRESS_PERIOD_SEC 1
  85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
  86
  87 /* Where clients shall send notification messages to */
  88 #define NOTIFY_SOCKET "@/org/freedesktop/systemd1/notify"
  89
  90 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
  91
  92 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  93 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  94 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  95 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  96 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
  97 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
  98
  99 static int manager_watch_jobs_in_progress(Manager *m) {
 100         assert(m);
 101
 102         if (m->jobs_in_progress_event_source)
 103                 return 0;
 104
 105         return sd_event_add_monotonic(m->event, JOBS_IN_PROGRESS_WAIT_SEC, 0, manager_dispatch_jobs_in_progress, m, &m->jobs_in_progress_event_source);
 106 }
 107
 108 #define CYLON_BUFFER_EXTRA (2*(sizeof(ANSI_RED_ON)-1) + sizeof(ANSI_HIGHLIGHT_RED_ON)-1 + 2*(sizeof(ANSI_HIGHLIGHT_OFF)-1))
 109
 110 static void draw_cylon(char buffer[], size_t buflen, unsigned width, unsigned pos) {
 111         char *p = buffer;
 112
 113         assert(buflen >= CYLON_BUFFER_EXTRA + width + 1);
 114         assert(pos <= width+1); /* 0 or width+1 mean that the center light is behind the corner */
 115
 116         if (pos > 1) {
 117                 if (pos > 2)
 118                         p = mempset(p, ' ', pos-2);
 119                 p = stpcpy(p, ANSI_RED_ON);
 120                 *p++ = '*';
 121         }
 122
 123         if (pos > 0 && pos <= width) {
 124                 p = stpcpy(p, ANSI_HIGHLIGHT_RED_ON);
 125                 *p++ = '*';
 126         }
 127
 128         p = stpcpy(p, ANSI_HIGHLIGHT_OFF);
 129
 130         if (pos < width) {
 131                 p = stpcpy(p, ANSI_RED_ON);
 132                 *p++ = '*';
 133                 if (pos < width-1)
 134                         p = mempset(p, ' ', width-1-pos);
 135                 strcpy(p, ANSI_HIGHLIGHT_OFF);
 136         }
 137 }
 138
 139 static void manager_print_jobs_in_progress(Manager *m) {
 140         _cleanup_free_ char *job_of_n = NULL;
 141         Iterator i;
 142         Job *j;
 143         unsigned counter = 0, print_nr;
 144         char cylon[6 + CYLON_BUFFER_EXTRA + 1];
 145         unsigned cylon_pos;
 146
 147         assert(m);
 148
 149         print_nr = (m->jobs_in_progress_iteration / JOBS_IN_PROGRESS_PERIOD_DIVISOR) % m->n_running_jobs;
 150
 151         HASHMAP_FOREACH(j, m->jobs, i)
 152                 if (j->state == JOB_RUNNING && counter++ == print_nr)
 153                         break;
 154
 155         /* m->n_running_jobs must be consistent with the contents of m->jobs,
 156          * so the above loop must have succeeded in finding j. */
 157         assert(counter == print_nr + 1);
 158         assert(j);
 159
 160         cylon_pos = m->jobs_in_progress_iteration % 14;
 161         if (cylon_pos >= 8)
 162                 cylon_pos = 14 - cylon_pos;
 163         draw_cylon(cylon, sizeof(cylon), 6, cylon_pos);
 164
 165         if (m->n_running_jobs > 1)
 166                 if (asprintf(&job_of_n, "(%u of %u) ", counter, m->n_running_jobs) < 0)
 167                         job_of_n = NULL;
 168
 169         manager_status_printf(m, true, cylon, "%sA %s job is running for %s",
 170                               strempty(job_of_n), job_type_to_string(j->type), unit_description(j->unit));
 171
 172         m->jobs_in_progress_iteration++;
 173 }
 174
 175 static int manager_watch_idle_pipe(Manager *m) {
 176         int r;
 177
 178         assert(m);
 179
 180         if (m->idle_pipe_event_source)
 181                 return 0;
 182
 183         if (m->idle_pipe[2] < 0)
 184                 return 0;
 185
 186         r = sd_event_add_io(m->event, m->idle_pipe[2], EPOLLIN, manager_dispatch_idle_pipe_fd, m, &m->idle_pipe_event_source);
 187         if (r < 0) {
 188                 log_error("Failed to watch idle pipe: %s", strerror(-r));
 189                 return r;
 190         }
 191
 192         return 0;
 193 }
 194
 195 static void manager_close_idle_pipe(Manager *m) {
 196         assert(m);
 197
 198         close_pipe(m->idle_pipe);
 199         close_pipe(m->idle_pipe + 2);
 200 }
 201
 202 static int manager_setup_time_change(Manager *m) {
 203         int r;
 204
 205         /* We only care for the cancellation event, hence we set the
 206          * timeout to the latest possible value. */
 207         struct itimerspec its = {
 208                 .it_value.tv_sec = TIME_T_MAX,
 209         };
 210
 211         assert(m);
 212         assert_cc(sizeof(time_t) == sizeof(TIME_T_MAX));
 213
 214         /* Uses TFD_TIMER_CANCEL_ON_SET to get notifications whenever
 215          * CLOCK_REALTIME makes a jump relative to CLOCK_MONOTONIC */
 216
 217         m->time_change_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
 218         if (m->time_change_fd < 0) {
 219                 log_error("Failed to create timerfd: %m");
 220                 return -errno;
 221         }
 222
 223         if (timerfd_settime(m->time_change_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
 224                 log_debug("Failed to set up TFD_TIMER_CANCEL_ON_SET, ignoring: %m");
 225                 close_nointr_nofail(m->time_change_fd);
 226                 m->time_change_fd = -1;
 227                 return 0;
 228         }
 229
 230         r = sd_event_add_io(m->event, m->time_change_fd, EPOLLIN, manager_dispatch_time_change_fd, m, &m->time_change_event_source);
 231         if (r < 0) {
 232                 log_error("Failed to create time change event source: %s", strerror(-r));
 233                 return r;
 234         }
 235
 236         log_debug("Set up TFD_TIMER_CANCEL_ON_SET timerfd.");
 237
 238         return 0;
 239 }
 240
 241 static int enable_special_signals(Manager *m) {
 242         _cleanup_close_ int fd = -1;
 243
 244         assert(m);
 245
 246         /* Enable that we get SIGINT on control-alt-del. In containers
 247          * this will fail with EPERM (older) or EINVAL (newer), so
 248          * ignore that. */
 249         if (reboot(RB_DISABLE_CAD) < 0 && errno != EPERM && errno != EINVAL)
 250                 log_warning("Failed to enable ctrl-alt-del handling: %m");
 251
 252         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
 253         if (fd < 0) {
 254                 /* Support systems without virtual console */
 255                 if (fd != -ENOENT)
 256                         log_warning("Failed to open /dev/tty0: %m");
 257         } else {
 258                 /* Enable that we get SIGWINCH on kbrequest */
 259                 if (ioctl(fd, KDSIGACCEPT, SIGWINCH) < 0)
 260                         log_warning("Failed to enable kbrequest handling: %m");
 261         }
 262
 263         return 0;
 264 }
 265
 266 static int manager_setup_signals(Manager *m) {
 267         struct sigaction sa = {
 268                 .sa_handler = SIG_DFL,
 269                 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
 270         };
 271         sigset_t mask;
 272         int r;
 273
 274         assert(m);
 275
 276         /* We are not interested in SIGSTOP and friends. */
 277         assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
 278
 279         assert_se(sigemptyset(&mask) == 0);
 280
 281         sigset_add_many(&mask,
 282                         SIGCHLD,     /* Child died */
 283                         SIGTERM,     /* Reexecute daemon */
 284                         SIGHUP,      /* Reload configuration */
 285                         SIGUSR1,     /* systemd/upstart: reconnect to D-Bus */
 286                         SIGUSR2,     /* systemd: dump status */
 287                         SIGINT,      /* Kernel sends us this on control-alt-del */
 288                         SIGWINCH,    /* Kernel sends us this on kbrequest (alt-arrowup) */
 289                         SIGPWR,      /* Some kernel drivers and upsd send us this on power failure */
 290                         SIGRTMIN+0,  /* systemd: start default.target */
 291                         SIGRTMIN+1,  /* systemd: isolate rescue.target */
 292                         SIGRTMIN+2,  /* systemd: isolate emergency.target */
 293                         SIGRTMIN+3,  /* systemd: start halt.target */
 294                         SIGRTMIN+4,  /* systemd: start poweroff.target */
 295                         SIGRTMIN+5,  /* systemd: start reboot.target */
 296                         SIGRTMIN+6,  /* systemd: start kexec.target */
 297                         SIGRTMIN+13, /* systemd: Immediate halt */
 298                         SIGRTMIN+14, /* systemd: Immediate poweroff */
 299                         SIGRTMIN+15, /* systemd: Immediate reboot */
 300                         SIGRTMIN+16, /* systemd: Immediate kexec */
 301                         SIGRTMIN+20, /* systemd: enable status messages */
 302                         SIGRTMIN+21, /* systemd: disable status messages */
 303                         SIGRTMIN+22, /* systemd: set log level to LOG_DEBUG */
 304                         SIGRTMIN+23, /* systemd: set log level to LOG_INFO */
 305                         SIGRTMIN+24, /* systemd: Immediate exit (--user only) */
 306                         SIGRTMIN+26, /* systemd: set log target to journal-or-kmsg */
 307                         SIGRTMIN+27, /* systemd: set log target to console */
 308                         SIGRTMIN+28, /* systemd: set log target to kmsg */
 309                         SIGRTMIN+29, /* systemd: set log target to syslog-or-kmsg */
 310                         -1);
 311         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
 312
 313         m->signal_fd = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC);
 314         if (m->signal_fd < 0)
 315                 return -errno;
 316
 317         r = sd_event_add_io(m->event, m->signal_fd, EPOLLIN, manager_dispatch_signal_fd, m, &m->signal_event_source);
 318         if (r < 0)
 319                 return r;
 320
 321         /* Process signals a bit earlier than the rest of things, but
 322          * later that notify_fd processing, so that the notify
 323          * processing can still figure out to which process/service a
 324          * message belongs, before we reap the process. */
 325         r = sd_event_source_set_priority(m->signal_event_source, -5);
 326         if (r < 0)
 327                 return r;
 328
 329         if (m->running_as == SYSTEMD_SYSTEM)
 330                 return enable_special_signals(m);
 331
 332         return 0;
 333 }
 334
 335 static int manager_default_environment(Manager *m) {
 336         assert(m);
 337
 338         if (m->running_as == SYSTEMD_SYSTEM) {
 339                 /* The system manager always starts with a clean
 340                  * environment for its children. It does not import
 341                  * the kernel or the parents exported variables.
 342                  *
 343                  * The initial passed environ is untouched to keep
 344                  * /proc/self/environ valid; it is used for tagging
 345                  * the init process inside containers. */
 346                 m->environment = strv_new("PATH=" DEFAULT_PATH,
 347                                           NULL);
 348
 349                 /* Import locale variables LC_*= from configuration */
 350                 locale_setup(&m->environment);
 351         } else
 352                 /* The user manager passes its own environment
 353                  * along to its children. */
 354                 m->environment = strv_copy(environ);
 355
 356         if (!m->environment)
 357                 return -ENOMEM;
 358
 359         strv_sort(m->environment);
 360
 361         return 0;
 362 }
 363
 364 int manager_new(SystemdRunningAs running_as, Manager **_m) {
 365         Manager *m;
 366         int r;
 367
 368         assert(_m);
 369         assert(running_as >= 0);
 370         assert(running_as < _SYSTEMD_RUNNING_AS_MAX);
 371
 372         m = new0(Manager, 1);
 373         if (!m)
 374                 return -ENOMEM;
 375
 376 #ifdef ENABLE_EFI
 377         if (detect_container(NULL) <= 0)
 378                 boot_timestamps(&m->userspace_timestamp, &m->firmware_timestamp, &m->loader_timestamp);
 379 #endif
 380
 381         m->running_as = running_as;
 382         m->exit_code = _MANAGER_EXIT_CODE_INVALID;
 383
 384         m->idle_pipe[0] = m->idle_pipe[1] = m->idle_pipe[2] = m->idle_pipe[3] = -1;
 385
 386         m->pin_cgroupfs_fd = m->notify_fd = m->signal_fd = m->time_change_fd = m->dev_autofs_fd = m->private_listen_fd = m->kdbus_fd = -1;
 387         m->current_job_id = 1; /* start as id #1, so that we can leave #0 around as "null-like" value */
 388
 389         r = manager_default_environment(m);
 390         if (r < 0)
 391                 goto fail;
 392
 393         r = hashmap_ensure_allocated(&m->units, string_hash_func, string_compare_func);
 394         if (r < 0)
 395                 goto fail;
 396
 397         r = hashmap_ensure_allocated(&m->jobs, trivial_hash_func, trivial_compare_func);
 398         if (r < 0)
 399                 goto fail;
 400
 401         r = hashmap_ensure_allocated(&m->cgroup_unit, string_hash_func, string_compare_func);
 402         if (r < 0)
 403                 goto fail;
 404
 405         r = hashmap_ensure_allocated(&m->watch_pids, trivial_hash_func, trivial_compare_func);
 406         if (r < 0)
 407                 goto fail;
 408
 409         r = hashmap_ensure_allocated(&m->watch_bus, string_hash_func, string_compare_func);
 410         if (r < 0)
 411                 goto fail;
 412
 413         r = sd_event_default(&m->event);
 414         if (r < 0)
 415                 goto fail;
 416
 417         r = sd_event_add_defer(m->event, manager_dispatch_run_queue, m, &m->run_queue_event_source);
 418         if (r < 0)
 419                 goto fail;
 420
 421         r = sd_event_source_set_priority(m->run_queue_event_source, SD_EVENT_PRIORITY_IDLE);
 422         if (r < 0)
 423                 goto fail;
 424
 425         r = sd_event_source_set_enabled(m->run_queue_event_source, SD_EVENT_OFF);
 426         if (r < 0)
 427                 goto fail;
 428
 429         r = manager_setup_signals(m);
 430         if (r < 0)
 431                 goto fail;
 432
 433         r = manager_setup_cgroup(m);
 434         if (r < 0)
 435                 goto fail;
 436
 437         r = manager_setup_time_change(m);
 438         if (r < 0)
 439                 goto fail;
 440
 441         m->udev = udev_new();
 442         if (!m->udev) {
 443                 r = -ENOMEM;
 444                 goto fail;
 445         }
 446
 447         /* Note that we set up neither kdbus, nor the notify fd
 448          * here. We do that after deserialization, since they might
 449          * have gotten serialized across the reexec. */
 450
 451         m->taint_usr = dir_is_empty("/usr") > 0;
 452
 453         *_m = m;
 454         return 0;
 455
 456 fail:
 457         manager_free(m);
 458         return r;
 459 }
 460
 461 static int manager_setup_notify(Manager *m) {
 462         union {
 463                 struct sockaddr sa;
 464                 struct sockaddr_un un;
 465         } sa = {
 466                 .sa.sa_family = AF_UNIX,
 467         };
 468         int one = 1, r;
 469
 470         if (m->notify_fd < 0) {
 471                 _cleanup_close_ int fd = -1;
 472
 473                 /* First free all secondary fields */
 474                 free(m->notify_socket);
 475                 m->notify_socket = NULL;
 476                 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
 477
 478                 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 479                 if (fd < 0) {
 480                         log_error("Failed to allocate notification socket: %m");
 481                         return -errno;
 482                 }
 483
 484                 if (getpid() != 1 || detect_container(NULL) > 0)
 485                         snprintf(sa.un.sun_path, sizeof(sa.un.sun_path), NOTIFY_SOCKET "/%" PRIx64, random_u64());
 486                 else
 487                         strncpy(sa.un.sun_path, NOTIFY_SOCKET, sizeof(sa.un.sun_path));
 488                 sa.un.sun_path[0] = 0;
 489
 490                 r = bind(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1));
 491                 if (r < 0) {
 492                         log_error("bind() failed: %m");
 493                         return -errno;
 494                 }
 495
 496                 r = setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one));
 497                 if (r < 0) {
 498                         log_error("SO_PASSCRED failed: %m");
 499                         return -errno;
 500                 }
 501
 502                 sa.un.sun_path[0] = '@';
 503                 m->notify_socket = strdup(sa.un.sun_path);
 504                 if (!m->notify_socket)
 505                         return log_oom();
 506
 507                 m->notify_fd = fd;
 508                 fd = -1;
 509
 510                 log_debug("Using notification socket %s", m->notify_socket);
 511         }
 512
 513         if (!m->notify_event_source) {
 514                 r = sd_event_add_io(m->event, m->notify_fd, EPOLLIN, manager_dispatch_notify_fd, m, &m->notify_event_source);
 515                 if (r < 0) {
 516                         log_error("Failed to allocate notify event source: %s", strerror(-r));
 517                         return -errno;
 518                 }
 519
 520                 /* Process signals a bit earlier than SIGCHLD, so that we can
 521                  * still identify to which service an exit message belongs */
 522                 r = sd_event_source_set_priority(m->notify_event_source, -7);
 523                 if (r < 0) {
 524                         log_error("Failed to set priority of notify event source: %s", strerror(-r));
 525                         return r;
 526                 }
 527         }
 528
 529         return 0;
 530 }
 531
 532 static int manager_setup_kdbus(Manager *m) {
 533 #ifdef ENABLE_KDBUS
 534         _cleanup_free_ char *p = NULL;
 535 #endif
 536
 537 #ifdef ENABLE_KDBUS
 538         assert(m);
 539
 540         if (m->kdbus_fd >= 0)
 541                 return 0;
 542
 543         m->kdbus_fd = bus_kernel_create_bus(m->running_as == SYSTEMD_SYSTEM ? "system" : "user", m->running_as == SYSTEMD_SYSTEM, &p);
 544         if (m->kdbus_fd < 0) {
 545                 log_debug("Failed to set up kdbus: %s", strerror(-m->kdbus_fd));
 546                 return m->kdbus_fd;
 547         }
 548
 549         log_debug("Successfully set up kdbus on %s", p);
 550
 551         /* Create the namespace directory here, so that the contents
 552          * of that directory is not visible to non-root users. This is
 553          * necessary to ensure that users cannot get access to busses
 554          * of virtualized users when no UID namespacing is used. */
 555         if (m->running_as == SYSTEMD_SYSTEM)
 556                 mkdir_p_label("/dev/kdbus/ns", 0700);
 557 #endif
 558
 559         return 0;
 560 }
 561
 562 static int manager_connect_bus(Manager *m, bool reexecuting) {
 563         bool try_bus_connect;
 564
 565         assert(m);
 566
 567         try_bus_connect =
 568                 m->kdbus_fd >= 0 ||
 569                 reexecuting ||
 570                 (m->running_as == SYSTEMD_USER && getenv("DBUS_SESSION_BUS_ADDRESS"));
 571
 572         /* Try to connect to the busses, if possible. */
 573         return bus_init(m, try_bus_connect);
 574 }
 575
 576 static unsigned manager_dispatch_cleanup_queue(Manager *m) {
 577         Unit *u;
 578         unsigned n = 0;
 579
 580         assert(m);
 581
 582         while ((u = m->cleanup_queue)) {
 583                 assert(u->in_cleanup_queue);
 584
 585                 unit_free(u);
 586                 n++;
 587         }
 588
 589         return n;
 590 }
 591
 592 enum {
 593         GC_OFFSET_IN_PATH,  /* This one is on the path we were traveling */
 594         GC_OFFSET_UNSURE,   /* No clue */
 595         GC_OFFSET_GOOD,     /* We still need this unit */
 596         GC_OFFSET_BAD,      /* We don't need this unit anymore */
 597         _GC_OFFSET_MAX
 598 };
 599
 600 static void unit_gc_sweep(Unit *u, unsigned gc_marker) {
 601         Iterator i;
 602         Unit *other;
 603         bool is_bad;
 604
 605         assert(u);
 606
 607         if (u->gc_marker == gc_marker + GC_OFFSET_GOOD ||
 608             u->gc_marker == gc_marker + GC_OFFSET_BAD ||
 609             u->gc_marker == gc_marker + GC_OFFSET_IN_PATH)
 610                 return;
 611
 612         if (u->in_cleanup_queue)
 613                 goto bad;
 614
 615         if (unit_check_gc(u))
 616                 goto good;
 617
 618         u->gc_marker = gc_marker + GC_OFFSET_IN_PATH;
 619
 620         is_bad = true;
 621
 622         SET_FOREACH(other, u->dependencies[UNIT_REFERENCED_BY], i) {
 623                 unit_gc_sweep(other, gc_marker);
 624
 625                 if (other->gc_marker == gc_marker + GC_OFFSET_GOOD)
 626                         goto good;
 627
 628                 if (other->gc_marker != gc_marker + GC_OFFSET_BAD)
 629                         is_bad = false;
 630         }
 631
 632         if (is_bad)
 633                 goto bad;
 634
 635         /* We were unable to find anything out about this entry, so
 636          * let's investigate it later */
 637         u->gc_marker = gc_marker + GC_OFFSET_UNSURE;
 638         unit_add_to_gc_queue(u);
 639         return;
 640
 641 bad:
 642         /* We definitely know that this one is not useful anymore, so
 643          * let's mark it for deletion */
 644         u->gc_marker = gc_marker + GC_OFFSET_BAD;
 645         unit_add_to_cleanup_queue(u);
 646         return;
 647
 648 good:
 649         u->gc_marker = gc_marker + GC_OFFSET_GOOD;
 650 }
 651
 652 static unsigned manager_dispatch_gc_queue(Manager *m) {
 653         Unit *u;
 654         unsigned n = 0;
 655         unsigned gc_marker;
 656
 657         assert(m);
 658
 659         /* log_debug("Running GC..."); */
 660
 661         m->gc_marker += _GC_OFFSET_MAX;
 662         if (m->gc_marker + _GC_OFFSET_MAX <= _GC_OFFSET_MAX)
 663                 m->gc_marker = 1;
 664
 665         gc_marker = m->gc_marker;
 666
 667         while ((u = m->gc_queue)) {
 668                 assert(u->in_gc_queue);
 669
 670                 unit_gc_sweep(u, gc_marker);
 671
 672                 LIST_REMOVE(gc_queue, m->gc_queue, u);
 673                 u->in_gc_queue = false;
 674
 675                 n++;
 676
 677                 if (u->gc_marker == gc_marker + GC_OFFSET_BAD ||
 678                     u->gc_marker == gc_marker + GC_OFFSET_UNSURE) {
 679                         log_debug_unit(u->id, "Collecting %s", u->id);
 680                         u->gc_marker = gc_marker + GC_OFFSET_BAD;
 681                         unit_add_to_cleanup_queue(u);
 682                 }
 683         }
 684
 685         m->n_in_gc_queue = 0;
 686
 687         return n;
 688 }
 689
 690 static void manager_clear_jobs_and_units(Manager *m) {
 691         Unit *u;
 692
 693         assert(m);
 694
 695         while ((u = hashmap_first(m->units)))
 696                 unit_free(u);
 697
 698         manager_dispatch_cleanup_queue(m);
 699
 700         assert(!m->load_queue);
 701         assert(!m->run_queue);
 702         assert(!m->dbus_unit_queue);
 703         assert(!m->dbus_job_queue);
 704         assert(!m->cleanup_queue);
 705         assert(!m->gc_queue);
 706
 707         assert(hashmap_isempty(m->jobs));
 708         assert(hashmap_isempty(m->units));
 709
 710         m->n_on_console = 0;
 711         m->n_running_jobs = 0;
 712 }
 713
 714 void manager_free(Manager *m) {
 715         UnitType c;
 716         int i;
 717
 718         assert(m);
 719
 720         manager_clear_jobs_and_units(m);
 721
 722         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 723                 if (unit_vtable[c]->shutdown)
 724                         unit_vtable[c]->shutdown(m);
 725
 726         /* If we reexecute ourselves, we keep the root cgroup
 727          * around */
 728         manager_shutdown_cgroup(m, m->exit_code != MANAGER_REEXECUTE);
 729
 730         manager_undo_generators(m);
 731
 732         bus_done(m);
 733
 734         hashmap_free(m->units);
 735         hashmap_free(m->jobs);
 736         hashmap_free(m->watch_pids);
 737         hashmap_free(m->watch_bus);
 738
 739         sd_event_source_unref(m->signal_event_source);
 740         sd_event_source_unref(m->notify_event_source);
 741         sd_event_source_unref(m->time_change_event_source);
 742         sd_event_source_unref(m->jobs_in_progress_event_source);
 743         sd_event_source_unref(m->idle_pipe_event_source);
 744         sd_event_source_unref(m->run_queue_event_source);
 745
 746         if (m->signal_fd >= 0)
 747                 close_nointr_nofail(m->signal_fd);
 748         if (m->notify_fd >= 0)
 749                 close_nointr_nofail(m->notify_fd);
 750         if (m->time_change_fd >= 0)
 751                 close_nointr_nofail(m->time_change_fd);
 752         if (m->kdbus_fd >= 0)
 753                 close_nointr_nofail(m->kdbus_fd);
 754
 755         manager_close_idle_pipe(m);
 756
 757         udev_unref(m->udev);
 758         sd_event_unref(m->event);
 759
 760         free(m->notify_socket);
 761
 762         lookup_paths_free(&m->lookup_paths);
 763         strv_free(m->environment);
 764
 765         hashmap_free(m->cgroup_unit);
 766         set_free_free(m->unit_path_cache);
 767
 768         free(m->switch_root);
 769         free(m->switch_root_init);
 770
 771         for (i = 0; i < RLIMIT_NLIMITS; i++)
 772                 free(m->rlimit[i]);
 773
 774         assert(hashmap_isempty(m->units_requiring_mounts_for));
 775         hashmap_free(m->units_requiring_mounts_for);
 776
 777         free(m);
 778 }
 779
 780 int manager_enumerate(Manager *m) {
 781         int r = 0, q;
 782         UnitType c;
 783
 784         assert(m);
 785
 786         /* Let's ask every type to load all units from disk/kernel
 787          * that it might know */
 788         for (c = 0; c < _UNIT_TYPE_MAX; c++)
 789                 if (unit_vtable[c]->enumerate) {
 790                         q = unit_vtable[c]->enumerate(m);
 791                         if (q < 0)
 792                                 r = q;
 793                 }
 794
 795         manager_dispatch_load_queue(m);
 796         return r;
 797 }
 798
 799 static int manager_coldplug(Manager *m) {
 800         int r = 0, q;
 801         Iterator i;
 802         Unit *u;
 803         char *k;
 804
 805         assert(m);
 806
 807         /* Then, let's set up their initial state. */
 808         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
 809
 810                 /* ignore aliases */
 811                 if (u->id != k)
 812                         continue;
 813
 814                 if ((q = unit_coldplug(u)) < 0)
 815                         r = q;
 816         }
 817
 818         return r;
 819 }
 820
 821 static void manager_build_unit_path_cache(Manager *m) {
 822         char **i;
 823         _cleanup_free_ DIR *d = NULL;
 824         int r;
 825
 826         assert(m);
 827
 828         set_free_free(m->unit_path_cache);
 829
 830         m->unit_path_cache = set_new(string_hash_func, string_compare_func);
 831         if (!m->unit_path_cache) {
 832                 log_error("Failed to allocate unit path cache.");
 833                 return;
 834         }
 835
 836         /* This simply builds a list of files we know exist, so that
 837          * we don't always have to go to disk */
 838
 839         STRV_FOREACH(i, m->lookup_paths.unit_path) {
 840                 struct dirent *de;
 841
 842                 d = opendir(*i);
 843                 if (!d) {
 844                         if (errno != ENOENT)
 845                                 log_error("Failed to open directory %s: %m", *i);
 846                         continue;
 847                 }
 848
 849                 while ((de = readdir(d))) {
 850                         char *p;
 851
 852                         if (ignore_file(de->d_name))
 853                                 continue;
 854
 855                         p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
 856                         if (!p) {
 857                                 r = -ENOMEM;
 858                                 goto fail;
 859                         }
 860
 861                         r = set_consume(m->unit_path_cache, p);
 862                         if (r < 0)
 863                                 goto fail;
 864                 }
 865
 866                 closedir(d);
 867                 d = NULL;
 868         }
 869
 870         return;
 871
 872 fail:
 873         log_error("Failed to build unit path cache: %s", strerror(-r));
 874
 875         set_free_free(m->unit_path_cache);
 876         m->unit_path_cache = NULL;
 877 }
 878
 879
 880 static int manager_distribute_fds(Manager *m, FDSet *fds) {
 881         Unit *u;
 882         Iterator i;
 883         int r;
 884
 885         assert(m);
 886
 887         HASHMAP_FOREACH(u, m->units, i) {
 888
 889                 if (fdset_size(fds) <= 0)
 890                         break;
 891
 892                 if (UNIT_VTABLE(u)->distribute_fds) {
 893                         r = UNIT_VTABLE(u)->distribute_fds(u, fds);
 894                         if (r < 0)
 895                                 return r;
 896                 }
 897         }
 898
 899         return 0;
 900 }
 901
 902 int manager_startup(Manager *m, FILE *serialization, FDSet *fds) {
 903         int r, q;
 904
 905         assert(m);
 906
 907         dual_timestamp_get(&m->generators_start_timestamp);
 908         manager_run_generators(m);
 909         dual_timestamp_get(&m->generators_finish_timestamp);
 910
 911         r = lookup_paths_init(
 912                         &m->lookup_paths, m->running_as, true,
 913                         m->generator_unit_path,
 914                         m->generator_unit_path_early,
 915                         m->generator_unit_path_late);
 916         if (r < 0)
 917                 return r;
 918
 919         manager_build_unit_path_cache(m);
 920
 921         /* If we will deserialize make sure that during enumeration
 922          * this is already known, so we increase the counter here
 923          * already */
 924         if (serialization)
 925                 m->n_reloading ++;
 926
 927         /* First, enumerate what we can from all config files */
 928         dual_timestamp_get(&m->units_load_start_timestamp);
 929         r = manager_enumerate(m);
 930         dual_timestamp_get(&m->units_load_finish_timestamp);
 931
 932         /* Second, deserialize if there is something to deserialize */
 933         if (serialization) {
 934                 q = manager_deserialize(m, serialization, fds);
 935                 if (q < 0)
 936                         r = q;
 937         }
 938
 939         /* Any fds left? Find some unit which wants them. This is
 940          * useful to allow container managers to pass some file
 941          * descriptors to us pre-initialized. This enables
 942          * socket-based activation of entire containers. */
 943         if (fdset_size(fds) > 0) {
 944                 q = manager_distribute_fds(m, fds);
 945                 if (q < 0)
 946                         r = q;
 947         }
 948
 949         /* We might have deserialized the notify fd, but if we didn't
 950          * then let's create the bus now */
 951         manager_setup_notify(m);
 952
 953         /* We might have deserialized the kdbus control fd, but if we
 954          * didn't, then let's create the bus now. */
 955         manager_setup_kdbus(m);
 956         manager_connect_bus(m, !!serialization);
 957
 958         /* Third, fire things up! */
 959         q = manager_coldplug(m);
 960         if (q < 0)
 961                 r = q;
 962
 963         if (serialization) {
 964                 assert(m->n_reloading > 0);
 965                 m->n_reloading --;
 966
 967                 /* Let's wait for the UnitNew/JobNew messages being
 968                  * sent, before we notify that the reload is
 969                  * finished */
 970                 m->send_reloading_done = true;
 971         }
 972
 973         return r;
 974 }
 975
 976 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
 977         int r;
 978         Transaction *tr;
 979
 980         assert(m);
 981         assert(type < _JOB_TYPE_MAX);
 982         assert(unit);
 983         assert(mode < _JOB_MODE_MAX);
 984
 985         if (mode == JOB_ISOLATE && type != JOB_START) {
 986                 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
 987                 return -EINVAL;
 988         }
 989
 990         if (mode == JOB_ISOLATE && !unit->allow_isolate) {
 991                 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
 992                 return -EPERM;
 993         }
 994
 995         log_debug_unit(unit->id,
 996                        "Trying to enqueue job %s/%s/%s", unit->id,
 997                        job_type_to_string(type), job_mode_to_string(mode));
 998
 999         job_type_collapse(&type, unit);
1000
1001         tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1002         if (!tr)
1003                 return -ENOMEM;
1004
1005         r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1006                                                  mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1007                                                  mode == JOB_IGNORE_DEPENDENCIES, e);
1008         if (r < 0)
1009                 goto tr_abort;
1010
1011         if (mode == JOB_ISOLATE) {
1012                 r = transaction_add_isolate_jobs(tr, m);
1013                 if (r < 0)
1014                         goto tr_abort;
1015         }
1016
1017         r = transaction_activate(tr, m, mode, e);
1018         if (r < 0)
1019                 goto tr_abort;
1020
1021         log_debug_unit(unit->id,
1022                        "Enqueued job %s/%s as %u", unit->id,
1023                        job_type_to_string(type), (unsigned) tr->anchor_job->id);
1024
1025         if (_ret)
1026                 *_ret = tr->anchor_job;
1027
1028         transaction_free(tr);
1029         return 0;
1030
1031 tr_abort:
1032         transaction_abort(tr);
1033         transaction_free(tr);
1034         return r;
1035 }
1036
1037 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1038         Unit *unit;
1039         int r;
1040
1041         assert(m);
1042         assert(type < _JOB_TYPE_MAX);
1043         assert(name);
1044         assert(mode < _JOB_MODE_MAX);
1045
1046         r = manager_load_unit(m, name, NULL, NULL, &unit);
1047         if (r < 0)
1048                 return r;
1049
1050         return manager_add_job(m, type, unit, mode, override, e, _ret);
1051 }
1052
1053 Job *manager_get_job(Manager *m, uint32_t id) {
1054         assert(m);
1055
1056         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1057 }
1058
1059 Unit *manager_get_unit(Manager *m, const char *name) {
1060         assert(m);
1061         assert(name);
1062
1063         return hashmap_get(m->units, name);
1064 }
1065
1066 unsigned manager_dispatch_load_queue(Manager *m) {
1067         Unit *u;
1068         unsigned n = 0;
1069
1070         assert(m);
1071
1072         /* Make sure we are not run recursively */
1073         if (m->dispatching_load_queue)
1074                 return 0;
1075
1076         m->dispatching_load_queue = true;
1077
1078         /* Dispatches the load queue. Takes a unit from the queue and
1079          * tries to load its data until the queue is empty */
1080
1081         while ((u = m->load_queue)) {
1082                 assert(u->in_load_queue);
1083
1084                 unit_load(u);
1085                 n++;
1086         }
1087
1088         m->dispatching_load_queue = false;
1089         return n;
1090 }
1091
1092 int manager_load_unit_prepare(
1093                 Manager *m,
1094                 const char *name,
1095                 const char *path,
1096                 sd_bus_error *e,
1097                 Unit **_ret) {
1098
1099         Unit *ret;
1100         UnitType t;
1101         int r;
1102
1103         assert(m);
1104         assert(name || path);
1105
1106         /* This will prepare the unit for loading, but not actually
1107          * load anything from disk. */
1108
1109         if (path && !is_path(path))
1110                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1111
1112         if (!name)
1113                 name = basename(path);
1114
1115         t = unit_name_to_type(name);
1116
1117         if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1118                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1119
1120         ret = manager_get_unit(m, name);
1121         if (ret) {
1122                 *_ret = ret;
1123                 return 1;
1124         }
1125
1126         ret = unit_new(m, unit_vtable[t]->object_size);
1127         if (!ret)
1128                 return -ENOMEM;
1129
1130         if (path) {
1131                 ret->fragment_path = strdup(path);
1132                 if (!ret->fragment_path) {
1133                         unit_free(ret);
1134                         return -ENOMEM;
1135                 }
1136         }
1137
1138         r = unit_add_name(ret, name);
1139         if (r < 0) {
1140                 unit_free(ret);
1141                 return r;
1142         }
1143
1144         unit_add_to_load_queue(ret);
1145         unit_add_to_dbus_queue(ret);
1146         unit_add_to_gc_queue(ret);
1147
1148         if (_ret)
1149                 *_ret = ret;
1150
1151         return 0;
1152 }
1153
1154 int manager_load_unit(
1155                 Manager *m,
1156                 const char *name,
1157                 const char *path,
1158                 sd_bus_error *e,
1159                 Unit **_ret) {
1160
1161         int r;
1162
1163         assert(m);
1164
1165         /* This will load the service information files, but not actually
1166          * start any services or anything. */
1167
1168         r = manager_load_unit_prepare(m, name, path, e, _ret);
1169         if (r != 0)
1170                 return r;
1171
1172         manager_dispatch_load_queue(m);
1173
1174         if (_ret)
1175                 *_ret = unit_follow_merge(*_ret);
1176
1177         return 0;
1178 }
1179
1180 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1181         Iterator i;
1182         Job *j;
1183
1184         assert(s);
1185         assert(f);
1186
1187         HASHMAP_FOREACH(j, s->jobs, i)
1188                 job_dump(j, f, prefix);
1189 }
1190
1191 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1192         Iterator i;
1193         Unit *u;
1194         const char *t;
1195
1196         assert(s);
1197         assert(f);
1198
1199         HASHMAP_FOREACH_KEY(u, t, s->units, i)
1200                 if (u->id == t)
1201                         unit_dump(u, f, prefix);
1202 }
1203
1204 void manager_clear_jobs(Manager *m) {
1205         Job *j;
1206
1207         assert(m);
1208
1209         while ((j = hashmap_first(m->jobs)))
1210                 /* No need to recurse. We're cancelling all jobs. */
1211                 job_finish_and_invalidate(j, JOB_CANCELED, false);
1212 }
1213
1214 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1215         Manager *m = userdata;
1216         Job *j;
1217
1218         assert(source);
1219         assert(m);
1220
1221         while ((j = m->run_queue)) {
1222                 assert(j->installed);
1223                 assert(j->in_run_queue);
1224
1225                 job_run_and_invalidate(j);
1226         }
1227
1228         if (m->n_running_jobs > 0)
1229                 manager_watch_jobs_in_progress(m);
1230
1231         if (m->n_on_console > 0)
1232                 manager_watch_idle_pipe(m);
1233
1234         return 1;
1235 }
1236
1237 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1238         Job *j;
1239         Unit *u;
1240         unsigned n = 0;
1241
1242         assert(m);
1243
1244         if (m->dispatching_dbus_queue)
1245                 return 0;
1246
1247         m->dispatching_dbus_queue = true;
1248
1249         while ((u = m->dbus_unit_queue)) {
1250                 assert(u->in_dbus_queue);
1251
1252                 bus_unit_send_change_signal(u);
1253                 n++;
1254         }
1255
1256         while ((j = m->dbus_job_queue)) {
1257                 assert(j->in_dbus_queue);
1258
1259                 bus_job_send_change_signal(j);
1260                 n++;
1261         }
1262
1263         m->dispatching_dbus_queue = false;
1264
1265         if (m->send_reloading_done) {
1266                 m->send_reloading_done = false;
1267
1268                 bus_manager_send_reloading(m, false);
1269         }
1270
1271         if (m->queued_message)
1272                 bus_send_queued_message(m);
1273
1274         return n;
1275 }
1276
1277 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1278         Manager *m = userdata;
1279         ssize_t n;
1280
1281         assert(m);
1282         assert(m->notify_fd == fd);
1283
1284         if (revents != EPOLLIN) {
1285                 log_warning("Got unexpected poll event for notify fd.");
1286                 return 0;
1287         }
1288
1289         for (;;) {
1290                 char buf[4096];
1291                 struct iovec iovec = {
1292                         .iov_base = buf,
1293                         .iov_len = sizeof(buf)-1,
1294                 };
1295
1296                 union {
1297                         struct cmsghdr cmsghdr;
1298                         uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1299                 } control = {};
1300
1301                 struct msghdr msghdr = {
1302                         .msg_iov = &iovec,
1303                         .msg_iovlen = 1,
1304                         .msg_control = &control,
1305                         .msg_controllen = sizeof(control),
1306                 };
1307                 struct ucred *ucred;
1308                 Unit *u;
1309                 _cleanup_strv_free_ char **tags = NULL;
1310
1311                 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1312                 if (n <= 0) {
1313                         if (n == 0)
1314                                 return -EIO;
1315
1316                         if (errno == EAGAIN || errno == EINTR)
1317                                 break;
1318
1319                         return -errno;
1320                 }
1321
1322                 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1323                     control.cmsghdr.cmsg_level != SOL_SOCKET ||
1324                     control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1325                     control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1326                         log_warning("Received notify message without credentials. Ignoring.");
1327                         continue;
1328                 }
1329
1330                 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1331
1332                 u = hashmap_get(m->watch_pids, LONG_TO_PTR(ucred->pid));
1333                 if (!u) {
1334                         u = manager_get_unit_by_pid(m, ucred->pid);
1335                         if (!u) {
1336                                 log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1337                                 continue;
1338                         }
1339                 }
1340
1341                 assert((size_t) n < sizeof(buf));
1342                 buf[n] = 0;
1343                 tags = strv_split(buf, "\n\r");
1344                 if (!tags)
1345                         return log_oom();
1346
1347                 log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1348
1349                 if (UNIT_VTABLE(u)->notify_message)
1350                         UNIT_VTABLE(u)->notify_message(u, ucred->pid, tags);
1351         }
1352
1353         return 0;
1354 }
1355
1356 static int manager_dispatch_sigchld(Manager *m) {
1357         assert(m);
1358
1359         for (;;) {
1360                 siginfo_t si = {};
1361                 Unit *u;
1362
1363                 /* First we call waitd() for a PID and do not reap the
1364                  * zombie. That way we can still access /proc/$PID for
1365                  * it while it is a zombie. */
1366                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1367
1368                         if (errno == ECHILD)
1369                                 break;
1370
1371                         if (errno == EINTR)
1372                                 continue;
1373
1374                         return -errno;
1375                 }
1376
1377                 if (si.si_pid <= 0)
1378                         break;
1379
1380                 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1381                         _cleanup_free_ char *name = NULL;
1382
1383                         get_process_comm(si.si_pid, &name);
1384                         log_debug("Got SIGCHLD for process "PID_FMT" (%s)", si.si_pid, strna(name));
1385                 }
1386
1387                 /* And now figure out the unit this belongs to */
1388                 u = hashmap_get(m->watch_pids, LONG_TO_PTR(si.si_pid));
1389                 if (!u)
1390                         u = manager_get_unit_by_pid(m, si.si_pid);
1391
1392                 /* And now, we actually reap the zombie. */
1393                 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1394                         if (errno == EINTR)
1395                                 continue;
1396
1397                         return -errno;
1398                 }
1399
1400                 if (si.si_code != CLD_EXITED && si.si_code != CLD_KILLED && si.si_code != CLD_DUMPED)
1401                         continue;
1402
1403                 log_debug("Child %lu died (code=%s, status=%i/%s)",
1404                           (long unsigned) si.si_pid,
1405                           sigchld_code_to_string(si.si_code),
1406                           si.si_status,
1407                           strna(si.si_code == CLD_EXITED
1408                                 ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1409                                 : signal_to_string(si.si_status)));
1410
1411                 if (!u)
1412                         continue;
1413
1414                 log_debug_unit(u->id,
1415                                "Child %lu belongs to %s", (long unsigned) si.si_pid, u->id);
1416
1417                 hashmap_remove(m->watch_pids, LONG_TO_PTR(si.si_pid));
1418                 UNIT_VTABLE(u)->sigchld_event(u, si.si_pid, si.si_code, si.si_status);
1419         }
1420
1421         return 0;
1422 }
1423
1424 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1425         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1426         int r;
1427
1428         log_debug_unit(name, "Activating special unit %s", name);
1429
1430         r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1431         if (r < 0)
1432                 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1433
1434         return r;
1435 }
1436
1437 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1438         Manager *m = userdata;
1439         ssize_t n;
1440         struct signalfd_siginfo sfsi;
1441         bool sigchld = false;
1442
1443         assert(m);
1444         assert(m->signal_fd == fd);
1445
1446         if (revents != EPOLLIN) {
1447                 log_warning("Got unexpected events from signal file descriptor.");
1448                 return 0;
1449         }
1450
1451         for (;;) {
1452                 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1453                 if (n != sizeof(sfsi)) {
1454
1455                         if (n >= 0)
1456                                 return -EIO;
1457
1458                         if (errno == EINTR || errno == EAGAIN)
1459                                 break;
1460
1461                         return -errno;
1462                 }
1463
1464                 if (sfsi.ssi_pid > 0) {
1465                         _cleanup_free_ char *p = NULL;
1466
1467                         get_process_comm(sfsi.ssi_pid, &p);
1468
1469                         log_full(sfsi.ssi_signo == SIGCHLD ||
1470                                  (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1471                                  ? LOG_DEBUG : LOG_INFO,
1472                                  "Received SIG%s from PID "PID_FMT" (%s).",
1473                                  signal_to_string(sfsi.ssi_signo),
1474                                  sfsi.ssi_pid, strna(p));
1475                 } else
1476                         log_full(sfsi.ssi_signo == SIGCHLD ||
1477                                  (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1478                                  ? LOG_DEBUG : LOG_INFO,
1479                                  "Received SIG%s.",
1480                                  signal_to_string(sfsi.ssi_signo));
1481
1482                 switch (sfsi.ssi_signo) {
1483
1484                 case SIGCHLD:
1485                         sigchld = true;
1486                         break;
1487
1488                 case SIGTERM:
1489                         if (m->running_as == SYSTEMD_SYSTEM) {
1490                                 /* This is for compatibility with the
1491                                  * original sysvinit */
1492                                 m->exit_code = MANAGER_REEXECUTE;
1493                                 break;
1494                         }
1495
1496                         /* Fall through */
1497
1498                 case SIGINT:
1499                         if (m->running_as == SYSTEMD_SYSTEM) {
1500                                 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1501                                 break;
1502                         }
1503
1504                         /* Run the exit target if there is one, if not, just exit. */
1505                         if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1506                                 m->exit_code = MANAGER_EXIT;
1507                                 return 0;
1508                         }
1509
1510                         break;
1511
1512                 case SIGWINCH:
1513                         if (m->running_as == SYSTEMD_SYSTEM)
1514                                 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1515
1516                         /* This is a nop on non-init */
1517                         break;
1518
1519                 case SIGPWR:
1520                         if (m->running_as == SYSTEMD_SYSTEM)
1521                                 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1522
1523                         /* This is a nop on non-init */
1524                         break;
1525
1526                 case SIGUSR1: {
1527                         Unit *u;
1528
1529                         u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1530
1531                         if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1532                                 log_info("Trying to reconnect to bus...");
1533                                 bus_init(m, true);
1534                         }
1535
1536                         if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1537                                 log_info("Loading D-Bus service...");
1538                                 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1539                         }
1540
1541                         break;
1542                 }
1543
1544                 case SIGUSR2: {
1545                         _cleanup_free_ char *dump = NULL;
1546                         _cleanup_fclose_ FILE *f = NULL;
1547                         size_t size;
1548
1549                         f = open_memstream(&dump, &size);
1550                         if (!f) {
1551                                 log_warning("Failed to allocate memory stream.");
1552                                 break;
1553                         }
1554
1555                         manager_dump_units(m, f, "\t");
1556                         manager_dump_jobs(m, f, "\t");
1557
1558                         if (ferror(f)) {
1559                                 log_warning("Failed to write status stream");
1560                                 break;
1561                         }
1562
1563                         log_dump(LOG_INFO, dump);
1564                         break;
1565                 }
1566
1567                 case SIGHUP:
1568                         m->exit_code = MANAGER_RELOAD;
1569                         break;
1570
1571                 default: {
1572
1573                         /* Starting SIGRTMIN+0 */
1574                         static const char * const target_table[] = {
1575                                 [0] = SPECIAL_DEFAULT_TARGET,
1576                                 [1] = SPECIAL_RESCUE_TARGET,
1577                                 [2] = SPECIAL_EMERGENCY_TARGET,
1578                                 [3] = SPECIAL_HALT_TARGET,
1579                                 [4] = SPECIAL_POWEROFF_TARGET,
1580                                 [5] = SPECIAL_REBOOT_TARGET,
1581                                 [6] = SPECIAL_KEXEC_TARGET
1582                         };
1583
1584                         /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1585                         static const ManagerExitCode code_table[] = {
1586                                 [0] = MANAGER_HALT,
1587                                 [1] = MANAGER_POWEROFF,
1588                                 [2] = MANAGER_REBOOT,
1589                                 [3] = MANAGER_KEXEC
1590                         };
1591
1592                         if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1593                             (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1594                                 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1595                                 manager_start_target(m, target_table[idx],
1596                                                      (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1597                                 break;
1598                         }
1599
1600                         if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1601                             (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1602                                 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1603                                 break;
1604                         }
1605
1606                         switch (sfsi.ssi_signo - SIGRTMIN) {
1607
1608                         case 20:
1609                                 log_debug("Enabling showing of status.");
1610                                 manager_set_show_status(m, true);
1611                                 break;
1612
1613                         case 21:
1614                                 log_debug("Disabling showing of status.");
1615                                 manager_set_show_status(m, false);
1616                                 break;
1617
1618                         case 22:
1619                                 log_set_max_level(LOG_DEBUG);
1620                                 log_notice("Setting log level to debug.");
1621                                 break;
1622
1623                         case 23:
1624                                 log_set_max_level(LOG_INFO);
1625                                 log_notice("Setting log level to info.");
1626                                 break;
1627
1628                         case 24:
1629                                 if (m->running_as == SYSTEMD_USER) {
1630                                         m->exit_code = MANAGER_EXIT;
1631                                         return 0;
1632                                 }
1633
1634                                 /* This is a nop on init */
1635                                 break;
1636
1637                         case 26:
1638                                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1639                                 log_notice("Setting log target to journal-or-kmsg.");
1640                                 break;
1641
1642                         case 27:
1643                                 log_set_target(LOG_TARGET_CONSOLE);
1644                                 log_notice("Setting log target to console.");
1645                                 break;
1646
1647                         case 28:
1648                                 log_set_target(LOG_TARGET_KMSG);
1649                                 log_notice("Setting log target to kmsg.");
1650                                 break;
1651
1652                         case 29:
1653                                 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1654                                 log_notice("Setting log target to syslog-or-kmsg.");
1655                                 break;
1656
1657                         default:
1658                                 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1659                         }
1660                 }
1661                 }
1662         }
1663
1664         if (sigchld)
1665                 manager_dispatch_sigchld(m);
1666
1667         return 0;
1668 }
1669
1670 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1671         Manager *m = userdata;
1672         Iterator i;
1673         Unit *u;
1674
1675         assert(m);
1676         assert(m->time_change_fd == fd);
1677
1678         log_struct(LOG_INFO,
1679                    MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1680                    "MESSAGE=Time has been changed",
1681                    NULL);
1682
1683         /* Restart the watch */
1684         m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1685
1686         close_nointr_nofail(m->time_change_fd);
1687         m->time_change_fd = -1;
1688
1689         manager_setup_time_change(m);
1690
1691         HASHMAP_FOREACH(u, m->units, i)
1692                 if (UNIT_VTABLE(u)->time_change)
1693                         UNIT_VTABLE(u)->time_change(u);
1694
1695         return 0;
1696 }
1697
1698 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1699         Manager *m = userdata;
1700
1701         assert(m);
1702         assert(m->idle_pipe[2] == fd);
1703
1704         m->no_console_output = m->n_on_console > 0;
1705
1706         m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1707         manager_close_idle_pipe(m);
1708
1709         return 0;
1710 }
1711
1712 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1713         Manager *m = userdata;
1714
1715         assert(m);
1716
1717         manager_print_jobs_in_progress(m);
1718         return 0;
1719 }
1720
1721 int manager_loop(Manager *m) {
1722         int r;
1723
1724         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1725
1726         assert(m);
1727         m->exit_code = MANAGER_RUNNING;
1728
1729         /* Release the path cache */
1730         set_free_free(m->unit_path_cache);
1731         m->unit_path_cache = NULL;
1732
1733         manager_check_finished(m);
1734
1735         /* There might still be some zombies hanging around from
1736          * before we were exec()'ed. Let's reap them. */
1737         r = manager_dispatch_sigchld(m);
1738         if (r < 0)
1739                 return r;
1740
1741         while (m->exit_code == MANAGER_RUNNING) {
1742                 usec_t wait_usec;
1743
1744                 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1745                         watchdog_ping();
1746
1747                 if (!ratelimit_test(&rl)) {
1748                         /* Yay, something is going seriously wrong, pause a little */
1749                         log_warning("Looping too fast. Throttling execution a little.");
1750                         sleep(1);
1751                         continue;
1752                 }
1753
1754                 if (manager_dispatch_load_queue(m) > 0)
1755                         continue;
1756
1757                 if (manager_dispatch_gc_queue(m) > 0)
1758                         continue;
1759
1760                 if (manager_dispatch_cleanup_queue(m) > 0)
1761                         continue;
1762
1763                 if (manager_dispatch_cgroup_queue(m) > 0)
1764                         continue;
1765
1766                 if (manager_dispatch_dbus_queue(m) > 0)
1767                         continue;
1768
1769                 /* Sleep for half the watchdog time */
1770                 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1771                         wait_usec = m->runtime_watchdog / 2;
1772                         if (wait_usec <= 0)
1773                                 wait_usec = 1;
1774                 } else
1775                         wait_usec = (usec_t) -1;
1776
1777                 r = sd_event_run(m->event, wait_usec);
1778                 if (r < 0) {
1779                         log_error("Failed to run event loop: %s", strerror(-r));
1780                         return r;
1781                 }
1782         }
1783
1784         return m->exit_code;
1785 }
1786
1787 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1788         _cleanup_free_ char *n = NULL;
1789         Unit *u;
1790         int r;
1791
1792         assert(m);
1793         assert(s);
1794         assert(_u);
1795
1796         r = unit_name_from_dbus_path(s, &n);
1797         if (r < 0)
1798                 return r;
1799
1800         r = manager_load_unit(m, n, NULL, e, &u);
1801         if (r < 0)
1802                 return r;
1803
1804         *_u = u;
1805
1806         return 0;
1807 }
1808
1809 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1810         const char *p;
1811         unsigned id;
1812         Job *j;
1813         int r;
1814
1815         assert(m);
1816         assert(s);
1817         assert(_j);
1818
1819         p = startswith(s, "/org/freedesktop/systemd1/job/");
1820         if (!p)
1821                 return -EINVAL;
1822
1823         r = safe_atou(p, &id);
1824         if (r < 0)
1825                 return r;
1826
1827         j = manager_get_job(m, id);
1828         if (!j)
1829                 return -ENOENT;
1830
1831         *_j = j;
1832
1833         return 0;
1834 }
1835
1836 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1837
1838 #ifdef HAVE_AUDIT
1839         char *p;
1840         int audit_fd;
1841
1842         audit_fd = get_audit_fd();
1843         if (audit_fd < 0)
1844                 return;
1845
1846         /* Don't generate audit events if the service was already
1847          * started and we're just deserializing */
1848         if (m->n_reloading > 0)
1849                 return;
1850
1851         if (m->running_as != SYSTEMD_SYSTEM)
1852                 return;
1853
1854         if (u->type != UNIT_SERVICE)
1855                 return;
1856
1857         p = unit_name_to_prefix_and_instance(u->id);
1858         if (!p) {
1859                 log_error_unit(u->id,
1860                                "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1861                 return;
1862         }
1863
1864         if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1865                 if (errno == EPERM) {
1866                         /* We aren't allowed to send audit messages?
1867                          * Then let's not retry again. */
1868                         close_audit_fd();
1869                 } else
1870                         log_warning("Failed to send audit message: %m");
1871         }
1872
1873         free(p);
1874 #endif
1875
1876 }
1877
1878 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1879         int fd = -1;
1880         union sockaddr_union sa;
1881         int n = 0;
1882         char *message = NULL;
1883
1884         /* Don't generate plymouth events if the service was already
1885          * started and we're just deserializing */
1886         if (m->n_reloading > 0)
1887                 return;
1888
1889         if (m->running_as != SYSTEMD_SYSTEM)
1890                 return;
1891
1892         if (detect_container(NULL) > 0)
1893                 return;
1894
1895         if (u->type != UNIT_SERVICE &&
1896             u->type != UNIT_MOUNT &&
1897             u->type != UNIT_SWAP)
1898                 return;
1899
1900         /* We set SOCK_NONBLOCK here so that we rather drop the
1901          * message then wait for plymouth */
1902         fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
1903         if (fd < 0) {
1904                 log_error("socket() failed: %m");
1905                 return;
1906         }
1907
1908         zero(sa);
1909         sa.sa.sa_family = AF_UNIX;
1910         strncpy(sa.un.sun_path+1, "/org/freedesktop/plymouthd", sizeof(sa.un.sun_path)-1);
1911         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
1912
1913                 if (errno != EPIPE &&
1914                     errno != EAGAIN &&
1915                     errno != ENOENT &&
1916                     errno != ECONNREFUSED &&
1917                     errno != ECONNRESET &&
1918                     errno != ECONNABORTED)
1919                         log_error("connect() failed: %m");
1920
1921                 goto finish;
1922         }
1923
1924         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
1925                 log_oom();
1926                 goto finish;
1927         }
1928
1929         errno = 0;
1930         if (write(fd, message, n + 1) != n + 1) {
1931
1932                 if (errno != EPIPE &&
1933                     errno != EAGAIN &&
1934                     errno != ENOENT &&
1935                     errno != ECONNREFUSED &&
1936                     errno != ECONNRESET &&
1937                     errno != ECONNABORTED)
1938                         log_error("Failed to write Plymouth message: %m");
1939
1940                 goto finish;
1941         }
1942
1943 finish:
1944         if (fd >= 0)
1945                 close_nointr_nofail(fd);
1946
1947         free(message);
1948 }
1949
1950 void manager_dispatch_bus_name_owner_changed(
1951                 Manager *m,
1952                 const char *name,
1953                 const char* old_owner,
1954                 const char *new_owner) {
1955
1956         Unit *u;
1957
1958         assert(m);
1959         assert(name);
1960
1961         u = hashmap_get(m->watch_bus, name);
1962         if (!u)
1963                 return;
1964
1965         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
1966 }
1967
1968 int manager_open_serialization(Manager *m, FILE **_f) {
1969         _cleanup_free_ char *path = NULL;
1970         int fd = -1;
1971         FILE *f;
1972
1973         assert(_f);
1974
1975         if (m->running_as == SYSTEMD_SYSTEM)
1976                 asprintf(&path, "/run/systemd/dump-"PID_FMT"-XXXXXX", getpid());
1977         else
1978                 asprintf(&path, "/tmp/systemd-dump-"PID_FMT"-XXXXXX", getpid());
1979
1980         if (!path)
1981                 return -ENOMEM;
1982
1983         RUN_WITH_UMASK(0077) {
1984                 fd = mkostemp(path, O_RDWR|O_CLOEXEC);
1985         }
1986
1987         if (fd < 0)
1988                 return -errno;
1989
1990         unlink(path);
1991         log_debug("Serializing state to %s", path);
1992
1993         f = fdopen(fd, "w+");
1994         if (!f) {
1995                 close_nointr_nofail(fd);
1996                 return -errno;
1997         }
1998
1999         *_f = f;
2000
2001         return 0;
2002 }
2003
2004 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2005         Iterator i;
2006         Unit *u;
2007         const char *t;
2008         char **e;
2009         int r;
2010
2011         assert(m);
2012         assert(f);
2013         assert(fds);
2014
2015         m->n_reloading ++;
2016
2017         fprintf(f, "current-job-id=%i\n", m->current_job_id);
2018         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2019         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2020         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2021
2022         dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2023         dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2024         dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2025         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2026
2027         if (!in_initrd()) {
2028                 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2029                 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2030                 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2031                 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2032                 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2033                 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2034                 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2035                 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2036         }
2037
2038         if (!switching_root) {
2039                 STRV_FOREACH(e, m->environment) {
2040                         _cleanup_free_ char *ce;
2041
2042                         ce = cescape(*e);
2043                         if (!ce)
2044                                 return -ENOMEM;
2045
2046                         fprintf(f, "env=%s\n", *e);
2047                 }
2048         }
2049
2050         if (m->notify_fd >= 0) {
2051                 int copy;
2052
2053                 copy = fdset_put_dup(fds, m->notify_fd);
2054                 if (copy < 0)
2055                         return copy;
2056
2057                 fprintf(f, "notify-fd=%i\n", copy);
2058                 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2059         }
2060
2061         if (m->kdbus_fd >= 0) {
2062                 int copy;
2063
2064                 copy = fdset_put_dup(fds, m->kdbus_fd);
2065                 if (copy < 0)
2066                         return copy;
2067
2068                 fprintf(f, "kdbus-fd=%i\n", copy);
2069         }
2070
2071         bus_serialize(m, f);
2072
2073         fputc('\n', f);
2074
2075         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2076                 if (u->id != t)
2077                         continue;
2078
2079                 if (!unit_can_serialize(u))
2080                         continue;
2081
2082                 /* Start marker */
2083                 fputs(u->id, f);
2084                 fputc('\n', f);
2085
2086                 r = unit_serialize(u, f, fds, !switching_root);
2087                 if (r < 0) {
2088                         m->n_reloading --;
2089                         return r;
2090                 }
2091         }
2092
2093         assert(m->n_reloading > 0);
2094         m->n_reloading --;
2095
2096         if (ferror(f))
2097                 return -EIO;
2098
2099         r = bus_fdset_add_all(m, fds);
2100         if (r < 0)
2101                 return r;
2102
2103         return 0;
2104 }
2105
2106 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2107         int r = 0;
2108
2109         assert(m);
2110         assert(f);
2111
2112         log_debug("Deserializing state...");
2113
2114         m->n_reloading ++;
2115
2116         for (;;) {
2117                 char line[LINE_MAX], *l;
2118
2119                 if (!fgets(line, sizeof(line), f)) {
2120                         if (feof(f))
2121                                 r = 0;
2122                         else
2123                                 r = -errno;
2124
2125                         goto finish;
2126                 }
2127
2128                 char_array_0(line);
2129                 l = strstrip(line);
2130
2131                 if (l[0] == 0)
2132                         break;
2133
2134                 if (startswith(l, "current-job-id=")) {
2135                         uint32_t id;
2136
2137                         if (safe_atou32(l+15, &id) < 0)
2138                                 log_debug("Failed to parse current job id value %s", l+15);
2139                         else
2140                                 m->current_job_id = MAX(m->current_job_id, id);
2141
2142                 } else if (startswith(l, "n-installed-jobs=")) {
2143                         uint32_t n;
2144
2145                         if (safe_atou32(l+17, &n) < 0)
2146                                 log_debug("Failed to parse installed jobs counter %s", l+17);
2147                         else
2148                                 m->n_installed_jobs += n;
2149
2150                 } else if (startswith(l, "n-failed-jobs=")) {
2151                         uint32_t n;
2152
2153                         if (safe_atou32(l+14, &n) < 0)
2154                                 log_debug("Failed to parse failed jobs counter %s", l+14);
2155                         else
2156                                 m->n_failed_jobs += n;
2157
2158                 } else if (startswith(l, "taint-usr=")) {
2159                         int b;
2160
2161                         b = parse_boolean(l+10);
2162                         if (b < 0)
2163                                 log_debug("Failed to parse taint /usr flag %s", l+10);
2164                         else
2165                                 m->taint_usr = m->taint_usr || b;
2166
2167                 } else if (startswith(l, "firmware-timestamp="))
2168                         dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2169                 else if (startswith(l, "loader-timestamp="))
2170                         dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2171                 else if (startswith(l, "kernel-timestamp="))
2172                         dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2173                 else if (startswith(l, "initrd-timestamp="))
2174                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2175                 else if (startswith(l, "userspace-timestamp="))
2176                         dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2177                 else if (startswith(l, "finish-timestamp="))
2178                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2179                 else if (startswith(l, "security-start-timestamp="))
2180                         dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2181                 else if (startswith(l, "security-finish-timestamp="))
2182                         dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2183                 else if (startswith(l, "generators-start-timestamp="))
2184                         dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2185                 else if (startswith(l, "generators-finish-timestamp="))
2186                         dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2187                 else if (startswith(l, "units-load-start-timestamp="))
2188                         dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2189                 else if (startswith(l, "units-load-finish-timestamp="))
2190                         dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2191                 else if (startswith(l, "env=")) {
2192                         _cleanup_free_ char *uce = NULL;
2193                         char **e;
2194
2195                         uce = cunescape(l+4);
2196                         if (!uce) {
2197                                 r = -ENOMEM;
2198                                 goto finish;
2199                         }
2200
2201                         e = strv_env_set(m->environment, uce);
2202                         if (!e) {
2203                                 r = -ENOMEM;
2204                                 goto finish;
2205                         }
2206
2207                         strv_free(m->environment);
2208                         m->environment = e;
2209
2210                 } else if (startswith(l, "notify-fd=")) {
2211                         int fd;
2212
2213                         if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2214                                 log_debug("Failed to parse notify fd: %s", l + 10);
2215                         else {
2216                                 if (m->notify_fd >= 0) {
2217                                         m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2218                                         close_nointr_nofail(m->notify_fd);
2219                                 }
2220
2221                                 m->notify_fd = fdset_remove(fds, fd);
2222                         }
2223
2224                 } else if (startswith(l, "notify-socket=")) {
2225                         char *n;
2226
2227                         n = strdup(l+14);
2228                         if (!n) {
2229                                 r = -ENOMEM;
2230                                 goto finish;
2231                         }
2232
2233                         free(m->notify_socket);
2234                         m->notify_socket = n;
2235
2236                 } else if (startswith(l, "kdbus-fd=")) {
2237                         int fd;
2238
2239                         if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2240                                 log_debug("Failed to parse kdbus fd: %s", l + 9);
2241                         else {
2242                                 if (m->kdbus_fd >= 0)
2243                                         close_nointr_nofail(m->kdbus_fd);
2244
2245                                 m->kdbus_fd = fdset_remove(fds, fd);
2246                         }
2247
2248                 } else if (bus_deserialize_item(m, l) == 0)
2249                         log_debug("Unknown serialization item '%s'", l);
2250         }
2251
2252         for (;;) {
2253                 Unit *u;
2254                 char name[UNIT_NAME_MAX+2];
2255
2256                 /* Start marker */
2257                 if (!fgets(name, sizeof(name), f)) {
2258                         if (feof(f))
2259                                 r = 0;
2260                         else
2261                                 r = -errno;
2262
2263                         goto finish;
2264                 }
2265
2266                 char_array_0(name);
2267
2268                 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2269                 if (r < 0)
2270                         goto finish;
2271
2272                 r = unit_deserialize(u, f, fds);
2273                 if (r < 0)
2274                         goto finish;
2275         }
2276
2277 finish:
2278         if (ferror(f))
2279                 r = -EIO;
2280
2281         assert(m->n_reloading > 0);
2282         m->n_reloading --;
2283
2284         return r;
2285 }
2286
2287 int manager_reload(Manager *m) {
2288         int r, q;
2289         _cleanup_fclose_ FILE *f = NULL;
2290         _cleanup_fdset_free_ FDSet *fds = NULL;
2291
2292         assert(m);
2293
2294         r = manager_open_serialization(m, &f);
2295         if (r < 0)
2296                 return r;
2297
2298         m->n_reloading ++;
2299         bus_manager_send_reloading(m, true);
2300
2301         fds = fdset_new();
2302         if (!fds) {
2303                 m->n_reloading --;
2304                 return -ENOMEM;
2305         }
2306
2307         r = manager_serialize(m, f, fds, false);
2308         if (r < 0) {
2309                 m->n_reloading --;
2310                 return r;
2311         }
2312
2313         if (fseeko(f, 0, SEEK_SET) < 0) {
2314                 m->n_reloading --;
2315                 return -errno;
2316         }
2317
2318         /* From here on there is no way back. */
2319         manager_clear_jobs_and_units(m);
2320         manager_undo_generators(m);
2321         lookup_paths_free(&m->lookup_paths);
2322
2323         /* Find new unit paths */
2324         manager_run_generators(m);
2325
2326         q = lookup_paths_init(
2327                         &m->lookup_paths, m->running_as, true,
2328                         m->generator_unit_path,
2329                         m->generator_unit_path_early,
2330                         m->generator_unit_path_late);
2331         if (q < 0)
2332                 r = q;
2333
2334         manager_build_unit_path_cache(m);
2335
2336         /* First, enumerate what we can from all config files */
2337         q = manager_enumerate(m);
2338         if (q < 0)
2339                 r = q;
2340
2341         /* Second, deserialize our stored data */
2342         q = manager_deserialize(m, f, fds);
2343         if (q < 0)
2344                 r = q;
2345
2346         fclose(f);
2347         f = NULL;
2348
2349         /* Re-register notify_fd as event source */
2350         q = manager_setup_notify(m);
2351         if (q < 0)
2352                 r = q;
2353
2354         /* Third, fire things up! */
2355         q = manager_coldplug(m);
2356         if (q < 0)
2357                 r = q;
2358
2359         assert(m->n_reloading > 0);
2360         m->n_reloading--;
2361
2362         m->send_reloading_done = true;
2363
2364         return r;
2365 }
2366
2367 static bool manager_is_booting_or_shutting_down(Manager *m) {
2368         Unit *u;
2369
2370         assert(m);
2371
2372         /* Is the initial job still around? */
2373         if (manager_get_job(m, m->default_unit_job_id))
2374                 return true;
2375
2376         /* Is there a job for the shutdown target? */
2377         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2378         if (u)
2379                 return !!u->job;
2380
2381         return false;
2382 }
2383
2384 bool manager_is_reloading_or_reexecuting(Manager *m) {
2385         assert(m);
2386
2387         return m->n_reloading != 0;
2388 }
2389
2390 void manager_reset_failed(Manager *m) {
2391         Unit *u;
2392         Iterator i;
2393
2394         assert(m);
2395
2396         HASHMAP_FOREACH(u, m->units, i)
2397                 unit_reset_failed(u);
2398 }
2399
2400 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2401         Unit *u;
2402
2403         assert(m);
2404         assert(name);
2405
2406         /* Returns true if the unit is inactive or going down */
2407         u = manager_get_unit(m, name);
2408         if (!u)
2409                 return true;
2410
2411         return unit_inactive_or_pending(u);
2412 }
2413
2414 void manager_check_finished(Manager *m) {
2415         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2416         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2417
2418         assert(m);
2419
2420         if (m->n_running_jobs == 0)
2421                 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2422
2423         if (hashmap_size(m->jobs) > 0) {
2424                 if (m->jobs_in_progress_event_source)
2425                         sd_event_source_set_time(m->jobs_in_progress_event_source, JOBS_IN_PROGRESS_PERIOD_SEC);
2426                 return;
2427         }
2428
2429         /* Notify Type=idle units that we are done now */
2430         m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2431         manager_close_idle_pipe(m);
2432
2433         /* Turn off confirm spawn now */
2434         m->confirm_spawn = false;
2435
2436         if (dual_timestamp_is_set(&m->finish_timestamp))
2437                 return;
2438
2439         dual_timestamp_get(&m->finish_timestamp);
2440
2441         if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2442
2443                 /* Note that m->kernel_usec.monotonic is always at 0,
2444                  * and m->firmware_usec.monotonic and
2445                  * m->loader_usec.monotonic should be considered
2446                  * negative values. */
2447
2448                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2449                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2450                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2451                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2452
2453                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2454
2455                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2456                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2457
2458                         if (!log_on_console())
2459                                 log_struct(LOG_INFO,
2460                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2461                                            "KERNEL_USEC="USEC_FMT, kernel_usec,
2462                                            "INITRD_USEC="USEC_FMT, initrd_usec,
2463                                            "USERSPACE_USEC="USEC_FMT, userspace_usec,
2464                                            "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2465                                            format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2466                                            format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2467                                            format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2468                                            format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2469                                            NULL);
2470                 } else {
2471                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2472                         initrd_usec = 0;
2473
2474                         if (!log_on_console())
2475                                 log_struct(LOG_INFO,
2476                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2477                                            "KERNEL_USEC="USEC_FMT, kernel_usec,
2478                                            "USERSPACE_USEC="USEC_FMT, userspace_usec,
2479                                            "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2480                                            format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2481                                            format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2482                                            format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2483                                            NULL);
2484                 }
2485         } else {
2486                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2487                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2488
2489                 if (!log_on_console())
2490                         log_struct(LOG_INFO,
2491                                    MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2492                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
2493                                    "MESSAGE=Startup finished in %s.",
2494                                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2495                                    NULL);
2496         }
2497
2498         bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2499
2500         sd_notifyf(false,
2501                    "READY=1\nSTATUS=Startup finished in %s.",
2502                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2503 }
2504
2505 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2506         char *p;
2507         int r;
2508
2509         assert(m);
2510         assert(generator);
2511         assert(name);
2512
2513         if (*generator)
2514                 return 0;
2515
2516         if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2517                 /* systemd --system, not running --test */
2518
2519                 p = strappend("/run/systemd/", name);
2520                 if (!p)
2521                         return log_oom();
2522
2523                 r = mkdir_p_label(p, 0755);
2524                 if (r < 0) {
2525                         log_error("Failed to create generator directory %s: %s",
2526                                   p, strerror(-r));
2527                         free(p);
2528                         return r;
2529                 }
2530         } else if (m->running_as == SYSTEMD_USER) {
2531                 const char *s = NULL;
2532
2533                 s = getenv("XDG_RUNTIME_DIR");
2534                 if (!s)
2535                         return -EINVAL;
2536                 p = strjoin(s, "/systemd/", name, NULL);
2537                 if (!p)
2538                         return log_oom();
2539
2540                 r = mkdir_p_label(p, 0755);
2541                 if (r < 0) {
2542                         log_error("Failed to create generator directory %s: %s",
2543                                   p, strerror(-r));
2544                         free(p);
2545                         return r;
2546                 }
2547         } else {
2548                 /* systemd --system --test */
2549
2550                 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2551                 if (!p)
2552                         return log_oom();
2553
2554                 if (!mkdtemp(p)) {
2555                         log_error("Failed to create generator directory %s: %m",
2556                                   p);
2557                         free(p);
2558                         return -errno;
2559                 }
2560         }
2561
2562         *generator = p;
2563         return 0;
2564 }
2565
2566 static void trim_generator_dir(Manager *m, char **generator) {
2567         assert(m);
2568         assert(generator);
2569
2570         if (!*generator)
2571                 return;
2572
2573         if (rmdir(*generator) >= 0) {
2574                 free(*generator);
2575                 *generator = NULL;
2576         }
2577
2578         return;
2579 }
2580
2581 void manager_run_generators(Manager *m) {
2582         _cleanup_closedir_ DIR *d = NULL;
2583         const char *generator_path;
2584         const char *argv[5];
2585         int r;
2586
2587         assert(m);
2588
2589         generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2590         d = opendir(generator_path);
2591         if (!d) {
2592                 if (errno == ENOENT)
2593                         return;
2594
2595                 log_error("Failed to enumerate generator directory %s: %m",
2596                           generator_path);
2597                 return;
2598         }
2599
2600         r = create_generator_dir(m, &m->generator_unit_path, "generator");
2601         if (r < 0)
2602                 goto finish;
2603
2604         r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2605         if (r < 0)
2606                 goto finish;
2607
2608         r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2609         if (r < 0)
2610                 goto finish;
2611
2612         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2613         argv[1] = m->generator_unit_path;
2614         argv[2] = m->generator_unit_path_early;
2615         argv[3] = m->generator_unit_path_late;
2616         argv[4] = NULL;
2617
2618         RUN_WITH_UMASK(0022)
2619                 execute_directory(generator_path, d, (char**) argv);
2620
2621 finish:
2622         trim_generator_dir(m, &m->generator_unit_path);
2623         trim_generator_dir(m, &m->generator_unit_path_early);
2624         trim_generator_dir(m, &m->generator_unit_path_late);
2625 }
2626
2627 static void remove_generator_dir(Manager *m, char **generator) {
2628         assert(m);
2629         assert(generator);
2630
2631         if (!*generator)
2632                 return;
2633
2634         strv_remove(m->lookup_paths.unit_path, *generator);
2635         rm_rf(*generator, false, true, false);
2636
2637         free(*generator);
2638         *generator = NULL;
2639 }
2640
2641 void manager_undo_generators(Manager *m) {
2642         assert(m);
2643
2644         remove_generator_dir(m, &m->generator_unit_path);
2645         remove_generator_dir(m, &m->generator_unit_path_early);
2646         remove_generator_dir(m, &m->generator_unit_path_late);
2647 }
2648
2649 int manager_environment_add(Manager *m, char **minus, char **plus) {
2650         char **a = NULL, **b = NULL, **l;
2651         assert(m);
2652
2653         l = m->environment;
2654
2655         if (!strv_isempty(minus)) {
2656                 a = strv_env_delete(l, 1, minus);
2657                 if (!a)
2658                         return -ENOMEM;
2659
2660                 l = a;
2661         }
2662
2663         if (!strv_isempty(plus)) {
2664                 b = strv_env_merge(2, l, plus);
2665                 if (!b)
2666                         return -ENOMEM;
2667
2668                 l = b;
2669         }
2670
2671         if (m->environment != l)
2672                 strv_free(m->environment);
2673         if (a != l)
2674                 strv_free(a);
2675         if (b != l)
2676                 strv_free(b);
2677
2678         m->environment = strv_sort(l);
2679         return 0;
2680 }
2681
2682 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2683         int i;
2684
2685         assert(m);
2686
2687         for (i = 0; i < RLIMIT_NLIMITS; i++) {
2688                 if (!default_rlimit[i])
2689                         continue;
2690
2691                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2692                 if (!m->rlimit[i])
2693                         return -ENOMEM;
2694         }
2695
2696         return 0;
2697 }
2698
2699 void manager_recheck_journal(Manager *m) {
2700         Unit *u;
2701
2702         assert(m);
2703
2704         if (m->running_as != SYSTEMD_SYSTEM)
2705                 return;
2706
2707         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2708         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2709                 log_close_journal();
2710                 return;
2711         }
2712
2713         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2714         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2715                 log_close_journal();
2716                 return;
2717         }
2718
2719         /* Hmm, OK, so the socket is fully up and the service is up
2720          * too, then let's make use of the thing. */
2721         log_open();
2722 }
2723
2724 void manager_set_show_status(Manager *m, bool b) {
2725         assert(m);
2726
2727         if (m->running_as != SYSTEMD_SYSTEM)
2728                 return;
2729
2730         m->show_status = b;
2731
2732         if (b)
2733                 touch("/run/systemd/show-status");
2734         else
2735                 unlink("/run/systemd/show-status");
2736 }
2737
2738 static bool manager_get_show_status(Manager *m) {
2739         assert(m);
2740
2741         if (m->running_as != SYSTEMD_SYSTEM)
2742                 return false;
2743
2744         if (m->no_console_output)
2745                 return false;
2746
2747         if (m->show_status)
2748                 return true;
2749
2750         /* If Plymouth is running make sure we show the status, so
2751          * that there's something nice to see when people press Esc */
2752
2753         return plymouth_running();
2754 }
2755
2756 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2757         va_list ap;
2758
2759         if (!manager_get_show_status(m))
2760                 return;
2761
2762         /* XXX We should totally drop the check for ephemeral here
2763          * and thus effectively make 'Type=idle' pointless. */
2764         if (ephemeral && m->n_on_console > 0)
2765                 return;
2766
2767         if (!manager_is_booting_or_shutting_down(m))
2768                 return;
2769
2770         va_start(ap, format);
2771         status_vprintf(status, true, ephemeral, format, ap);
2772         va_end(ap);
2773 }
2774
2775 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2776         _cleanup_free_ char *p = NULL;
2777         Unit *found;
2778
2779         assert(m);
2780         assert(path);
2781         assert(suffix);
2782         assert(_found);
2783
2784         p = unit_name_from_path(path, suffix);
2785         if (!p)
2786                 return -ENOMEM;
2787
2788         found = manager_get_unit(m, p);
2789         if (!found) {
2790                 *_found = NULL;
2791                 return 0;
2792         }
2793
2794         *_found = found;
2795         return 1;
2796 }
2797
2798 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2799         char p[strlen(path)+1];
2800
2801         assert(m);
2802         assert(path);
2803
2804         strcpy(p, path);
2805         path_kill_slashes(p);
2806
2807         return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2808 }