src/core/manager.c

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