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