src/core/manager.c

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