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