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