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