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