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