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