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