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                 q = manager_deserialize(m, serialization, fds);
1010                 if (q < 0)
1011                         r = q;
1012         }
1013
1014         /* Any fds left? Find some unit which wants them. This is
1015          * useful to allow container managers to pass some file
1016          * descriptors to us pre-initialized. This enables
1017          * socket-based activation of entire containers. */
1018         if (fdset_size(fds) > 0) {
1019                 q = manager_distribute_fds(m, fds);
1020                 if (q < 0)
1021                         r = q;
1022         }
1023
1024         /* We might have deserialized the notify fd, but if we didn't
1025          * then let's create the bus now */
1026         manager_setup_notify(m);
1027
1028         /* We might have deserialized the kdbus control fd, but if we
1029          * didn't, then let's create the bus now. */
1030         manager_setup_kdbus(m);
1031         manager_connect_bus(m, !!serialization);
1032         bus_track_coldplug(m, &m->subscribed, &m->deserialized_subscribed);
1033
1034         /* Third, fire things up! */
1035         q = manager_coldplug(m);
1036         if (q < 0)
1037                 r = q;
1038
1039         if (serialization) {
1040                 assert(m->n_reloading > 0);
1041                 m->n_reloading --;
1042
1043                 /* Let's wait for the UnitNew/JobNew messages being
1044                  * sent, before we notify that the reload is
1045                  * finished */
1046                 m->send_reloading_done = true;
1047         }
1048
1049         return r;
1050 }
1051
1052 int manager_add_job(Manager *m, JobType type, Unit *unit, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1053         int r;
1054         Transaction *tr;
1055
1056         assert(m);
1057         assert(type < _JOB_TYPE_MAX);
1058         assert(unit);
1059         assert(mode < _JOB_MODE_MAX);
1060
1061         if (mode == JOB_ISOLATE && type != JOB_START) {
1062                 sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Isolate is only valid for start.");
1063                 return -EINVAL;
1064         }
1065
1066         if (mode == JOB_ISOLATE && !unit->allow_isolate) {
1067                 sd_bus_error_setf(e, BUS_ERROR_NO_ISOLATION, "Operation refused, unit may not be isolated.");
1068                 return -EPERM;
1069         }
1070
1071         log_debug_unit(unit->id,
1072                        "Trying to enqueue job %s/%s/%s", unit->id,
1073                        job_type_to_string(type), job_mode_to_string(mode));
1074
1075         job_type_collapse(&type, unit);
1076
1077         tr = transaction_new(mode == JOB_REPLACE_IRREVERSIBLY);
1078         if (!tr)
1079                 return -ENOMEM;
1080
1081         r = transaction_add_job_and_dependencies(tr, type, unit, NULL, true, override, false,
1082                                                  mode == JOB_IGNORE_DEPENDENCIES || mode == JOB_IGNORE_REQUIREMENTS,
1083                                                  mode == JOB_IGNORE_DEPENDENCIES, e);
1084         if (r < 0)
1085                 goto tr_abort;
1086
1087         if (mode == JOB_ISOLATE) {
1088                 r = transaction_add_isolate_jobs(tr, m);
1089                 if (r < 0)
1090                         goto tr_abort;
1091         }
1092
1093         r = transaction_activate(tr, m, mode, e);
1094         if (r < 0)
1095                 goto tr_abort;
1096
1097         log_debug_unit(unit->id,
1098                        "Enqueued job %s/%s as %u", unit->id,
1099                        job_type_to_string(type), (unsigned) tr->anchor_job->id);
1100
1101         if (_ret)
1102                 *_ret = tr->anchor_job;
1103
1104         transaction_free(tr);
1105         return 0;
1106
1107 tr_abort:
1108         transaction_abort(tr);
1109         transaction_free(tr);
1110         return r;
1111 }
1112
1113 int manager_add_job_by_name(Manager *m, JobType type, const char *name, JobMode mode, bool override, sd_bus_error *e, Job **_ret) {
1114         Unit *unit;
1115         int r;
1116
1117         assert(m);
1118         assert(type < _JOB_TYPE_MAX);
1119         assert(name);
1120         assert(mode < _JOB_MODE_MAX);
1121
1122         r = manager_load_unit(m, name, NULL, NULL, &unit);
1123         if (r < 0)
1124                 return r;
1125
1126         return manager_add_job(m, type, unit, mode, override, e, _ret);
1127 }
1128
1129 Job *manager_get_job(Manager *m, uint32_t id) {
1130         assert(m);
1131
1132         return hashmap_get(m->jobs, UINT32_TO_PTR(id));
1133 }
1134
1135 Unit *manager_get_unit(Manager *m, const char *name) {
1136         assert(m);
1137         assert(name);
1138
1139         return hashmap_get(m->units, name);
1140 }
1141
1142 unsigned manager_dispatch_load_queue(Manager *m) {
1143         Unit *u;
1144         unsigned n = 0;
1145
1146         assert(m);
1147
1148         /* Make sure we are not run recursively */
1149         if (m->dispatching_load_queue)
1150                 return 0;
1151
1152         m->dispatching_load_queue = true;
1153
1154         /* Dispatches the load queue. Takes a unit from the queue and
1155          * tries to load its data until the queue is empty */
1156
1157         while ((u = m->load_queue)) {
1158                 assert(u->in_load_queue);
1159
1160                 unit_load(u);
1161                 n++;
1162         }
1163
1164         m->dispatching_load_queue = false;
1165         return n;
1166 }
1167
1168 int manager_load_unit_prepare(
1169                 Manager *m,
1170                 const char *name,
1171                 const char *path,
1172                 sd_bus_error *e,
1173                 Unit **_ret) {
1174
1175         Unit *ret;
1176         UnitType t;
1177         int r;
1178
1179         assert(m);
1180         assert(name || path);
1181
1182         /* This will prepare the unit for loading, but not actually
1183          * load anything from disk. */
1184
1185         if (path && !is_path(path))
1186                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
1187
1188         if (!name)
1189                 name = basename(path);
1190
1191         t = unit_name_to_type(name);
1192
1193         if (t == _UNIT_TYPE_INVALID || !unit_name_is_valid(name, TEMPLATE_INVALID))
1194                 return sd_bus_error_setf(e, SD_BUS_ERROR_INVALID_ARGS, "Unit name %s is not valid.", name);
1195
1196         ret = manager_get_unit(m, name);
1197         if (ret) {
1198                 *_ret = ret;
1199                 return 1;
1200         }
1201
1202         ret = unit_new(m, unit_vtable[t]->object_size);
1203         if (!ret)
1204                 return -ENOMEM;
1205
1206         if (path) {
1207                 ret->fragment_path = strdup(path);
1208                 if (!ret->fragment_path) {
1209                         unit_free(ret);
1210                         return -ENOMEM;
1211                 }
1212         }
1213
1214         r = unit_add_name(ret, name);
1215         if (r < 0) {
1216                 unit_free(ret);
1217                 return r;
1218         }
1219
1220         unit_add_to_load_queue(ret);
1221         unit_add_to_dbus_queue(ret);
1222         unit_add_to_gc_queue(ret);
1223
1224         if (_ret)
1225                 *_ret = ret;
1226
1227         return 0;
1228 }
1229
1230 int manager_load_unit(
1231                 Manager *m,
1232                 const char *name,
1233                 const char *path,
1234                 sd_bus_error *e,
1235                 Unit **_ret) {
1236
1237         int r;
1238
1239         assert(m);
1240
1241         /* This will load the service information files, but not actually
1242          * start any services or anything. */
1243
1244         r = manager_load_unit_prepare(m, name, path, e, _ret);
1245         if (r != 0)
1246                 return r;
1247
1248         manager_dispatch_load_queue(m);
1249
1250         if (_ret)
1251                 *_ret = unit_follow_merge(*_ret);
1252
1253         return 0;
1254 }
1255
1256 void manager_dump_jobs(Manager *s, FILE *f, const char *prefix) {
1257         Iterator i;
1258         Job *j;
1259
1260         assert(s);
1261         assert(f);
1262
1263         HASHMAP_FOREACH(j, s->jobs, i)
1264                 job_dump(j, f, prefix);
1265 }
1266
1267 void manager_dump_units(Manager *s, FILE *f, const char *prefix) {
1268         Iterator i;
1269         Unit *u;
1270         const char *t;
1271
1272         assert(s);
1273         assert(f);
1274
1275         HASHMAP_FOREACH_KEY(u, t, s->units, i)
1276                 if (u->id == t)
1277                         unit_dump(u, f, prefix);
1278 }
1279
1280 void manager_clear_jobs(Manager *m) {
1281         Job *j;
1282
1283         assert(m);
1284
1285         while ((j = hashmap_first(m->jobs)))
1286                 /* No need to recurse. We're cancelling all jobs. */
1287                 job_finish_and_invalidate(j, JOB_CANCELED, false);
1288 }
1289
1290 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata) {
1291         Manager *m = userdata;
1292         Job *j;
1293
1294         assert(source);
1295         assert(m);
1296
1297         while ((j = m->run_queue)) {
1298                 assert(j->installed);
1299                 assert(j->in_run_queue);
1300
1301                 job_run_and_invalidate(j);
1302         }
1303
1304         if (m->n_running_jobs > 0)
1305                 manager_watch_jobs_in_progress(m);
1306
1307         if (m->n_on_console > 0)
1308                 manager_watch_idle_pipe(m);
1309
1310         return 1;
1311 }
1312
1313 static unsigned manager_dispatch_dbus_queue(Manager *m) {
1314         Job *j;
1315         Unit *u;
1316         unsigned n = 0;
1317
1318         assert(m);
1319
1320         if (m->dispatching_dbus_queue)
1321                 return 0;
1322
1323         m->dispatching_dbus_queue = true;
1324
1325         while ((u = m->dbus_unit_queue)) {
1326                 assert(u->in_dbus_queue);
1327
1328                 bus_unit_send_change_signal(u);
1329                 n++;
1330         }
1331
1332         while ((j = m->dbus_job_queue)) {
1333                 assert(j->in_dbus_queue);
1334
1335                 bus_job_send_change_signal(j);
1336                 n++;
1337         }
1338
1339         m->dispatching_dbus_queue = false;
1340
1341         if (m->send_reloading_done) {
1342                 m->send_reloading_done = false;
1343
1344                 bus_manager_send_reloading(m, false);
1345         }
1346
1347         if (m->queued_message)
1348                 bus_send_queued_message(m);
1349
1350         return n;
1351 }
1352
1353 static void manager_invoke_notify_message(Manager *m, Unit *u, pid_t pid, char *buf, size_t n) {
1354         _cleanup_strv_free_ char **tags = NULL;
1355
1356         assert(m);
1357         assert(u);
1358         assert(buf);
1359         assert(n > 0);
1360
1361         tags = strv_split(buf, "\n\r");
1362         if (!tags) {
1363                 log_oom();
1364                 return;
1365         }
1366
1367         log_debug_unit(u->id, "Got notification message for unit %s", u->id);
1368
1369         if (UNIT_VTABLE(u)->notify_message)
1370                 UNIT_VTABLE(u)->notify_message(u, pid, tags);
1371 }
1372
1373 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1374         Manager *m = userdata;
1375         ssize_t n;
1376
1377         assert(m);
1378         assert(m->notify_fd == fd);
1379
1380         if (revents != EPOLLIN) {
1381                 log_warning("Got unexpected poll event for notify fd.");
1382                 return 0;
1383         }
1384
1385         for (;;) {
1386                 char buf[4096];
1387                 struct iovec iovec = {
1388                         .iov_base = buf,
1389                         .iov_len = sizeof(buf)-1,
1390                 };
1391                 bool found = false;
1392
1393                 union {
1394                         struct cmsghdr cmsghdr;
1395                         uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
1396                 } control = {};
1397
1398                 struct msghdr msghdr = {
1399                         .msg_iov = &iovec,
1400                         .msg_iovlen = 1,
1401                         .msg_control = &control,
1402                         .msg_controllen = sizeof(control),
1403                 };
1404                 struct ucred *ucred;
1405                 Unit *u;
1406
1407                 n = recvmsg(m->notify_fd, &msghdr, MSG_DONTWAIT);
1408                 if (n <= 0) {
1409                         if (n == 0)
1410                                 return -EIO;
1411
1412                         if (errno == EAGAIN || errno == EINTR)
1413                                 break;
1414
1415                         return -errno;
1416                 }
1417
1418                 if (msghdr.msg_controllen < CMSG_LEN(sizeof(struct ucred)) ||
1419                     control.cmsghdr.cmsg_level != SOL_SOCKET ||
1420                     control.cmsghdr.cmsg_type != SCM_CREDENTIALS ||
1421                     control.cmsghdr.cmsg_len != CMSG_LEN(sizeof(struct ucred))) {
1422                         log_warning("Received notify message without credentials. Ignoring.");
1423                         continue;
1424                 }
1425
1426                 ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
1427
1428                 assert((size_t) n < sizeof(buf));
1429                 buf[n] = 0;
1430
1431                 u = manager_get_unit_by_pid(m, ucred->pid);
1432                 if (u) {
1433                         manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1434                         found = true;
1435                 }
1436
1437                 u = hashmap_get(m->watch_pids1, LONG_TO_PTR(ucred->pid));
1438                 if (u) {
1439                         manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1440                         found = true;
1441                 }
1442
1443                 u = hashmap_get(m->watch_pids2, LONG_TO_PTR(ucred->pid));
1444                 if (u) {
1445                         manager_invoke_notify_message(m, u, ucred->pid, buf, n);
1446                         found = true;
1447                 }
1448
1449                 if (!found)
1450                         log_warning("Cannot find unit for notify message of PID "PID_FMT".", ucred->pid);
1451         }
1452
1453         return 0;
1454 }
1455
1456 static void invoke_sigchld_event(Manager *m, Unit *u, siginfo_t *si) {
1457         assert(m);
1458         assert(u);
1459         assert(si);
1460
1461         log_debug_unit(u->id, "Child "PID_FMT" belongs to %s", si->si_pid, u->id);
1462
1463         unit_unwatch_pid(u, si->si_pid);
1464         UNIT_VTABLE(u)->sigchld_event(u, si->si_pid, si->si_code, si->si_status);
1465 }
1466
1467 static int manager_dispatch_sigchld(Manager *m) {
1468         assert(m);
1469
1470         for (;;) {
1471                 siginfo_t si = {};
1472
1473                 /* First we call waitd() for a PID and do not reap the
1474                  * zombie. That way we can still access /proc/$PID for
1475                  * it while it is a zombie. */
1476                 if (waitid(P_ALL, 0, &si, WEXITED|WNOHANG|WNOWAIT) < 0) {
1477
1478                         if (errno == ECHILD)
1479                                 break;
1480
1481                         if (errno == EINTR)
1482                                 continue;
1483
1484                         return -errno;
1485                 }
1486
1487                 if (si.si_pid <= 0)
1488                         break;
1489
1490                 if (si.si_code == CLD_EXITED || si.si_code == CLD_KILLED || si.si_code == CLD_DUMPED) {
1491                         _cleanup_free_ char *name = NULL;
1492                         Unit *u;
1493
1494                         get_process_comm(si.si_pid, &name);
1495
1496                         log_debug("Child "PID_FMT" (%s) died (code=%s, status=%i/%s)",
1497                                   si.si_pid, strna(name),
1498                                   sigchld_code_to_string(si.si_code),
1499                                   si.si_status,
1500                                   strna(si.si_code == CLD_EXITED
1501                                         ? exit_status_to_string(si.si_status, EXIT_STATUS_FULL)
1502                                         : signal_to_string(si.si_status)));
1503
1504                         /* And now figure out the unit this belongs
1505                          * to, it might be multiple... */
1506                         u = manager_get_unit_by_pid(m, si.si_pid);
1507                         if (u)
1508                                 invoke_sigchld_event(m, u, &si);
1509                         u = hashmap_get(m->watch_pids1, LONG_TO_PTR(si.si_pid));
1510                         if (u)
1511                                 invoke_sigchld_event(m, u, &si);
1512                         u = hashmap_get(m->watch_pids2, LONG_TO_PTR(si.si_pid));
1513                         if (u)
1514                                 invoke_sigchld_event(m, u, &si);
1515                 }
1516
1517                 /* And now, we actually reap the zombie. */
1518                 if (waitid(P_PID, si.si_pid, &si, WEXITED) < 0) {
1519                         if (errno == EINTR)
1520                                 continue;
1521
1522                         return -errno;
1523                 }
1524         }
1525
1526         return 0;
1527 }
1528
1529 static int manager_start_target(Manager *m, const char *name, JobMode mode) {
1530         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1531         int r;
1532
1533         log_debug_unit(name, "Activating special unit %s", name);
1534
1535         r = manager_add_job_by_name(m, JOB_START, name, mode, true, &error, NULL);
1536         if (r < 0)
1537                 log_error_unit(name, "Failed to enqueue %s job: %s", name, bus_error_message(&error, r));
1538
1539         return r;
1540 }
1541
1542 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1543         Manager *m = userdata;
1544         ssize_t n;
1545         struct signalfd_siginfo sfsi;
1546         bool sigchld = false;
1547
1548         assert(m);
1549         assert(m->signal_fd == fd);
1550
1551         if (revents != EPOLLIN) {
1552                 log_warning("Got unexpected events from signal file descriptor.");
1553                 return 0;
1554         }
1555
1556         for (;;) {
1557                 n = read(m->signal_fd, &sfsi, sizeof(sfsi));
1558                 if (n != sizeof(sfsi)) {
1559
1560                         if (n >= 0)
1561                                 return -EIO;
1562
1563                         if (errno == EINTR || errno == EAGAIN)
1564                                 break;
1565
1566                         return -errno;
1567                 }
1568
1569                 log_received_signal(sfsi.ssi_signo == SIGCHLD ||
1570                                     (sfsi.ssi_signo == SIGTERM && m->running_as == SYSTEMD_USER)
1571                                     ? LOG_DEBUG : LOG_INFO,
1572                                     &sfsi);
1573
1574                 switch (sfsi.ssi_signo) {
1575
1576                 case SIGCHLD:
1577                         sigchld = true;
1578                         break;
1579
1580                 case SIGTERM:
1581                         if (m->running_as == SYSTEMD_SYSTEM) {
1582                                 /* This is for compatibility with the
1583                                  * original sysvinit */
1584                                 m->exit_code = MANAGER_REEXECUTE;
1585                                 break;
1586                         }
1587
1588                         /* Fall through */
1589
1590                 case SIGINT:
1591                         if (m->running_as == SYSTEMD_SYSTEM) {
1592                                 manager_start_target(m, SPECIAL_CTRL_ALT_DEL_TARGET, JOB_REPLACE_IRREVERSIBLY);
1593                                 break;
1594                         }
1595
1596                         /* Run the exit target if there is one, if not, just exit. */
1597                         if (manager_start_target(m, SPECIAL_EXIT_TARGET, JOB_REPLACE) < 0) {
1598                                 m->exit_code = MANAGER_EXIT;
1599                                 return 0;
1600                         }
1601
1602                         break;
1603
1604                 case SIGWINCH:
1605                         if (m->running_as == SYSTEMD_SYSTEM)
1606                                 manager_start_target(m, SPECIAL_KBREQUEST_TARGET, JOB_REPLACE);
1607
1608                         /* This is a nop on non-init */
1609                         break;
1610
1611                 case SIGPWR:
1612                         if (m->running_as == SYSTEMD_SYSTEM)
1613                                 manager_start_target(m, SPECIAL_SIGPWR_TARGET, JOB_REPLACE);
1614
1615                         /* This is a nop on non-init */
1616                         break;
1617
1618                 case SIGUSR1: {
1619                         Unit *u;
1620
1621                         u = manager_get_unit(m, SPECIAL_DBUS_SERVICE);
1622
1623                         if (!u || UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u))) {
1624                                 log_info("Trying to reconnect to bus...");
1625                                 bus_init(m, true);
1626                         }
1627
1628                         if (!u || !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))) {
1629                                 log_info("Loading D-Bus service...");
1630                                 manager_start_target(m, SPECIAL_DBUS_SERVICE, JOB_REPLACE);
1631                         }
1632
1633                         break;
1634                 }
1635
1636                 case SIGUSR2: {
1637                         _cleanup_free_ char *dump = NULL;
1638                         _cleanup_fclose_ FILE *f = NULL;
1639                         size_t size;
1640
1641                         f = open_memstream(&dump, &size);
1642                         if (!f) {
1643                                 log_warning("Failed to allocate memory stream.");
1644                                 break;
1645                         }
1646
1647                         manager_dump_units(m, f, "\t");
1648                         manager_dump_jobs(m, f, "\t");
1649
1650                         if (ferror(f)) {
1651                                 log_warning("Failed to write status stream");
1652                                 break;
1653                         }
1654
1655                         if (fflush(f)) {
1656                                 log_warning("Failed to flush status stream");
1657                                 break;
1658                         }
1659
1660                         log_dump(LOG_INFO, dump);
1661                         break;
1662                 }
1663
1664                 case SIGHUP:
1665                         m->exit_code = MANAGER_RELOAD;
1666                         break;
1667
1668                 default: {
1669
1670                         /* Starting SIGRTMIN+0 */
1671                         static const char * const target_table[] = {
1672                                 [0] = SPECIAL_DEFAULT_TARGET,
1673                                 [1] = SPECIAL_RESCUE_TARGET,
1674                                 [2] = SPECIAL_EMERGENCY_TARGET,
1675                                 [3] = SPECIAL_HALT_TARGET,
1676                                 [4] = SPECIAL_POWEROFF_TARGET,
1677                                 [5] = SPECIAL_REBOOT_TARGET,
1678                                 [6] = SPECIAL_KEXEC_TARGET
1679                         };
1680
1681                         /* Starting SIGRTMIN+13, so that target halt and system halt are 10 apart */
1682                         static const ManagerExitCode code_table[] = {
1683                                 [0] = MANAGER_HALT,
1684                                 [1] = MANAGER_POWEROFF,
1685                                 [2] = MANAGER_REBOOT,
1686                                 [3] = MANAGER_KEXEC
1687                         };
1688
1689                         if ((int) sfsi.ssi_signo >= SIGRTMIN+0 &&
1690                             (int) sfsi.ssi_signo < SIGRTMIN+(int) ELEMENTSOF(target_table)) {
1691                                 int idx = (int) sfsi.ssi_signo - SIGRTMIN;
1692                                 manager_start_target(m, target_table[idx],
1693                                                      (idx == 1 || idx == 2) ? JOB_ISOLATE : JOB_REPLACE);
1694                                 break;
1695                         }
1696
1697                         if ((int) sfsi.ssi_signo >= SIGRTMIN+13 &&
1698                             (int) sfsi.ssi_signo < SIGRTMIN+13+(int) ELEMENTSOF(code_table)) {
1699                                 m->exit_code = code_table[sfsi.ssi_signo - SIGRTMIN - 13];
1700                                 break;
1701                         }
1702
1703                         switch (sfsi.ssi_signo - SIGRTMIN) {
1704
1705                         case 20:
1706                                 log_debug("Enabling showing of status.");
1707                                 manager_set_show_status(m, SHOW_STATUS_YES);
1708                                 break;
1709
1710                         case 21:
1711                                 log_debug("Disabling showing of status.");
1712                                 manager_set_show_status(m, SHOW_STATUS_NO);
1713                                 break;
1714
1715                         case 22:
1716                                 log_set_max_level(LOG_DEBUG);
1717                                 log_notice("Setting log level to debug.");
1718                                 break;
1719
1720                         case 23:
1721                                 log_set_max_level(LOG_INFO);
1722                                 log_notice("Setting log level to info.");
1723                                 break;
1724
1725                         case 24:
1726                                 if (m->running_as == SYSTEMD_USER) {
1727                                         m->exit_code = MANAGER_EXIT;
1728                                         return 0;
1729                                 }
1730
1731                                 /* This is a nop on init */
1732                                 break;
1733
1734                         case 26:
1735                                 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1736                                 log_notice("Setting log target to journal-or-kmsg.");
1737                                 break;
1738
1739                         case 27:
1740                                 log_set_target(LOG_TARGET_CONSOLE);
1741                                 log_notice("Setting log target to console.");
1742                                 break;
1743
1744                         case 28:
1745                                 log_set_target(LOG_TARGET_KMSG);
1746                                 log_notice("Setting log target to kmsg.");
1747                                 break;
1748
1749                         case 29:
1750                                 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
1751                                 log_notice("Setting log target to syslog-or-kmsg.");
1752                                 break;
1753
1754                         default:
1755                                 log_warning("Got unhandled signal <%s>.", signal_to_string(sfsi.ssi_signo));
1756                         }
1757                 }
1758                 }
1759         }
1760
1761         if (sigchld)
1762                 manager_dispatch_sigchld(m);
1763
1764         return 0;
1765 }
1766
1767 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1768         Manager *m = userdata;
1769         Iterator i;
1770         Unit *u;
1771
1772         assert(m);
1773         assert(m->time_change_fd == fd);
1774
1775         log_struct(LOG_INFO,
1776                    MESSAGE_ID(SD_MESSAGE_TIME_CHANGE),
1777                    "MESSAGE=Time has been changed",
1778                    NULL);
1779
1780         /* Restart the watch */
1781         m->time_change_event_source = sd_event_source_unref(m->time_change_event_source);
1782         m->time_change_fd = safe_close(m->time_change_fd);
1783
1784         manager_setup_time_change(m);
1785
1786         HASHMAP_FOREACH(u, m->units, i)
1787                 if (UNIT_VTABLE(u)->time_change)
1788                         UNIT_VTABLE(u)->time_change(u);
1789
1790         return 0;
1791 }
1792
1793 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1794         Manager *m = userdata;
1795
1796         assert(m);
1797         assert(m->idle_pipe[2] == fd);
1798
1799         m->no_console_output = m->n_on_console > 0;
1800
1801         m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
1802         manager_close_idle_pipe(m);
1803
1804         return 0;
1805 }
1806
1807 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata) {
1808         Manager *m = userdata;
1809         int r;
1810         uint64_t next;
1811
1812         assert(m);
1813         assert(source);
1814
1815         manager_print_jobs_in_progress(m);
1816
1817         next = now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_PERIOD_USEC;
1818         r = sd_event_source_set_time(source, next);
1819         if (r < 0)
1820                 return r;
1821
1822         return sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
1823 }
1824
1825 int manager_loop(Manager *m) {
1826         int r;
1827
1828         RATELIMIT_DEFINE(rl, 1*USEC_PER_SEC, 50000);
1829
1830         assert(m);
1831         m->exit_code = MANAGER_OK;
1832
1833         /* Release the path cache */
1834         set_free_free(m->unit_path_cache);
1835         m->unit_path_cache = NULL;
1836
1837         manager_check_finished(m);
1838
1839         /* There might still be some zombies hanging around from
1840          * before we were exec()'ed. Let's reap them. */
1841         r = manager_dispatch_sigchld(m);
1842         if (r < 0)
1843                 return r;
1844
1845         while (m->exit_code == MANAGER_OK) {
1846                 usec_t wait_usec;
1847
1848                 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM)
1849                         watchdog_ping();
1850
1851                 if (!ratelimit_test(&rl)) {
1852                         /* Yay, something is going seriously wrong, pause a little */
1853                         log_warning("Looping too fast. Throttling execution a little.");
1854                         sleep(1);
1855                         continue;
1856                 }
1857
1858                 if (manager_dispatch_load_queue(m) > 0)
1859                         continue;
1860
1861                 if (manager_dispatch_gc_queue(m) > 0)
1862                         continue;
1863
1864                 if (manager_dispatch_cleanup_queue(m) > 0)
1865                         continue;
1866
1867                 if (manager_dispatch_cgroup_queue(m) > 0)
1868                         continue;
1869
1870                 if (manager_dispatch_dbus_queue(m) > 0)
1871                         continue;
1872
1873                 /* Sleep for half the watchdog time */
1874                 if (m->runtime_watchdog > 0 && m->running_as == SYSTEMD_SYSTEM) {
1875                         wait_usec = m->runtime_watchdog / 2;
1876                         if (wait_usec <= 0)
1877                                 wait_usec = 1;
1878                 } else
1879                         wait_usec = (usec_t) -1;
1880
1881                 r = sd_event_run(m->event, wait_usec);
1882                 if (r < 0) {
1883                         log_error("Failed to run event loop: %s", strerror(-r));
1884                         return r;
1885                 }
1886         }
1887
1888         return m->exit_code;
1889 }
1890
1891 int manager_load_unit_from_dbus_path(Manager *m, const char *s, sd_bus_error *e, Unit **_u) {
1892         _cleanup_free_ char *n = NULL;
1893         Unit *u;
1894         int r;
1895
1896         assert(m);
1897         assert(s);
1898         assert(_u);
1899
1900         r = unit_name_from_dbus_path(s, &n);
1901         if (r < 0)
1902                 return r;
1903
1904         r = manager_load_unit(m, n, NULL, e, &u);
1905         if (r < 0)
1906                 return r;
1907
1908         *_u = u;
1909
1910         return 0;
1911 }
1912
1913 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j) {
1914         const char *p;
1915         unsigned id;
1916         Job *j;
1917         int r;
1918
1919         assert(m);
1920         assert(s);
1921         assert(_j);
1922
1923         p = startswith(s, "/org/freedesktop/systemd1/job/");
1924         if (!p)
1925                 return -EINVAL;
1926
1927         r = safe_atou(p, &id);
1928         if (r < 0)
1929                 return r;
1930
1931         j = manager_get_job(m, id);
1932         if (!j)
1933                 return -ENOENT;
1934
1935         *_j = j;
1936
1937         return 0;
1938 }
1939
1940 void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success) {
1941
1942 #ifdef HAVE_AUDIT
1943         _cleanup_free_ char *p = NULL;
1944         int audit_fd;
1945
1946         audit_fd = get_audit_fd();
1947         if (audit_fd < 0)
1948                 return;
1949
1950         /* Don't generate audit events if the service was already
1951          * started and we're just deserializing */
1952         if (m->n_reloading > 0)
1953                 return;
1954
1955         if (m->running_as != SYSTEMD_SYSTEM)
1956                 return;
1957
1958         if (u->type != UNIT_SERVICE)
1959                 return;
1960
1961         p = unit_name_to_prefix_and_instance(u->id);
1962         if (!p) {
1963                 log_error_unit(u->id,
1964                                "Failed to allocate unit name for audit message: %s", strerror(ENOMEM));
1965                 return;
1966         }
1967
1968         if (audit_log_user_comm_message(audit_fd, type, "", p, NULL, NULL, NULL, success) < 0) {
1969                 if (errno == EPERM) {
1970                         /* We aren't allowed to send audit messages?
1971                          * Then let's not retry again. */
1972                         close_audit_fd();
1973                 } else
1974                         log_warning("Failed to send audit message: %m");
1975         }
1976 #endif
1977
1978 }
1979
1980 void manager_send_unit_plymouth(Manager *m, Unit *u) {
1981         union sockaddr_union sa = {
1982                 .un.sun_family = AF_UNIX,
1983                 .un.sun_path = "\0/org/freedesktop/plymouthd",
1984         };
1985
1986         int n = 0;
1987         _cleanup_free_ char *message = NULL;
1988         _cleanup_close_ int fd = -1;
1989
1990         /* Don't generate plymouth events if the service was already
1991          * started and we're just deserializing */
1992         if (m->n_reloading > 0)
1993                 return;
1994
1995         if (m->running_as != SYSTEMD_SYSTEM)
1996                 return;
1997
1998         if (detect_container(NULL) > 0)
1999                 return;
2000
2001         if (u->type != UNIT_SERVICE &&
2002             u->type != UNIT_MOUNT &&
2003             u->type != UNIT_SWAP)
2004                 return;
2005
2006         /* We set SOCK_NONBLOCK here so that we rather drop the
2007          * message then wait for plymouth */
2008         fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2009         if (fd < 0) {
2010                 log_error("socket() failed: %m");
2011                 return;
2012         }
2013
2014         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2015
2016                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2017                         log_error("connect() failed: %m");
2018                 return;
2019         }
2020
2021         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2022                 log_oom();
2023                 return;
2024         }
2025
2026         errno = 0;
2027         if (write(fd, message, n + 1) != n + 1)
2028                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2029                         log_error("Failed to write Plymouth message: %m");
2030 }
2031
2032 void manager_dispatch_bus_name_owner_changed(
2033                 Manager *m,
2034                 const char *name,
2035                 const char* old_owner,
2036                 const char *new_owner) {
2037
2038         Unit *u;
2039
2040         assert(m);
2041         assert(name);
2042
2043         u = hashmap_get(m->watch_bus, name);
2044         if (!u)
2045                 return;
2046
2047         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2048 }
2049
2050 int manager_open_serialization(Manager *m, FILE **_f) {
2051         const char *path;
2052         int fd = -1;
2053         FILE *f;
2054
2055         assert(_f);
2056
2057         path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2058         fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2059         if (fd < 0)
2060                 return -errno;
2061
2062         log_debug("Serializing state to %s", path);
2063
2064         f = fdopen(fd, "w+");
2065         if (!f) {
2066                 safe_close(fd);
2067                 return -errno;
2068         }
2069
2070         *_f = f;
2071
2072         return 0;
2073 }
2074
2075 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2076         Iterator i;
2077         Unit *u;
2078         const char *t;
2079         char **e;
2080         int r;
2081
2082         assert(m);
2083         assert(f);
2084         assert(fds);
2085
2086         m->n_reloading ++;
2087
2088         fprintf(f, "current-job-id=%i\n", m->current_job_id);
2089         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2090         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2091         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2092
2093         dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2094         dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2095         dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2096         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2097
2098         if (!in_initrd()) {
2099                 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2100                 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2101                 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2102                 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2103                 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2104                 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2105                 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2106                 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2107         }
2108
2109         if (!switching_root) {
2110                 STRV_FOREACH(e, m->environment) {
2111                         _cleanup_free_ char *ce;
2112
2113                         ce = cescape(*e);
2114                         if (!ce)
2115                                 return -ENOMEM;
2116
2117                         fprintf(f, "env=%s\n", *e);
2118                 }
2119         }
2120
2121         if (m->notify_fd >= 0) {
2122                 int copy;
2123
2124                 copy = fdset_put_dup(fds, m->notify_fd);
2125                 if (copy < 0)
2126                         return copy;
2127
2128                 fprintf(f, "notify-fd=%i\n", copy);
2129                 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2130         }
2131
2132         if (m->kdbus_fd >= 0) {
2133                 int copy;
2134
2135                 copy = fdset_put_dup(fds, m->kdbus_fd);
2136                 if (copy < 0)
2137                         return copy;
2138
2139                 fprintf(f, "kdbus-fd=%i\n", copy);
2140         }
2141
2142         bus_track_serialize(m->subscribed, f);
2143
2144         fputc('\n', f);
2145
2146         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2147                 if (u->id != t)
2148                         continue;
2149
2150                 /* Start marker */
2151                 fputs(u->id, f);
2152                 fputc('\n', f);
2153
2154                 r = unit_serialize(u, f, fds, !switching_root);
2155                 if (r < 0) {
2156                         m->n_reloading --;
2157                         return r;
2158                 }
2159         }
2160
2161         assert(m->n_reloading > 0);
2162         m->n_reloading --;
2163
2164         if (ferror(f))
2165                 return -EIO;
2166
2167         r = bus_fdset_add_all(m, fds);
2168         if (r < 0)
2169                 return r;
2170
2171         return 0;
2172 }
2173
2174 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2175         int r = 0;
2176
2177         assert(m);
2178         assert(f);
2179
2180         log_debug("Deserializing state...");
2181
2182         m->n_reloading ++;
2183
2184         for (;;) {
2185                 char line[LINE_MAX], *l;
2186
2187                 if (!fgets(line, sizeof(line), f)) {
2188                         if (feof(f))
2189                                 r = 0;
2190                         else
2191                                 r = -errno;
2192
2193                         goto finish;
2194                 }
2195
2196                 char_array_0(line);
2197                 l = strstrip(line);
2198
2199                 if (l[0] == 0)
2200                         break;
2201
2202                 if (startswith(l, "current-job-id=")) {
2203                         uint32_t id;
2204
2205                         if (safe_atou32(l+15, &id) < 0)
2206                                 log_debug("Failed to parse current job id value %s", l+15);
2207                         else
2208                                 m->current_job_id = MAX(m->current_job_id, id);
2209
2210                 } else if (startswith(l, "n-installed-jobs=")) {
2211                         uint32_t n;
2212
2213                         if (safe_atou32(l+17, &n) < 0)
2214                                 log_debug("Failed to parse installed jobs counter %s", l+17);
2215                         else
2216                                 m->n_installed_jobs += n;
2217
2218                 } else if (startswith(l, "n-failed-jobs=")) {
2219                         uint32_t n;
2220
2221                         if (safe_atou32(l+14, &n) < 0)
2222                                 log_debug("Failed to parse failed jobs counter %s", l+14);
2223                         else
2224                                 m->n_failed_jobs += n;
2225
2226                 } else if (startswith(l, "taint-usr=")) {
2227                         int b;
2228
2229                         b = parse_boolean(l+10);
2230                         if (b < 0)
2231                                 log_debug("Failed to parse taint /usr flag %s", l+10);
2232                         else
2233                                 m->taint_usr = m->taint_usr || b;
2234
2235                 } else if (startswith(l, "firmware-timestamp="))
2236                         dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2237                 else if (startswith(l, "loader-timestamp="))
2238                         dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2239                 else if (startswith(l, "kernel-timestamp="))
2240                         dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2241                 else if (startswith(l, "initrd-timestamp="))
2242                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2243                 else if (startswith(l, "userspace-timestamp="))
2244                         dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2245                 else if (startswith(l, "finish-timestamp="))
2246                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2247                 else if (startswith(l, "security-start-timestamp="))
2248                         dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2249                 else if (startswith(l, "security-finish-timestamp="))
2250                         dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2251                 else if (startswith(l, "generators-start-timestamp="))
2252                         dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2253                 else if (startswith(l, "generators-finish-timestamp="))
2254                         dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2255                 else if (startswith(l, "units-load-start-timestamp="))
2256                         dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2257                 else if (startswith(l, "units-load-finish-timestamp="))
2258                         dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2259                 else if (startswith(l, "env=")) {
2260                         _cleanup_free_ char *uce = NULL;
2261                         char **e;
2262
2263                         uce = cunescape(l+4);
2264                         if (!uce) {
2265                                 r = -ENOMEM;
2266                                 goto finish;
2267                         }
2268
2269                         e = strv_env_set(m->environment, uce);
2270                         if (!e) {
2271                                 r = -ENOMEM;
2272                                 goto finish;
2273                         }
2274
2275                         strv_free(m->environment);
2276                         m->environment = e;
2277
2278                 } else if (startswith(l, "notify-fd=")) {
2279                         int fd;
2280
2281                         if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2282                                 log_debug("Failed to parse notify fd: %s", l + 10);
2283                         else {
2284                                 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2285                                 safe_close(m->notify_fd);
2286                                 m->notify_fd = fdset_remove(fds, fd);
2287                         }
2288
2289                 } else if (startswith(l, "notify-socket=")) {
2290                         char *n;
2291
2292                         n = strdup(l+14);
2293                         if (!n) {
2294                                 r = -ENOMEM;
2295                                 goto finish;
2296                         }
2297
2298                         free(m->notify_socket);
2299                         m->notify_socket = n;
2300
2301                 } else if (startswith(l, "kdbus-fd=")) {
2302                         int fd;
2303
2304                         if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2305                                 log_debug("Failed to parse kdbus fd: %s", l + 9);
2306                         else {
2307                                 safe_close(m->kdbus_fd);
2308                                 m->kdbus_fd = fdset_remove(fds, fd);
2309                         }
2310
2311                 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2312                         log_debug("Unknown serialization item '%s'", l);
2313         }
2314
2315         for (;;) {
2316                 Unit *u;
2317                 char name[UNIT_NAME_MAX+2];
2318
2319                 /* Start marker */
2320                 if (!fgets(name, sizeof(name), f)) {
2321                         if (feof(f))
2322                                 r = 0;
2323                         else
2324                                 r = -errno;
2325
2326                         goto finish;
2327                 }
2328
2329                 char_array_0(name);
2330
2331                 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2332                 if (r < 0)
2333                         goto finish;
2334
2335                 r = unit_deserialize(u, f, fds);
2336                 if (r < 0)
2337                         goto finish;
2338         }
2339
2340 finish:
2341         if (ferror(f))
2342                 r = -EIO;
2343
2344         assert(m->n_reloading > 0);
2345         m->n_reloading --;
2346
2347         return r;
2348 }
2349
2350 int manager_reload(Manager *m) {
2351         int r, q;
2352         _cleanup_fclose_ FILE *f = NULL;
2353         _cleanup_fdset_free_ FDSet *fds = NULL;
2354
2355         assert(m);
2356
2357         r = manager_open_serialization(m, &f);
2358         if (r < 0)
2359                 return r;
2360
2361         m->n_reloading ++;
2362         bus_manager_send_reloading(m, true);
2363
2364         fds = fdset_new();
2365         if (!fds) {
2366                 m->n_reloading --;
2367                 return -ENOMEM;
2368         }
2369
2370         r = manager_serialize(m, f, fds, false);
2371         if (r < 0) {
2372                 m->n_reloading --;
2373                 return r;
2374         }
2375
2376         if (fseeko(f, 0, SEEK_SET) < 0) {
2377                 m->n_reloading --;
2378                 return -errno;
2379         }
2380
2381         /* From here on there is no way back. */
2382         manager_clear_jobs_and_units(m);
2383         manager_undo_generators(m);
2384         lookup_paths_free(&m->lookup_paths);
2385
2386         /* Find new unit paths */
2387         manager_run_generators(m);
2388
2389         q = lookup_paths_init(
2390                         &m->lookup_paths, m->running_as, true,
2391                         NULL,
2392                         m->generator_unit_path,
2393                         m->generator_unit_path_early,
2394                         m->generator_unit_path_late);
2395         if (q < 0)
2396                 r = q;
2397
2398         manager_build_unit_path_cache(m);
2399
2400         /* First, enumerate what we can from all config files */
2401         q = manager_enumerate(m);
2402         if (q < 0)
2403                 r = q;
2404
2405         /* Second, deserialize our stored data */
2406         q = manager_deserialize(m, f, fds);
2407         if (q < 0)
2408                 r = q;
2409
2410         fclose(f);
2411         f = NULL;
2412
2413         /* Re-register notify_fd as event source */
2414         q = manager_setup_notify(m);
2415         if (q < 0)
2416                 r = q;
2417
2418         /* Third, fire things up! */
2419         q = manager_coldplug(m);
2420         if (q < 0)
2421                 r = q;
2422
2423         assert(m->n_reloading > 0);
2424         m->n_reloading--;
2425
2426         m->send_reloading_done = true;
2427
2428         return r;
2429 }
2430
2431 bool manager_is_reloading_or_reexecuting(Manager *m) {
2432         assert(m);
2433
2434         return m->n_reloading != 0;
2435 }
2436
2437 void manager_reset_failed(Manager *m) {
2438         Unit *u;
2439         Iterator i;
2440
2441         assert(m);
2442
2443         HASHMAP_FOREACH(u, m->units, i)
2444                 unit_reset_failed(u);
2445 }
2446
2447 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2448         Unit *u;
2449
2450         assert(m);
2451         assert(name);
2452
2453         /* Returns true if the unit is inactive or going down */
2454         u = manager_get_unit(m, name);
2455         if (!u)
2456                 return true;
2457
2458         return unit_inactive_or_pending(u);
2459 }
2460
2461 void manager_check_finished(Manager *m) {
2462         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2463         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2464         Unit *u = NULL;
2465         Iterator i;
2466
2467         assert(m);
2468
2469         if (m->n_running_jobs == 0)
2470                 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2471
2472         if (hashmap_size(m->jobs) > 0) {
2473
2474                 if (m->jobs_in_progress_event_source) {
2475                         sd_event_source_set_time(m->jobs_in_progress_event_source,
2476                                                  now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2477                 }
2478
2479                 return;
2480         }
2481
2482         manager_flip_auto_status(m, false);
2483
2484         /* Notify Type=idle units that we are done now */
2485         m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2486         manager_close_idle_pipe(m);
2487
2488         /* Turn off confirm spawn now */
2489         m->confirm_spawn = false;
2490
2491         /* This is no longer the first boot */
2492         manager_set_first_boot(m, false);
2493
2494         if (dual_timestamp_is_set(&m->finish_timestamp))
2495                 return;
2496
2497         dual_timestamp_get(&m->finish_timestamp);
2498
2499         if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2500
2501                 /* Note that m->kernel_usec.monotonic is always at 0,
2502                  * and m->firmware_usec.monotonic and
2503                  * m->loader_usec.monotonic should be considered
2504                  * negative values. */
2505
2506                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2507                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2508                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2509                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2510
2511                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2512
2513                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2514                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2515
2516                         if (!log_on_console())
2517                                 log_struct(LOG_INFO,
2518                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2519                                            "KERNEL_USEC="USEC_FMT, kernel_usec,
2520                                            "INITRD_USEC="USEC_FMT, initrd_usec,
2521                                            "USERSPACE_USEC="USEC_FMT, userspace_usec,
2522                                            "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2523                                            format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2524                                            format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2525                                            format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2526                                            format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2527                                            NULL);
2528                 } else {
2529                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2530                         initrd_usec = 0;
2531
2532                         if (!log_on_console())
2533                                 log_struct(LOG_INFO,
2534                                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2535                                            "KERNEL_USEC="USEC_FMT, kernel_usec,
2536                                            "USERSPACE_USEC="USEC_FMT, userspace_usec,
2537                                            "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2538                                            format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2539                                            format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2540                                            format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2541                                            NULL);
2542                 }
2543         } else {
2544                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2545                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2546
2547                 if (!log_on_console())
2548                         log_struct(LOG_INFO,
2549                                    MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2550                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
2551                                    "MESSAGE=Startup finished in %s.",
2552                                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2553                                    NULL);
2554         }
2555
2556         SET_FOREACH(u, m->startup_units, i)
2557                 if (u->cgroup_path)
2558                         cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2559
2560         bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2561
2562         sd_notifyf(false,
2563                    "READY=1\nSTATUS=Startup finished in %s.",
2564                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2565 }
2566
2567 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2568         char *p;
2569         int r;
2570
2571         assert(m);
2572         assert(generator);
2573         assert(name);
2574
2575         if (*generator)
2576                 return 0;
2577
2578         if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2579                 /* systemd --system, not running --test */
2580
2581                 p = strappend("/run/systemd/", name);
2582                 if (!p)
2583                         return log_oom();
2584
2585                 r = mkdir_p_label(p, 0755);
2586                 if (r < 0) {
2587                         log_error("Failed to create generator directory %s: %s",
2588                                   p, strerror(-r));
2589                         free(p);
2590                         return r;
2591                 }
2592         } else if (m->running_as == SYSTEMD_USER) {
2593                 const char *s = NULL;
2594
2595                 s = getenv("XDG_RUNTIME_DIR");
2596                 if (!s)
2597                         return -EINVAL;
2598                 p = strjoin(s, "/systemd/", name, NULL);
2599                 if (!p)
2600                         return log_oom();
2601
2602                 r = mkdir_p_label(p, 0755);
2603                 if (r < 0) {
2604                         log_error("Failed to create generator directory %s: %s",
2605                                   p, strerror(-r));
2606                         free(p);
2607                         return r;
2608                 }
2609         } else {
2610                 /* systemd --system --test */
2611
2612                 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2613                 if (!p)
2614                         return log_oom();
2615
2616                 if (!mkdtemp(p)) {
2617                         log_error("Failed to create generator directory %s: %m",
2618                                   p);
2619                         free(p);
2620                         return -errno;
2621                 }
2622         }
2623
2624         *generator = p;
2625         return 0;
2626 }
2627
2628 static void trim_generator_dir(Manager *m, char **generator) {
2629         assert(m);
2630         assert(generator);
2631
2632         if (!*generator)
2633                 return;
2634
2635         if (rmdir(*generator) >= 0) {
2636                 free(*generator);
2637                 *generator = NULL;
2638         }
2639
2640         return;
2641 }
2642
2643 void manager_run_generators(Manager *m) {
2644         _cleanup_closedir_ DIR *d = NULL;
2645         const char *generator_path;
2646         const char *argv[5];
2647         int r;
2648
2649         assert(m);
2650
2651         if (m->test_run)
2652                 return;
2653
2654         generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2655         d = opendir(generator_path);
2656         if (!d) {
2657                 if (errno == ENOENT)
2658                         return;
2659
2660                 log_error("Failed to enumerate generator directory %s: %m",
2661                           generator_path);
2662                 return;
2663         }
2664
2665         r = create_generator_dir(m, &m->generator_unit_path, "generator");
2666         if (r < 0)
2667                 goto finish;
2668
2669         r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2670         if (r < 0)
2671                 goto finish;
2672
2673         r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2674         if (r < 0)
2675                 goto finish;
2676
2677         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2678         argv[1] = m->generator_unit_path;
2679         argv[2] = m->generator_unit_path_early;
2680         argv[3] = m->generator_unit_path_late;
2681         argv[4] = NULL;
2682
2683         RUN_WITH_UMASK(0022)
2684                 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2685
2686 finish:
2687         trim_generator_dir(m, &m->generator_unit_path);
2688         trim_generator_dir(m, &m->generator_unit_path_early);
2689         trim_generator_dir(m, &m->generator_unit_path_late);
2690 }
2691
2692 static void remove_generator_dir(Manager *m, char **generator) {
2693         assert(m);
2694         assert(generator);
2695
2696         if (!*generator)
2697                 return;
2698
2699         strv_remove(m->lookup_paths.unit_path, *generator);
2700         rm_rf(*generator, false, true, false);
2701
2702         free(*generator);
2703         *generator = NULL;
2704 }
2705
2706 void manager_undo_generators(Manager *m) {
2707         assert(m);
2708
2709         remove_generator_dir(m, &m->generator_unit_path);
2710         remove_generator_dir(m, &m->generator_unit_path_early);
2711         remove_generator_dir(m, &m->generator_unit_path_late);
2712 }
2713
2714 int manager_environment_add(Manager *m, char **minus, char **plus) {
2715         char **a = NULL, **b = NULL, **l;
2716         assert(m);
2717
2718         l = m->environment;
2719
2720         if (!strv_isempty(minus)) {
2721                 a = strv_env_delete(l, 1, minus);
2722                 if (!a)
2723                         return -ENOMEM;
2724
2725                 l = a;
2726         }
2727
2728         if (!strv_isempty(plus)) {
2729                 b = strv_env_merge(2, l, plus);
2730                 if (!b)
2731                         return -ENOMEM;
2732
2733                 l = b;
2734         }
2735
2736         if (m->environment != l)
2737                 strv_free(m->environment);
2738         if (a != l)
2739                 strv_free(a);
2740         if (b != l)
2741                 strv_free(b);
2742
2743         m->environment = l;
2744         manager_clean_environment(m);
2745         strv_sort(m->environment);
2746
2747         return 0;
2748 }
2749
2750 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2751         int i;
2752
2753         assert(m);
2754
2755         for (i = 0; i < _RLIMIT_MAX; i++) {
2756                 if (!default_rlimit[i])
2757                         continue;
2758
2759                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2760                 if (!m->rlimit[i])
2761                         return -ENOMEM;
2762         }
2763
2764         return 0;
2765 }
2766
2767 void manager_recheck_journal(Manager *m) {
2768         Unit *u;
2769
2770         assert(m);
2771
2772         if (m->running_as != SYSTEMD_SYSTEM)
2773                 return;
2774
2775         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2776         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2777                 log_close_journal();
2778                 return;
2779         }
2780
2781         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2782         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2783                 log_close_journal();
2784                 return;
2785         }
2786
2787         /* Hmm, OK, so the socket is fully up and the service is up
2788          * too, then let's make use of the thing. */
2789         log_open();
2790 }
2791
2792 void manager_set_show_status(Manager *m, ShowStatus mode) {
2793         assert(m);
2794         assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2795
2796         if (m->running_as != SYSTEMD_SYSTEM)
2797                 return;
2798
2799         m->show_status = mode;
2800
2801         if (mode > 0)
2802                 touch("/run/systemd/show-status");
2803         else
2804                 unlink("/run/systemd/show-status");
2805 }
2806
2807 static bool manager_get_show_status(Manager *m) {
2808         assert(m);
2809
2810         if (m->running_as != SYSTEMD_SYSTEM)
2811                 return false;
2812
2813         if (m->no_console_output)
2814                 return false;
2815
2816         if (!IN_SET(manager_state(m), MANAGER_STARTING, MANAGER_STOPPING))
2817                 return false;
2818
2819         if (m->show_status > 0)
2820                 return true;
2821
2822         /* If Plymouth is running make sure we show the status, so
2823          * that there's something nice to see when people press Esc */
2824
2825         return plymouth_running();
2826 }
2827
2828 void manager_set_first_boot(Manager *m, bool b) {
2829         assert(m);
2830
2831         if (m->running_as != SYSTEMD_SYSTEM)
2832                 return;
2833
2834         m->first_boot = b;
2835
2836         if (m->first_boot)
2837                 touch("/run/systemd/first-boot");
2838         else
2839                 unlink("/run/systemd/first-boot");
2840 }
2841
2842 void manager_status_printf(Manager *m, bool ephemeral, const char *status, const char *format, ...) {
2843         va_list ap;
2844
2845         if (!manager_get_show_status(m))
2846                 return;
2847
2848         /* XXX We should totally drop the check for ephemeral here
2849          * and thus effectively make 'Type=idle' pointless. */
2850         if (ephemeral && m->n_on_console > 0)
2851                 return;
2852
2853         va_start(ap, format);
2854         status_vprintf(status, true, ephemeral, format, ap);
2855         va_end(ap);
2856 }
2857
2858 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2859         _cleanup_free_ char *p = NULL;
2860         Unit *found;
2861
2862         assert(m);
2863         assert(path);
2864         assert(suffix);
2865         assert(_found);
2866
2867         p = unit_name_from_path(path, suffix);
2868         if (!p)
2869                 return -ENOMEM;
2870
2871         found = manager_get_unit(m, p);
2872         if (!found) {
2873                 *_found = NULL;
2874                 return 0;
2875         }
2876
2877         *_found = found;
2878         return 1;
2879 }
2880
2881 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
2882         char p[strlen(path)+1];
2883
2884         assert(m);
2885         assert(path);
2886
2887         strcpy(p, path);
2888         path_kill_slashes(p);
2889
2890         return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
2891 }
2892
2893 const char *manager_get_runtime_prefix(Manager *m) {
2894         assert(m);
2895
2896         return m->running_as == SYSTEMD_SYSTEM ?
2897                "/run" :
2898                getenv("XDG_RUNTIME_DIR");
2899 }
2900
2901 ManagerState manager_state(Manager *m) {
2902         Unit *u;
2903
2904         assert(m);
2905
2906         /* Did we ever finish booting? If not then we are still starting up */
2907         if (!dual_timestamp_is_set(&m->finish_timestamp))
2908                 return MANAGER_STARTING;
2909
2910         /* Is the special shutdown target queued? If so, we are in shutdown state */
2911         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
2912         if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
2913                 return MANAGER_STOPPING;
2914
2915         /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
2916         u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
2917         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2918                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2919                 return MANAGER_MAINTENANCE;
2920
2921         u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
2922         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
2923                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
2924                 return MANAGER_MAINTENANCE;
2925
2926         /* Are there any failed units? If so, we are in degraded mode */
2927         if (set_size(m->failed_units) > 0)
2928                 return MANAGER_DEGRADED;
2929
2930         return MANAGER_RUNNING;
2931 }
2932
2933 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
2934         [MANAGER_STARTING] = "starting",
2935         [MANAGER_RUNNING] = "running",
2936         [MANAGER_DEGRADED] = "degraded",
2937         [MANAGER_MAINTENANCE] = "maintenance",
2938         [MANAGER_STOPPING] = "stopping",
2939 };
2940
2941 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);