src/core/manager.c

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