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