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