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 = PLYMOUTH_SOCKET;
1981
1982         int n = 0;
1983         _cleanup_free_ char *message = NULL;
1984         _cleanup_close_ int fd = -1;
1985
1986         /* Don't generate plymouth events if the service was already
1987          * started and we're just deserializing */
1988         if (m->n_reloading > 0)
1989                 return;
1990
1991         if (m->running_as != SYSTEMD_SYSTEM)
1992                 return;
1993
1994         if (detect_container(NULL) > 0)
1995                 return;
1996
1997         if (u->type != UNIT_SERVICE &&
1998             u->type != UNIT_MOUNT &&
1999             u->type != UNIT_SWAP)
2000                 return;
2001
2002         /* We set SOCK_NONBLOCK here so that we rather drop the
2003          * message then wait for plymouth */
2004         fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2005         if (fd < 0) {
2006                 log_error("socket() failed: %m");
2007                 return;
2008         }
2009
2010         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2011
2012                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2013                         log_error("connect() failed: %m");
2014                 return;
2015         }
2016
2017         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2018                 log_oom();
2019                 return;
2020         }
2021
2022         errno = 0;
2023         if (write(fd, message, n + 1) != n + 1)
2024                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2025                         log_error("Failed to write Plymouth message: %m");
2026 }
2027
2028 void manager_dispatch_bus_name_owner_changed(
2029                 Manager *m,
2030                 const char *name,
2031                 const char* old_owner,
2032                 const char *new_owner) {
2033
2034         Unit *u;
2035
2036         assert(m);
2037         assert(name);
2038
2039         u = hashmap_get(m->watch_bus, name);
2040         if (!u)
2041                 return;
2042
2043         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2044 }
2045
2046 int manager_open_serialization(Manager *m, FILE **_f) {
2047         const char *path;
2048         int fd = -1;
2049         FILE *f;
2050
2051         assert(_f);
2052
2053         path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2054         fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2055         if (fd < 0)
2056                 return -errno;
2057
2058         log_debug("Serializing state to %s", path);
2059
2060         f = fdopen(fd, "w+");
2061         if (!f) {
2062                 safe_close(fd);
2063                 return -errno;
2064         }
2065
2066         *_f = f;
2067
2068         return 0;
2069 }
2070
2071 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2072         Iterator i;
2073         Unit *u;
2074         const char *t;
2075         char **e;
2076         int r;
2077
2078         assert(m);
2079         assert(f);
2080         assert(fds);
2081
2082         m->n_reloading ++;
2083
2084         fprintf(f, "current-job-id=%i\n", m->current_job_id);
2085         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2086         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2087         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2088
2089         dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2090         dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2091         dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2092         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2093
2094         if (!in_initrd()) {
2095                 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2096                 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2097                 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2098                 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2099                 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2100                 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2101                 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2102                 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2103         }
2104
2105         if (!switching_root) {
2106                 STRV_FOREACH(e, m->environment) {
2107                         _cleanup_free_ char *ce;
2108
2109                         ce = cescape(*e);
2110                         if (!ce)
2111                                 return -ENOMEM;
2112
2113                         fprintf(f, "env=%s\n", *e);
2114                 }
2115         }
2116
2117         if (m->notify_fd >= 0) {
2118                 int copy;
2119
2120                 copy = fdset_put_dup(fds, m->notify_fd);
2121                 if (copy < 0)
2122                         return copy;
2123
2124                 fprintf(f, "notify-fd=%i\n", copy);
2125                 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2126         }
2127
2128         if (m->kdbus_fd >= 0) {
2129                 int copy;
2130
2131                 copy = fdset_put_dup(fds, m->kdbus_fd);
2132                 if (copy < 0)
2133                         return copy;
2134
2135                 fprintf(f, "kdbus-fd=%i\n", copy);
2136         }
2137
2138         bus_track_serialize(m->subscribed, f);
2139
2140         fputc('\n', f);
2141
2142         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2143                 if (u->id != t)
2144                         continue;
2145
2146                 /* Start marker */
2147                 fputs(u->id, f);
2148                 fputc('\n', f);
2149
2150                 r = unit_serialize(u, f, fds, !switching_root);
2151                 if (r < 0) {
2152                         m->n_reloading --;
2153                         return r;
2154                 }
2155         }
2156
2157         assert(m->n_reloading > 0);
2158         m->n_reloading --;
2159
2160         if (ferror(f))
2161                 return -EIO;
2162
2163         r = bus_fdset_add_all(m, fds);
2164         if (r < 0)
2165                 return r;
2166
2167         return 0;
2168 }
2169
2170 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2171         int r = 0;
2172
2173         assert(m);
2174         assert(f);
2175
2176         log_debug("Deserializing state...");
2177
2178         m->n_reloading ++;
2179
2180         for (;;) {
2181                 char line[LINE_MAX], *l;
2182
2183                 if (!fgets(line, sizeof(line), f)) {
2184                         if (feof(f))
2185                                 r = 0;
2186                         else
2187                                 r = -errno;
2188
2189                         goto finish;
2190                 }
2191
2192                 char_array_0(line);
2193                 l = strstrip(line);
2194
2195                 if (l[0] == 0)
2196                         break;
2197
2198                 if (startswith(l, "current-job-id=")) {
2199                         uint32_t id;
2200
2201                         if (safe_atou32(l+15, &id) < 0)
2202                                 log_debug("Failed to parse current job id value %s", l+15);
2203                         else
2204                                 m->current_job_id = MAX(m->current_job_id, id);
2205
2206                 } else if (startswith(l, "n-installed-jobs=")) {
2207                         uint32_t n;
2208
2209                         if (safe_atou32(l+17, &n) < 0)
2210                                 log_debug("Failed to parse installed jobs counter %s", l+17);
2211                         else
2212                                 m->n_installed_jobs += n;
2213
2214                 } else if (startswith(l, "n-failed-jobs=")) {
2215                         uint32_t n;
2216
2217                         if (safe_atou32(l+14, &n) < 0)
2218                                 log_debug("Failed to parse failed jobs counter %s", l+14);
2219                         else
2220                                 m->n_failed_jobs += n;
2221
2222                 } else if (startswith(l, "taint-usr=")) {
2223                         int b;
2224
2225                         b = parse_boolean(l+10);
2226                         if (b < 0)
2227                                 log_debug("Failed to parse taint /usr flag %s", l+10);
2228                         else
2229                                 m->taint_usr = m->taint_usr || b;
2230
2231                 } else if (startswith(l, "firmware-timestamp="))
2232                         dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2233                 else if (startswith(l, "loader-timestamp="))
2234                         dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2235                 else if (startswith(l, "kernel-timestamp="))
2236                         dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2237                 else if (startswith(l, "initrd-timestamp="))
2238                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2239                 else if (startswith(l, "userspace-timestamp="))
2240                         dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2241                 else if (startswith(l, "finish-timestamp="))
2242                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2243                 else if (startswith(l, "security-start-timestamp="))
2244                         dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2245                 else if (startswith(l, "security-finish-timestamp="))
2246                         dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2247                 else if (startswith(l, "generators-start-timestamp="))
2248                         dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2249                 else if (startswith(l, "generators-finish-timestamp="))
2250                         dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2251                 else if (startswith(l, "units-load-start-timestamp="))
2252                         dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2253                 else if (startswith(l, "units-load-finish-timestamp="))
2254                         dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2255                 else if (startswith(l, "env=")) {
2256                         _cleanup_free_ char *uce = NULL;
2257                         char **e;
2258
2259                         uce = cunescape(l+4);
2260                         if (!uce) {
2261                                 r = -ENOMEM;
2262                                 goto finish;
2263                         }
2264
2265                         e = strv_env_set(m->environment, uce);
2266                         if (!e) {
2267                                 r = -ENOMEM;
2268                                 goto finish;
2269                         }
2270
2271                         strv_free(m->environment);
2272                         m->environment = e;
2273
2274                 } else if (startswith(l, "notify-fd=")) {
2275                         int fd;
2276
2277                         if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2278                                 log_debug("Failed to parse notify fd: %s", l + 10);
2279                         else {
2280                                 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2281                                 safe_close(m->notify_fd);
2282                                 m->notify_fd = fdset_remove(fds, fd);
2283                         }
2284
2285                 } else if (startswith(l, "notify-socket=")) {
2286                         char *n;
2287
2288                         n = strdup(l+14);
2289                         if (!n) {
2290                                 r = -ENOMEM;
2291                                 goto finish;
2292                         }
2293
2294                         free(m->notify_socket);
2295                         m->notify_socket = n;
2296
2297                 } else if (startswith(l, "kdbus-fd=")) {
2298                         int fd;
2299
2300                         if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2301                                 log_debug("Failed to parse kdbus fd: %s", l + 9);
2302                         else {
2303                                 safe_close(m->kdbus_fd);
2304                                 m->kdbus_fd = fdset_remove(fds, fd);
2305                         }
2306
2307                 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2308                         log_debug("Unknown serialization item '%s'", l);
2309         }
2310
2311         for (;;) {
2312                 Unit *u;
2313                 char name[UNIT_NAME_MAX+2];
2314
2315                 /* Start marker */
2316                 if (!fgets(name, sizeof(name), f)) {
2317                         if (feof(f))
2318                                 r = 0;
2319                         else
2320                                 r = -errno;
2321
2322                         goto finish;
2323                 }
2324
2325                 char_array_0(name);
2326
2327                 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2328                 if (r < 0)
2329                         goto finish;
2330
2331                 r = unit_deserialize(u, f, fds);
2332                 if (r < 0)
2333                         goto finish;
2334         }
2335
2336 finish:
2337         if (ferror(f))
2338                 r = -EIO;
2339
2340         assert(m->n_reloading > 0);
2341         m->n_reloading --;
2342
2343         return r;
2344 }
2345
2346 int manager_reload(Manager *m) {
2347         int r, q;
2348         _cleanup_fclose_ FILE *f = NULL;
2349         _cleanup_fdset_free_ FDSet *fds = NULL;
2350
2351         assert(m);
2352
2353         r = manager_open_serialization(m, &f);
2354         if (r < 0)
2355                 return r;
2356
2357         m->n_reloading ++;
2358         bus_manager_send_reloading(m, true);
2359
2360         fds = fdset_new();
2361         if (!fds) {
2362                 m->n_reloading --;
2363                 return -ENOMEM;
2364         }
2365
2366         r = manager_serialize(m, f, fds, false);
2367         if (r < 0) {
2368                 m->n_reloading --;
2369                 return r;
2370         }
2371
2372         if (fseeko(f, 0, SEEK_SET) < 0) {
2373                 m->n_reloading --;
2374                 return -errno;
2375         }
2376
2377         /* From here on there is no way back. */
2378         manager_clear_jobs_and_units(m);
2379         manager_undo_generators(m);
2380         lookup_paths_free(&m->lookup_paths);
2381
2382         /* Find new unit paths */
2383         manager_run_generators(m);
2384
2385         q = lookup_paths_init(
2386                         &m->lookup_paths, m->running_as, true,
2387                         NULL,
2388                         m->generator_unit_path,
2389                         m->generator_unit_path_early,
2390                         m->generator_unit_path_late);
2391         if (q < 0)
2392                 r = q;
2393
2394         manager_build_unit_path_cache(m);
2395
2396         /* First, enumerate what we can from all config files */
2397         q = manager_enumerate(m);
2398         if (q < 0)
2399                 r = q;
2400
2401         /* Second, deserialize our stored data */
2402         q = manager_deserialize(m, f, fds);
2403         if (q < 0)
2404                 r = q;
2405
2406         fclose(f);
2407         f = NULL;
2408
2409         /* Re-register notify_fd as event source */
2410         q = manager_setup_notify(m);
2411         if (q < 0)
2412                 r = q;
2413
2414         /* Third, fire things up! */
2415         q = manager_coldplug(m);
2416         if (q < 0)
2417                 r = q;
2418
2419         assert(m->n_reloading > 0);
2420         m->n_reloading--;
2421
2422         m->send_reloading_done = true;
2423
2424         return r;
2425 }
2426
2427 bool manager_is_reloading_or_reexecuting(Manager *m) {
2428         assert(m);
2429
2430         return m->n_reloading != 0;
2431 }
2432
2433 void manager_reset_failed(Manager *m) {
2434         Unit *u;
2435         Iterator i;
2436
2437         assert(m);
2438
2439         HASHMAP_FOREACH(u, m->units, i)
2440                 unit_reset_failed(u);
2441 }
2442
2443 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2444         Unit *u;
2445
2446         assert(m);
2447         assert(name);
2448
2449         /* Returns true if the unit is inactive or going down */
2450         u = manager_get_unit(m, name);
2451         if (!u)
2452                 return true;
2453
2454         return unit_inactive_or_pending(u);
2455 }
2456
2457 void manager_check_finished(Manager *m) {
2458         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2459         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2460         Unit *u = NULL;
2461         Iterator i;
2462
2463         assert(m);
2464
2465         if (m->n_running_jobs == 0)
2466                 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2467
2468         if (hashmap_size(m->jobs) > 0) {
2469
2470                 if (m->jobs_in_progress_event_source) {
2471                         sd_event_source_set_time(m->jobs_in_progress_event_source,
2472                                                  now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2473                 }
2474
2475                 return;
2476         }
2477
2478         manager_flip_auto_status(m, false);
2479
2480         /* Notify Type=idle units that we are done now */
2481         m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2482         manager_close_idle_pipe(m);
2483
2484         /* Turn off confirm spawn now */
2485         m->confirm_spawn = false;
2486
2487         /* This is no longer the first boot */
2488         manager_set_first_boot(m, false);
2489
2490         if (dual_timestamp_is_set(&m->finish_timestamp))
2491                 return;
2492
2493         dual_timestamp_get(&m->finish_timestamp);
2494
2495         if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2496
2497                 /* Note that m->kernel_usec.monotonic is always at 0,
2498                  * and m->firmware_usec.monotonic and
2499                  * m->loader_usec.monotonic should be considered
2500                  * negative values. */
2501
2502                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2503                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2504                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2505                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2506
2507                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2508
2509                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2510                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2511
2512                         if (!log_on_console())
2513                                 log_struct(LOG_INFO,
2514                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2515                                            "KERNEL_USEC="USEC_FMT, kernel_usec,
2516                                            "INITRD_USEC="USEC_FMT, initrd_usec,
2517                                            "USERSPACE_USEC="USEC_FMT, userspace_usec,
2518                                            "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2519                                            format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2520                                            format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2521                                            format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2522                                            format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2523                                            NULL);
2524                 } else {
2525                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2526                         initrd_usec = 0;
2527
2528                         if (!log_on_console())
2529                                 log_struct(LOG_INFO,
2530                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2531                                            "KERNEL_USEC="USEC_FMT, kernel_usec,
2532                                            "USERSPACE_USEC="USEC_FMT, userspace_usec,
2533                                            "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2534                                            format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2535                                            format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2536                                            format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2537                                            NULL);
2538                 }
2539         } else {
2540                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2541                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2542
2543                 if (!log_on_console())
2544                         log_struct(LOG_INFO,
2545                                    MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2546                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
2547                                    "MESSAGE=Startup finished in %s.",
2548                                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2549                                    NULL);
2550         }
2551
2552         SET_FOREACH(u, m->startup_units, i)
2553                 if (u->cgroup_path)
2554                         cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2555
2556         bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2557
2558         sd_notifyf(false,
2559                    "READY=1\nSTATUS=Startup finished in %s.",
2560                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2561 }
2562
2563 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2564         char *p;
2565         int r;
2566
2567         assert(m);
2568         assert(generator);
2569         assert(name);
2570
2571         if (*generator)
2572                 return 0;
2573
2574         if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2575                 /* systemd --system, not running --test */
2576
2577                 p = strappend("/run/systemd/", name);
2578                 if (!p)
2579                         return log_oom();
2580
2581                 r = mkdir_p_label(p, 0755);
2582                 if (r < 0) {
2583                         log_error("Failed to create generator directory %s: %s",
2584                                   p, strerror(-r));
2585                         free(p);
2586                         return r;
2587                 }
2588         } else if (m->running_as == SYSTEMD_USER) {
2589                 const char *s = NULL;
2590
2591                 s = getenv("XDG_RUNTIME_DIR");
2592                 if (!s)
2593                         return -EINVAL;
2594                 p = strjoin(s, "/systemd/", name, NULL);
2595                 if (!p)
2596                         return log_oom();
2597
2598                 r = mkdir_p_label(p, 0755);
2599                 if (r < 0) {
2600                         log_error("Failed to create generator directory %s: %s",
2601                                   p, strerror(-r));
2602                         free(p);
2603                         return r;
2604                 }
2605         } else {
2606                 /* systemd --system --test */
2607
2608                 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2609                 if (!p)
2610                         return log_oom();
2611
2612                 if (!mkdtemp(p)) {
2613                         log_error("Failed to create generator directory %s: %m",
2614                                   p);
2615                         free(p);
2616                         return -errno;
2617                 }
2618         }
2619
2620         *generator = p;
2621         return 0;
2622 }
2623
2624 static void trim_generator_dir(Manager *m, char **generator) {
2625         assert(m);
2626         assert(generator);
2627
2628         if (!*generator)
2629                 return;
2630
2631         if (rmdir(*generator) >= 0) {
2632                 free(*generator);
2633                 *generator = NULL;
2634         }
2635
2636         return;
2637 }
2638
2639 void manager_run_generators(Manager *m) {
2640         _cleanup_closedir_ DIR *d = NULL;
2641         const char *generator_path;
2642         const char *argv[5];
2643         int r;
2644
2645         assert(m);
2646
2647         if (m->test_run)
2648                 return;
2649
2650         generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2651         d = opendir(generator_path);
2652         if (!d) {
2653                 if (errno == ENOENT)
2654                         return;
2655
2656                 log_error("Failed to enumerate generator directory %s: %m",
2657                           generator_path);
2658                 return;
2659         }
2660
2661         r = create_generator_dir(m, &m->generator_unit_path, "generator");
2662         if (r < 0)
2663                 goto finish;
2664
2665         r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2666         if (r < 0)
2667                 goto finish;
2668
2669         r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2670         if (r < 0)
2671                 goto finish;
2672
2673         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2674         argv[1] = m->generator_unit_path;
2675         argv[2] = m->generator_unit_path_early;
2676         argv[3] = m->generator_unit_path_late;
2677         argv[4] = NULL;
2678
2679         RUN_WITH_UMASK(0022)
2680                 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2681
2682 finish:
2683         trim_generator_dir(m, &m->generator_unit_path);
2684         trim_generator_dir(m, &m->generator_unit_path_early);
2685         trim_generator_dir(m, &m->generator_unit_path_late);
2686 }
2687
2688 static void remove_generator_dir(Manager *m, char **generator) {
2689         assert(m);
2690         assert(generator);
2691
2692         if (!*generator)
2693                 return;
2694
2695         strv_remove(m->lookup_paths.unit_path, *generator);
2696         rm_rf(*generator, false, true, false);
2697
2698         free(*generator);
2699         *generator = NULL;
2700 }
2701
2702 void manager_undo_generators(Manager *m) {
2703         assert(m);
2704
2705         remove_generator_dir(m, &m->generator_unit_path);
2706         remove_generator_dir(m, &m->generator_unit_path_early);
2707         remove_generator_dir(m, &m->generator_unit_path_late);
2708 }
2709
2710 int manager_environment_add(Manager *m, char **minus, char **plus) {
2711         char **a = NULL, **b = NULL, **l;
2712         assert(m);
2713
2714         l = m->environment;
2715
2716         if (!strv_isempty(minus)) {
2717                 a = strv_env_delete(l, 1, minus);
2718                 if (!a)
2719                         return -ENOMEM;
2720
2721                 l = a;
2722         }
2723
2724         if (!strv_isempty(plus)) {
2725                 b = strv_env_merge(2, l, plus);
2726                 if (!b)
2727                         return -ENOMEM;
2728
2729                 l = b;
2730         }
2731
2732         if (m->environment != l)
2733                 strv_free(m->environment);
2734         if (a != l)
2735                 strv_free(a);
2736         if (b != l)
2737                 strv_free(b);
2738
2739         m->environment = l;
2740         manager_clean_environment(m);
2741         strv_sort(m->environment);
2742
2743         return 0;
2744 }
2745
2746 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2747         int i;
2748
2749         assert(m);
2750
2751         for (i = 0; i < _RLIMIT_MAX; i++) {
2752                 if (!default_rlimit[i])
2753                         continue;
2754
2755                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2756                 if (!m->rlimit[i])
2757                         return -ENOMEM;
2758         }
2759
2760         return 0;
2761 }
2762
2763 void manager_recheck_journal(Manager *m) {
2764         Unit *u;
2765
2766         assert(m);
2767
2768         if (m->running_as != SYSTEMD_SYSTEM)
2769                 return;
2770
2771         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2772         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2773                 log_close_journal();
2774                 return;
2775         }
2776
2777         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2778         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2779                 log_close_journal();
2780                 return;
2781         }
2782
2783         /* Hmm, OK, so the socket is fully up and the service is up
2784          * too, then let's make use of the thing. */
2785         log_open();
2786 }
2787
2788 void manager_set_show_status(Manager *m, ShowStatus mode) {
2789         assert(m);
2790         assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2791
2792         if (m->running_as != SYSTEMD_SYSTEM)
2793                 return;
2794
2795         m->show_status = mode;
2796
2797         if (mode > 0)
2798                 touch("/run/systemd/show-status");
2799         else
2800                 unlink("/run/systemd/show-status");
2801 }
2802
2803 static bool manager_get_show_status(Manager *m) {
2804         assert(m);
2805
2806         if (m->running_as != SYSTEMD_SYSTEM)
2807                 return false;
2808
2809         if (m->no_console_output)
2810                 return false;
2811
2812         if (!IN_SET(manager_state(m), MANAGER_STARTING, MANAGER_STOPPING))
2813                 return false;
2814
2815         if (m->show_status > 0)
2816                 return true;
2817
2818         /* If Plymouth is running make sure we show the status, so
2819          * that there's something nice to see when people press Esc */
2820
2821         return plymouth_running();
2822 }
2823
2824 void manager_set_first_boot(Manager *m, bool b) {
2825         assert(m);
2826
2827         if (m->running_as != SYSTEMD_SYSTEM)
2828                 return;
2829
2830         m->first_boot = b;
2831
2832         if (m->first_boot)
2833                 touch("/run/systemd/first-boot");
2834         else
2835                 unlink("/run/systemd/first-boot");
2836 }
2837
2838 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2839         va_list ap;
2840
2841         if (!manager_get_show_status(m))
2842                 return;
2843
2844         /* XXX We should totally drop the check for ephemeral here
2845          * and thus effectively make 'Type=idle' pointless. */
2846         if (ephemeral && m->n_on_console > 0)
2847                 return;
2848
2849         va_start(ap, format);
2850         status_vprintf(status, true, ephemeral, format, ap);
2851         va_end(ap);
2852 }
2853
2854 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2855         _cleanup_free_ char *p = NULL;
2856         Unit *found;
2857
2858         assert(m);
2859         assert(path);
2860         assert(suffix);
2861         assert(_found);
2862
2863         p = unit_name_from_path(path, suffix);
2864         if (!p)
2865                 return -ENOMEM;
2866
2867         found = manager_get_unit(m, p);
2868         if (!found) {
2869                 *_found = NULL;
2870                 return 0;
2871         }
2872
2873         *_found = found;
2874         return 1;
2875 }
2876
2877 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2878         char p[strlen(path)+1];
2879
2880         assert(m);
2881         assert(path);
2882
2883         strcpy(p, path);
2884         path_kill_slashes(p);
2885
2886         return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2887 }
2888
2889 const char *manager_get_runtime_prefix(Manager *m) {
2890         assert(m);
2891
2892         return m->running_as == SYSTEMD_SYSTEM ?
2893                "/run" :
2894                getenv("XDG_RUNTIME_DIR");
2895 }
2896
2897 ManagerState manager_state(Manager *m) {
2898         Unit *u;
2899
2900         assert(m);
2901
2902         /* Did we ever finish booting? If not then we are still starting up */
2903         if (!dual_timestamp_is_set(&m->finish_timestamp))
2904                 return MANAGER_STARTING;
2905
2906         /* Is the special shutdown target queued? If so, we are in shutdown state */
2907         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2908         if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
2909                 return MANAGER_STOPPING;
2910
2911         /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
2912         u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
2913         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2914                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2915                 return MANAGER_MAINTENANCE;
2916
2917         u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
2918         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2919                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2920                 return MANAGER_MAINTENANCE;
2921
2922         /* Are there any failed units? If so, we are in degraded mode */
2923         if (set_size(m->failed_units) > 0)
2924                 return MANAGER_DEGRADED;
2925
2926         return MANAGER_RUNNING;
2927 }
2928
2929 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
2930         [MANAGER_STARTING] = "starting",
2931         [MANAGER_RUNNING] = "running",
2932         [MANAGER_DEGRADED] = "degraded",
2933         [MANAGER_MAINTENANCE] = "maintenance",
2934         [MANAGER_STOPPING] = "stopping",
2935 };
2936
2937 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);