src/core/manager.c

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