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