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