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