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