src/core/manager.c

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