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