src/core/manager.c

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