src/core/manager.c

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