src/core/manager.c

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