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