src/core/manager.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <assert.h>
  23 #include <errno.h>
  24 #include <string.h>
  25 #include <signal.h>
  26 #include <sys/wait.h>
  27 #include <unistd.h>
  28 #include <sys/inotify.h>
  29 #include <sys/epoll.h>
  30 #include <sys/poll.h>
  31 #include <sys/reboot.h>
  32 #include <sys/ioctl.h>
  33 #include <linux/kd.h>
  34 #include <termios.h>
  35 #include <fcntl.h>
  36 #include <sys/types.h>
  37 #include <sys/stat.h>
  38 #include <dirent.h>
  39 #include <sys/timerfd.h>
  40
  41 #ifdef HAVE_AUDIT
  42 #include <libaudit.h>
  43 #endif
  44
  45 #include "sd-daemon.h"
  46 #include "sd-id128.h"
  47 #include "sd-messages.h"
  48
  49 #include "manager.h"
  50 #include "transaction.h"
  51 #include "hashmap.h"
  52 #include "macro.h"
  53 #include "strv.h"
  54 #include "log.h"
  55 #include "util.h"
  56 #include "mkdir.h"
  57 #include "ratelimit.h"
  58 #include "locale-setup.h"
  59 #include "mount-setup.h"
  60 #include "unit-name.h"
  61 #include "missing.h"
  62 #include "path-lookup.h"
  63 #include "special.h"
  64 #include "exit-status.h"
  65 #include "virt.h"
  66 #include "watchdog.h"
  67 #include "cgroup-util.h"
  68 #include "path-util.h"
  69 #include "audit-fd.h"
  70 #include "boot-timestamps.h"
  71 #include "env-util.h"
  72 #include "bus-common-errors.h"
  73 #include "bus-error.h"
  74 #include "bus-util.h"
  75 #include "dbus.h"
  76 #include "dbus-unit.h"
  77 #include "dbus-job.h"
  78 #include "dbus-manager.h"
  79 #include "bus-kernel.h"
  80 #include "time-util.h"
  81
  82 /* Initial delay and the interval for printing status messages about running jobs */
  83 #define JOBS_IN_PROGRESS_WAIT_USEC (5*USEC_PER_SEC)
  84 #define JOBS_IN_PROGRESS_PERIOD_USEC (USEC_PER_SEC / 3)
  85 #define JOBS_IN_PROGRESS_PERIOD_DIVISOR 3
  86
  87 static int manager_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  88 static int manager_dispatch_signal_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  89 static int manager_dispatch_time_change_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  90 static int manager_dispatch_idle_pipe_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  91 static int manager_dispatch_jobs_in_progress(sd_event_source *source, usec_t usec, void *userdata);
  92 static int manager_dispatch_run_queue(sd_event_source *source, void *userdata);
  93 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 too more
