src/core/manager.c

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