src/core/manager.c

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