1729                                  * than 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 = strappenda("unit=", p);
2110
2111         if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2112                 if (errno == EPERM)
2113                         /* We aren't allowed to send audit messages?
2114                          * Then let's not retry again. */
2115                         close_audit_fd();
2116                 else
2117                         log_warning_errno(errno, "Failed to send audit message: %m");
2118         }
2119 #endif
2120
2121 }
2122
2123 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2124         union sockaddr_union sa = PLYMOUTH_SOCKET;
2125
2126         int n = 0;
2127         _cleanup_free_ char *message = NULL;
2128         _cleanup_close_ int fd = -1;
2129
2130         /* Don't generate plymouth events if the service was already
2131          * started and we're just deserializing */
2132         if (m->n_reloading > 0)
2133                 return;
2134
2135         if (m->running_as != SYSTEMD_SYSTEM)
2136                 return;
2137
2138         if (detect_container(NULL) > 0)
2139                 return;
2140
2141         if (u->type != UNIT_SERVICE &&
2142             u->type != UNIT_MOUNT &&
2143             u->type != UNIT_SWAP)
2144                 return;
2145
2146         /* We set SOCK_NONBLOCK here so that we rather drop the
2147          * message then wait for plymouth */
2148         fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2149         if (fd < 0) {
2150                 log_error_errno(errno, "socket() failed: %m");
2151                 return;
2152         }
2153
2154         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2155
2156                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2157                         log_error_errno(errno, "connect() failed: %m");
2158                 return;
2159         }
2160
2161         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2162                 log_oom();
2163                 return;
2164         }
2165
2166         errno = 0;
2167         if (write(fd, message, n + 1) != n + 1)
2168                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2169                         log_error_errno(errno, "Failed to write Plymouth message: %m");
2170 }
2171
2172 void manager_dispatch_bus_name_owner_changed(
2173                 Manager *m,
2174                 const char *name,
2175                 const char* old_owner,
2176                 const char *new_owner) {
2177
2178         Unit *u;
2179
2180         assert(m);
2181         assert(name);
2182
2183         u = hashmap_get(m->watch_bus, name);
2184         if (!u)
2185                 return;
2186
2187         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2188 }
2189
2190 int manager_open_serialization(Manager *m, FILE **_f) {
2191         const char *path;
2192         int fd = -1;
2193         FILE *f;
2194
2195         assert(_f);
2196
2197         path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2198         fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2199         if (fd < 0)
2200                 return -errno;
2201
2202         log_debug("Serializing state to %s", path);
2203
2204         f = fdopen(fd, "w+");
2205         if (!f) {
2206                 safe_close(fd);
2207                 return -errno;
2208         }
2209
2210         *_f = f;
2211
2212         return 0;
2213 }
2214
2215 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2216         Iterator i;
2217         Unit *u;
2218         const char *t;
2219         char **e;
2220         int r;
2221
2222         assert(m);
2223         assert(f);
2224         assert(fds);
2225
2226         m->n_reloading ++;
2227
2228         fprintf(f, "current-job-id=%"PRIu32"\n", m->current_job_id);
2229         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2230         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2231         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2232
2233         dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2234         dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2235         dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2236         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2237
2238         if (!in_initrd()) {
2239                 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2240                 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2241                 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2242                 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2243                 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2244                 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2245                 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2246                 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2247         }
2248
2249         if (!switching_root) {
2250                 STRV_FOREACH(e, m->environment) {
2251                         _cleanup_free_ char *ce;
2252
2253                         ce = cescape(*e);
2254                         if (!ce)
2255                                 return -ENOMEM;
2256
2257                         fprintf(f, "env=%s\n", *e);
2258                 }
2259         }
2260
2261         if (m->notify_fd >= 0) {
2262                 int copy;
2263
2264                 copy = fdset_put_dup(fds, m->notify_fd);
2265                 if (copy < 0)
2266                         return copy;
2267
2268                 fprintf(f, "notify-fd=%i\n", copy);
2269                 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2270         }
2271
2272         if (m->kdbus_fd >= 0) {
2273                 int copy;
2274
2275                 copy = fdset_put_dup(fds, m->kdbus_fd);
2276                 if (copy < 0)
2277                         return copy;
2278
2279                 fprintf(f, "kdbus-fd=%i\n", copy);
2280         }
2281
2282         bus_track_serialize(m->subscribed, f);
2283
2284         fputc('\n', f);
2285
2286         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2287                 if (u->id != t)
2288                         continue;
2289
2290                 /* Start marker */
2291                 fputs(u->id, f);
2292                 fputc('\n', f);
2293
2294                 r = unit_serialize(u, f, fds, !switching_root);
2295                 if (r < 0) {
2296                         m->n_reloading --;
2297                         return r;
2298                 }
2299         }
2300
2301         assert(m->n_reloading > 0);
2302         m->n_reloading --;
2303
2304         if (ferror(f))
2305                 return -EIO;
2306
2307         r = bus_fdset_add_all(m, fds);
2308         if (r < 0)
2309                 return r;
2310
2311         return 0;
2312 }
2313
2314 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2315         int r = 0;
2316
2317         assert(m);
2318         assert(f);
2319
2320         log_debug("Deserializing state...");
2321
2322         m->n_reloading ++;
2323
2324         for (;;) {
2325                 char line[LINE_MAX], *l;
2326
2327                 if (!fgets(line, sizeof(line), f)) {
2328                         if (feof(f))
2329                                 r = 0;
2330                         else
2331                                 r = -errno;
2332
2333                         goto finish;
2334                 }
2335
2336                 char_array_0(line);
2337                 l = strstrip(line);
2338
2339                 if (l[0] == 0)
2340                         break;
2341
2342                 if (startswith(l, "current-job-id=")) {
2343                         uint32_t id;
2344
2345                         if (safe_atou32(l+15, &id) < 0)
2346                                 log_debug("Failed to parse current job id value %s", l+15);
2347                         else
2348                                 m->current_job_id = MAX(m->current_job_id, id);
2349
2350                 } else if (startswith(l, "n-installed-jobs=")) {
2351                         uint32_t n;
2352
2353                         if (safe_atou32(l+17, &n) < 0)
2354                                 log_debug("Failed to parse installed jobs counter %s", l+17);
2355                         else
2356                                 m->n_installed_jobs += n;
2357
2358                 } else if (startswith(l, "n-failed-jobs=")) {
2359                         uint32_t n;
2360
2361                         if (safe_atou32(l+14, &n) < 0)
2362                                 log_debug("Failed to parse failed jobs counter %s", l+14);
2363                         else
2364                                 m->n_failed_jobs += n;
2365
2366                 } else if (startswith(l, "taint-usr=")) {
2367                         int b;
2368
2369                         b = parse_boolean(l+10);
2370                         if (b < 0)
2371                                 log_debug("Failed to parse taint /usr flag %s", l+10);
2372                         else
2373                                 m->taint_usr = m->taint_usr || b;
2374
2375                 } else if (startswith(l, "firmware-timestamp="))
2376                         dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2377                 else if (startswith(l, "loader-timestamp="))
2378                         dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2379                 else if (startswith(l, "kernel-timestamp="))
2380                         dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2381                 else if (startswith(l, "initrd-timestamp="))
2382                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2383                 else if (startswith(l, "userspace-timestamp="))
2384                         dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2385                 else if (startswith(l, "finish-timestamp="))
2386                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2387                 else if (startswith(l, "security-start-timestamp="))
2388                         dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2389                 else if (startswith(l, "security-finish-timestamp="))
2390                         dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2391                 else if (startswith(l, "generators-start-timestamp="))
2392                         dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2393                 else if (startswith(l, "generators-finish-timestamp="))
2394                         dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2395                 else if (startswith(l, "units-load-start-timestamp="))
2396                         dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2397                 else if (startswith(l, "units-load-finish-timestamp="))
2398                         dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2399                 else if (startswith(l, "env=")) {
2400                         _cleanup_free_ char *uce = NULL;
2401                         char **e;
2402
2403                         uce = cunescape(l+4);
2404                         if (!uce) {
2405                                 r = -ENOMEM;
2406                                 goto finish;
2407                         }
2408
2409                         e = strv_env_set(m->environment, uce);
2410                         if (!e) {
2411                                 r = -ENOMEM;
2412                                 goto finish;
2413                         }
2414
2415                         strv_free(m->environment);
2416                         m->environment = e;
2417
2418                 } else if (startswith(l, "notify-fd=")) {
2419                         int fd;
2420
2421                         if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2422                                 log_debug("Failed to parse notify fd: %s", l + 10);
2423                         else {
2424                                 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2425                                 safe_close(m->notify_fd);
2426                                 m->notify_fd = fdset_remove(fds, fd);
2427                         }
2428
2429                 } else if (startswith(l, "notify-socket=")) {
2430                         char *n;
2431
2432                         n = strdup(l+14);
2433                         if (!n) {
2434                                 r = -ENOMEM;
2435                                 goto finish;
2436                         }
2437
2438                         free(m->notify_socket);
2439                         m->notify_socket = n;
2440
2441                 } else if (startswith(l, "kdbus-fd=")) {
2442                         int fd;
2443
2444                         if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2445                                 log_debug("Failed to parse kdbus fd: %s", l + 9);
2446                         else {
2447                                 safe_close(m->kdbus_fd);
2448                                 m->kdbus_fd = fdset_remove(fds, fd);
2449                         }
2450
2451                 } else {
2452                         int k;
2453
2454                         k = bus_track_deserialize_item(&m->deserialized_subscribed, l);
2455                         if (k < 0)
2456                                 log_debug_errno(k, "Failed to deserialize bus tracker object: %m");
2457                         else if (k == 0)
2458                                 log_debug("Unknown serialization item '%s'", l);
2459                 }
2460         }
2461
2462         for (;;) {
2463                 Unit *u;
2464                 char name[UNIT_NAME_MAX+2];
2465
2466                 /* Start marker */
2467                 if (!fgets(name, sizeof(name), f)) {
2468                         if (feof(f))
2469                                 r = 0;
2470                         else
2471                                 r = -errno;
2472
2473                         goto finish;
2474                 }
2475
2476                 char_array_0(name);
2477
2478                 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2479                 if (r < 0)
2480                         goto finish;
2481
2482                 r = unit_deserialize(u, f, fds);
2483                 if (r < 0)
2484                         goto finish;
2485         }
2486
2487 finish:
2488         if (ferror(f))
2489                 r = -EIO;
2490
2491         assert(m->n_reloading > 0);
2492         m->n_reloading --;
2493
2494         return r;
2495 }
2496
2497 int manager_reload(Manager *m) {
2498         int r, q;
2499         _cleanup_fclose_ FILE *f = NULL;
2500         _cleanup_fdset_free_ FDSet *fds = NULL;
2501
2502         assert(m);
2503
2504         r = manager_open_serialization(m, &f);
2505         if (r < 0)
2506                 return r;
2507
2508         m->n_reloading ++;
2509         bus_manager_send_reloading(m, true);
2510
2511         fds = fdset_new();
2512         if (!fds) {
2513                 m->n_reloading --;
2514                 return -ENOMEM;
2515         }
2516
2517         r = manager_serialize(m, f, fds, false);
2518         if (r < 0) {
2519                 m->n_reloading --;
2520                 return r;
2521         }
2522
2523         if (fseeko(f, 0, SEEK_SET) < 0) {
2524                 m->n_reloading --;
2525                 return -errno;
2526         }
2527
2528         /* From here on there is no way back. */
2529         manager_clear_jobs_and_units(m);
2530         manager_undo_generators(m);
2531         lookup_paths_free(&m->lookup_paths);
2532
2533         /* Find new unit paths */
2534         q = manager_run_generators(m);
2535         if (q < 0 && r >= 0)
2536                 r = q;
2537
2538         q = lookup_paths_init(
2539                         &m->lookup_paths, m->running_as, true,
2540                         NULL,
2541                         m->generator_unit_path,
2542                         m->generator_unit_path_early,
2543                         m->generator_unit_path_late);
2544         if (q < 0 && r >= 0)
2545                 r = q;
2546
2547         manager_build_unit_path_cache(m);
2548
2549         /* First, enumerate what we can from all config files */
2550         q = manager_enumerate(m);
2551         if (q < 0 && r >= 0)
2552                 r = q;
2553
2554         /* Second, deserialize our stored data */
2555         q = manager_deserialize(m, f, fds);
2556         if (q < 0 && r >= 0)
2557                 r = q;
2558
2559         fclose(f);
2560         f = NULL;
2561
2562         /* Re-register notify_fd as event source */
2563         q = manager_setup_notify(m);
2564         if (q < 0 && r >= 0)
2565                 r = q;
2566
2567         /* Third, fire things up! */
2568         q = manager_coldplug(m);
2569         if (q < 0 && r >= 0)
2570                 r = q;
2571
2572         assert(m->n_reloading > 0);
2573         m->n_reloading--;
2574
2575         m->send_reloading_done = true;
2576
2577         return r;
2578 }
2579
2580 bool manager_is_reloading_or_reexecuting(Manager *m) {
2581         assert(m);
2582
2583         return m->n_reloading != 0;
2584 }
2585
2586 void manager_reset_failed(Manager *m) {
2587         Unit *u;
2588         Iterator i;
2589
2590         assert(m);
2591
2592         HASHMAP_FOREACH(u, m->units, i)
2593                 unit_reset_failed(u);
2594 }
2595
2596 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2597         Unit *u;
2598
2599         assert(m);
2600         assert(name);
2601
2602         /* Returns true if the unit is inactive or going down */
2603         u = manager_get_unit(m, name);
2604         if (!u)
2605                 return true;
2606
2607         return unit_inactive_or_pending(u);
2608 }
2609
2610 static void manager_notify_finished(Manager *m) {
2611         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2612         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2613
2614         if (m->test_run)
2615                 return;
2616
2617         if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2618
2619                 /* Note that m->kernel_usec.monotonic is always at 0,
2620                  * and m->firmware_usec.monotonic and
2621                  * m->loader_usec.monotonic should be considered
2622                  * negative values. */
2623
2624                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2625                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2626                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2627                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2628
2629                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2630
2631                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2632                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2633
2634                         log_struct(LOG_INFO,
2635                                    LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2636                                    "KERNEL_USEC="USEC_FMT, kernel_usec,
2637                                    "INITRD_USEC="USEC_FMT, initrd_usec,
2638                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
2639                                    LOG_MESSAGE("Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2640                                                format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2641                                                format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2642                                                format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2643                                                format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2644                                    NULL);
2645                 } else {
2646                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2647                         initrd_usec = 0;
2648
2649                         log_struct(LOG_INFO,
2650                                    LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2651                                    "KERNEL_USEC="USEC_FMT, kernel_usec,
2652                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
2653                                    LOG_MESSAGE("Startup finished in %s (kernel) + %s (userspace) = %s.",
2654                                                format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2655                                                format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2656                                                format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2657                                    NULL);
2658                 }
2659         } else {
2660                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2661                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2662
2663                 log_struct(LOG_INFO,
2664                            LOG_MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2665                            "USERSPACE_USEC="USEC_FMT, userspace_usec,
2666                            LOG_MESSAGE("Startup finished in %s.",
2667                                        format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC)),
2668                            NULL);
2669         }
2670
2671         bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2672
2673         sd_notifyf(false,
2674                    "READY=1\n"
2675                    "STATUS=Startup finished in %s.",
2676                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2677 }
2678
2679 void manager_check_finished(Manager *m) {
2680         Unit *u = NULL;
2681         Iterator i;
2682
2683         assert(m);
2684
2685         if (hashmap_size(m->jobs) > 0) {
2686
2687                 if (m->jobs_in_progress_event_source)
2688                         sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2689
2690                 return;
2691         }
2692
2693         manager_flip_auto_status(m, false);
2694
2695         /* Notify Type=idle units that we are done now */
2696         m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2697         manager_close_idle_pipe(m);
2698
2699         /* Turn off confirm spawn now */
2700         m->confirm_spawn = false;
2701
2702         /* No need to update ask password status when we're going non-interactive */
2703         manager_close_ask_password(m);
2704
2705         /* This is no longer the first boot */
2706         manager_set_first_boot(m, false);
2707
2708         if (dual_timestamp_is_set(&m->finish_timestamp))
2709                 return;
2710
2711         dual_timestamp_get(&m->finish_timestamp);
2712
2713         manager_notify_finished(m);
2714
2715         SET_FOREACH(u, m->startup_units, i)
2716                 if (u->cgroup_path)
2717                         cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2718 }
2719
2720 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2721         char *p;
2722         int r;
2723
2724         assert(m);
2725         assert(generator);
2726         assert(name);
2727
2728         if (*generator)
2729                 return 0;
2730
2731         if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2732                 /* systemd --system, not running --test */
2733
2734                 p = strappend("/run/systemd/", name);
2735                 if (!p)
2736                         return log_oom();
2737
2738                 r = mkdir_p_label(p, 0755);
2739                 if (r < 0) {
2740                         log_error_errno(r, "Failed to create generator directory %s: %m", p);
2741                         free(p);
2742                         return r;
2743                 }
2744         } else if (m->running_as == SYSTEMD_USER) {
2745                 const char *s = NULL;
2746
2747                 s = getenv("XDG_RUNTIME_DIR");
2748                 if (!s)
2749                         return -EINVAL;
2750                 p = strjoin(s, "/systemd/", name, NULL);
2751                 if (!p)
2752                         return log_oom();
2753
2754                 r = mkdir_p_label(p, 0755);
2755                 if (r < 0) {
2756                         log_error_errno(r, "Failed to create generator directory %s: %m", p);
2757                         free(p);
2758                         return r;
2759                 }
2760         } else {
2761                 /* systemd --system --test */
2762
2763                 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2764                 if (!p)
2765                         return log_oom();
2766
2767                 if (!mkdtemp(p)) {
2768                         log_error_errno(errno, "Failed to create generator directory %s: %m",
2769                                   p);
2770                         free(p);
2771                         return -errno;
2772                 }
2773         }
2774
2775         *generator = p;
2776         return 0;
2777 }
2778
2779 static void trim_generator_dir(Manager *m, char **generator) {
2780         assert(m);
2781         assert(generator);
2782
2783         if (!*generator)
2784                 return;
2785
2786         if (rmdir(*generator) >= 0) {
2787                 free(*generator);
2788                 *generator = NULL;
2789         }
2790
2791         return;
2792 }
2793
2794 static int manager_run_generators(Manager *m) {
2795         _cleanup_free_ char **paths = NULL;
2796         const char *argv[5];
2797         char **path;
2798         int r;
2799
2800         assert(m);
2801
2802         if (m->test_run)
2803                 return 0;
2804
2805         paths = generator_paths(m->running_as);
2806         if (!paths)
2807                 return log_oom();
2808
2809         /* Optimize by skipping the whole process by not creating output directories
2810          * if no generators are found. */
2811         STRV_FOREACH(path, paths) {
2812                 r = access(*path, F_OK);
2813                 if (r == 0)
2814                         goto found;
2815                 if (errno != ENOENT)
2816                         log_warning_errno(errno, "Failed to open generator directory %s: %m", *path);
2817         }
2818         return 0;
2819
2820  found:
2821         r = create_generator_dir(m, &m->generator_unit_path, "generator");
2822         if (r < 0)
2823                 goto finish;
2824
2825         r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2826         if (r < 0)
2827                 goto finish;
2828
2829         r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2830         if (r < 0)
2831                 goto finish;
2832
2833         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2834         argv[1] = m->generator_unit_path;
2835         argv[2] = m->generator_unit_path_early;
2836         argv[3] = m->generator_unit_path_late;
2837         argv[4] = NULL;
2838
2839         RUN_WITH_UMASK(0022)
2840                 execute_directories((const char* const*) paths, DEFAULT_TIMEOUT_USEC, (char**) argv);
2841
2842 finish:
2843         trim_generator_dir(m, &m->generator_unit_path);
2844         trim_generator_dir(m, &m->generator_unit_path_early);
2845         trim_generator_dir(m, &m->generator_unit_path_late);
2846         return r;
2847 }
2848
2849 static void remove_generator_dir(Manager *m, char **generator) {
2850         assert(m);
2851         assert(generator);
2852
2853         if (!*generator)
2854                 return;
2855
2856         strv_remove(m->lookup_paths.unit_path, *generator);
2857         rm_rf(*generator, false, true, false);
2858
2859         free(*generator);
2860         *generator = NULL;
2861 }
2862
2863 static void manager_undo_generators(Manager *m) {
2864         assert(m);
2865
2866         remove_generator_dir(m, &m->generator_unit_path);
2867         remove_generator_dir(m, &m->generator_unit_path_early);
2868         remove_generator_dir(m, &m->generator_unit_path_late);
2869 }
2870
2871 int manager_environment_add(Manager *m, char **minus, char **plus) {
2872         char **a = NULL, **b = NULL, **l;
2873         assert(m);
2874
2875         l = m->environment;
2876
2877         if (!strv_isempty(minus)) {
2878                 a = strv_env_delete(l, 1, minus);
2879                 if (!a)
2880                         return -ENOMEM;
2881
2882                 l = a;
2883         }
2884
2885         if (!strv_isempty(plus)) {
2886                 b = strv_env_merge(2, l, plus);
2887                 if (!b) {
2888                         strv_free(a);
2889                         return -ENOMEM;
2890                 }
2891
2892                 l = b;
2893         }
2894
2895         if (m->environment != l)
2896                 strv_free(m->environment);
2897         if (a != l)
2898                 strv_free(a);
2899         if (b != l)
2900                 strv_free(b);
2901
2902         m->environment = l;
2903         manager_clean_environment(m);
2904         strv_sort(m->environment);
2905
2906         return 0;
2907 }
2908
2909 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2910         int i;
2911
2912         assert(m);
2913
2914         for (i = 0; i < _RLIMIT_MAX; i++) {
2915                 if (!default_rlimit[i])
2916                         continue;
2917
2918                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2919                 if (!m->rlimit[i])
2920                         return -ENOMEM;
2921         }
2922
2923         return 0;
2924 }
2925
2926 void manager_recheck_journal(Manager *m) {
2927         Unit *u;
2928
2929         assert(m);
2930
2931         if (m->running_as != SYSTEMD_SYSTEM)
2932                 return;
2933
2934         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2935         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2936                 log_close_journal();
2937                 return;
2938         }
2939
2940         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2941         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2942                 log_close_journal();
2943                 return;
2944         }
2945
2946         /* Hmm, OK, so the socket is fully up and the service is up
2947          * too, then let's make use of the thing. */
2948         log_open();
2949 }
2950
2951 void manager_set_show_status(Manager *m, ShowStatus mode) {
2952         assert(m);
2953         assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2954
2955         if (m->running_as != SYSTEMD_SYSTEM)
2956                 return;
2957
2958         m->show_status = mode;
2959
2960         if (mode > 0)
2961                 touch("/run/systemd/show-status");
2962         else
2963                 unlink("/run/systemd/show-status");
2964 }
2965
2966 static bool manager_get_show_status(Manager *m, StatusType type) {
2967         assert(m);
2968
2969         if (m->running_as != SYSTEMD_SYSTEM)
2970                 return false;
2971
2972         if (m->no_console_output)
2973                 return false;
2974
2975         if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
2976                 return false;
2977
2978         /* If we cannot find out the status properly, just proceed. */
2979         if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
2980                 return false;
2981
2982         if (m->show_status > 0)
2983                 return true;
2984
2985         /* If Plymouth is running make sure we show the status, so
2986          * that there's something nice to see when people press Esc */
2987         return plymouth_running();
2988 }
2989
2990 void manager_set_first_boot(Manager *m, bool b) {
2991         assert(m);
2992
2993         if (m->running_as != SYSTEMD_SYSTEM)
2994                 return;
2995
2996         m->first_boot = b;
2997
2998         if (m->first_boot)
2999                 touch("/run/systemd/first-boot");
3000         else
3001                 unlink("/run/systemd/first-boot");
3002 }
3003
3004 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
3005         va_list ap;
3006
3007         /* If m is NULL, assume we're after shutdown and let the messages through. */
3008
3009         if (m && !manager_get_show_status(m, type))
3010                 return;
3011
3012         /* XXX We should totally drop the check for ephemeral here
3013          * and thus effectively make 'Type=idle' pointless. */
3014         if (type == STATUS_TYPE_EPHEMERAL && m && m->n_on_console > 0)
3015                 return;
3016
3017         va_start(ap, format);
3018         status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
3019         va_end(ap);
3020 }
3021
3022 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
3023         _cleanup_free_ char *p = NULL;
3024         Unit *found;
3025
3026         assert(m);
3027         assert(path);
3028         assert(suffix);
3029         assert(_found);
3030
3031         p = unit_name_from_path(path, suffix);
3032         if (!p)
3033                 return -ENOMEM;
3034
3035         found = manager_get_unit(m, p);
3036         if (!found) {
3037                 *_found = NULL;
3038                 return 0;
3039         }
3040
3041         *_found = found;
3042         return 1;
3043 }
3044
3045 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3046         char p[strlen(path)+1];
3047
3048         assert(m);
3049         assert(path);
3050
3051         strcpy(p, path);
3052         path_kill_slashes(p);
3053
3054         return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3055 }
3056
3057 const char *manager_get_runtime_prefix(Manager *m) {
3058         assert(m);
3059
3060         return m->running_as == SYSTEMD_SYSTEM ?
3061                "/run" :
3062                getenv("XDG_RUNTIME_DIR");
3063 }
3064
3065 ManagerState manager_state(Manager *m) {
3066         Unit *u;
3067
3068         assert(m);
3069
3070         /* Did we ever finish booting? If not then we are still starting up */
3071         if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3072
3073                 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3074                 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3075                         return MANAGER_INITIALIZING;
3076
3077                 return MANAGER_STARTING;
3078         }
3079
3080         /* Is the special shutdown target queued? If so, we are in shutdown state */
3081         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3082         if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3083                 return MANAGER_STOPPING;
3084
3085         /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3086         u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3087         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3088                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3089                 return MANAGER_MAINTENANCE;
3090
3091         u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3092         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3093                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3094                 return MANAGER_MAINTENANCE;
3095
3096         /* Are there any failed units? If so, we are in degraded mode */
3097         if (set_size(m->failed_units) > 0)
3098                 return MANAGER_DEGRADED;
3099
3100         return MANAGER_RUNNING;
3101 }
3102
3103 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3104         [MANAGER_INITIALIZING] = "initializing",
3105         [MANAGER_STARTING] = "starting",
3106         [MANAGER_RUNNING] = "running",
3107         [MANAGER_DEGRADED] = "degraded",
3108         [MANAGER_MAINTENANCE] = "maintenance",
3109         [MANAGER_STOPPING] = "stopping",
3110 };
3111
3112 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);