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