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