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