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