src/core/manager.c

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