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