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