src/core/manager.c

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