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