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         const char *msg;
2070         int audit_fd;
2071
2072         audit_fd = get_audit_fd();
2073         if (audit_fd < 0)
2074                 return;
2075
2076         /* Don't generate audit events if the service was already
2077          * started and we're just deserializing */
2078         if (m->n_reloading > 0)
2079                 return;
2080
2081         if (m->running_as != SYSTEMD_SYSTEM)
2082                 return;
2083
2084         if (u->type != UNIT_SERVICE)
2085                 return;
2086
2087         p = unit_name_to_prefix_and_instance(u->id);
2088         if (!p) {
2089                 log_oom();
2090                 return;
2091         }
2092
2093         msg = strappenda("unit=", p);
2094
2095         if (audit_log_user_comm_message(audit_fd, type, msg, "systemd", NULL, NULL, NULL, success) < 0) {
2096                 if (errno == EPERM)
2097                         /* We aren't allowed to send audit messages?
2098                          * Then let's not retry again. */
2099                         close_audit_fd();
2100                 else
2101                         log_warning("Failed to send audit message: %m");
2102         }
2103 #endif
2104
2105 }
2106
2107 void manager_send_unit_plymouth(Manager *m, Unit *u) {
2108         union sockaddr_union sa = PLYMOUTH_SOCKET;
2109
2110         int n = 0;
2111         _cleanup_free_ char *message = NULL;
2112         _cleanup_close_ int fd = -1;
2113
2114         /* Don't generate plymouth events if the service was already
2115          * started and we're just deserializing */
2116         if (m->n_reloading > 0)
2117                 return;
2118
2119         if (m->running_as != SYSTEMD_SYSTEM)
2120                 return;
2121
2122         if (detect_container(NULL) > 0)
2123                 return;
2124
2125         if (u->type != UNIT_SERVICE &&
2126             u->type != UNIT_MOUNT &&
2127             u->type != UNIT_SWAP)
2128                 return;
2129
2130         /* We set SOCK_NONBLOCK here so that we rather drop the
2131          * message then wait for plymouth */
2132         fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
2133         if (fd < 0) {
2134                 log_error("socket() failed: %m");
2135                 return;
2136         }
2137
2138         if (connect(fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + 1 + strlen(sa.un.sun_path+1)) < 0) {
2139
2140                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2141                         log_error("connect() failed: %m");
2142                 return;
2143         }
2144
2145         if (asprintf(&message, "U\002%c%s%n", (int) (strlen(u->id) + 1), u->id, &n) < 0) {
2146                 log_oom();
2147                 return;
2148         }
2149
2150         errno = 0;
2151         if (write(fd, message, n + 1) != n + 1)
2152                 if (!IN_SET(errno, EPIPE, EAGAIN, ENOENT, ECONNREFUSED, ECONNRESET, ECONNABORTED))
2153                         log_error("Failed to write Plymouth message: %m");
2154 }
2155
2156 void manager_dispatch_bus_name_owner_changed(
2157                 Manager *m,
2158                 const char *name,
2159                 const char* old_owner,
2160                 const char *new_owner) {
2161
2162         Unit *u;
2163
2164         assert(m);
2165         assert(name);
2166
2167         u = hashmap_get(m->watch_bus, name);
2168         if (!u)
2169                 return;
2170
2171         UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2172 }
2173
2174 int manager_open_serialization(Manager *m, FILE **_f) {
2175         const char *path;
2176         int fd = -1;
2177         FILE *f;
2178
2179         assert(_f);
2180
2181         path = m->running_as == SYSTEMD_SYSTEM ? "/run/systemd" : "/tmp";
2182         fd = open_tmpfile(path, O_RDWR|O_CLOEXEC);
2183         if (fd < 0)
2184                 return -errno;
2185
2186         log_debug("Serializing state to %s", path);
2187
2188         f = fdopen(fd, "w+");
2189         if (!f) {
2190                 safe_close(fd);
2191                 return -errno;
2192         }
2193
2194         *_f = f;
2195
2196         return 0;
2197 }
2198
2199 int manager_serialize(Manager *m, FILE *f, FDSet *fds, bool switching_root) {
2200         Iterator i;
2201         Unit *u;
2202         const char *t;
2203         char **e;
2204         int r;
2205
2206         assert(m);
2207         assert(f);
2208         assert(fds);
2209
2210         m->n_reloading ++;
2211
2212         fprintf(f, "current-job-id=%i\n", m->current_job_id);
2213         fprintf(f, "taint-usr=%s\n", yes_no(m->taint_usr));
2214         fprintf(f, "n-installed-jobs=%u\n", m->n_installed_jobs);
2215         fprintf(f, "n-failed-jobs=%u\n", m->n_failed_jobs);
2216
2217         dual_timestamp_serialize(f, "firmware-timestamp", &m->firmware_timestamp);
2218         dual_timestamp_serialize(f, "loader-timestamp", &m->loader_timestamp);
2219         dual_timestamp_serialize(f, "kernel-timestamp", &m->kernel_timestamp);
2220         dual_timestamp_serialize(f, "initrd-timestamp", &m->initrd_timestamp);
2221
2222         if (!in_initrd()) {
2223                 dual_timestamp_serialize(f, "userspace-timestamp", &m->userspace_timestamp);
2224                 dual_timestamp_serialize(f, "finish-timestamp", &m->finish_timestamp);
2225                 dual_timestamp_serialize(f, "security-start-timestamp", &m->security_start_timestamp);
2226                 dual_timestamp_serialize(f, "security-finish-timestamp", &m->security_finish_timestamp);
2227                 dual_timestamp_serialize(f, "generators-start-timestamp", &m->generators_start_timestamp);
2228                 dual_timestamp_serialize(f, "generators-finish-timestamp", &m->generators_finish_timestamp);
2229                 dual_timestamp_serialize(f, "units-load-start-timestamp", &m->units_load_start_timestamp);
2230                 dual_timestamp_serialize(f, "units-load-finish-timestamp", &m->units_load_finish_timestamp);
2231         }
2232
2233         if (!switching_root) {
2234                 STRV_FOREACH(e, m->environment) {
2235                         _cleanup_free_ char *ce;
2236
2237                         ce = cescape(*e);
2238                         if (!ce)
2239                                 return -ENOMEM;
2240
2241                         fprintf(f, "env=%s\n", *e);
2242                 }
2243         }
2244
2245         if (m->notify_fd >= 0) {
2246                 int copy;
2247
2248                 copy = fdset_put_dup(fds, m->notify_fd);
2249                 if (copy < 0)
2250                         return copy;
2251
2252                 fprintf(f, "notify-fd=%i\n", copy);
2253                 fprintf(f, "notify-socket=%s\n", m->notify_socket);
2254         }
2255
2256         if (m->kdbus_fd >= 0) {
2257                 int copy;
2258
2259                 copy = fdset_put_dup(fds, m->kdbus_fd);
2260                 if (copy < 0)
2261                         return copy;
2262
2263                 fprintf(f, "kdbus-fd=%i\n", copy);
2264         }
2265
2266         bus_track_serialize(m->subscribed, f);
2267
2268         fputc('\n', f);
2269
2270         HASHMAP_FOREACH_KEY(u, t, m->units, i) {
2271                 if (u->id != t)
2272                         continue;
2273
2274                 /* Start marker */
2275                 fputs(u->id, f);
2276                 fputc('\n', f);
2277
2278                 r = unit_serialize(u, f, fds, !switching_root);
2279                 if (r < 0) {
2280                         m->n_reloading --;
2281                         return r;
2282                 }
2283         }
2284
2285         assert(m->n_reloading > 0);
2286         m->n_reloading --;
2287
2288         if (ferror(f))
2289                 return -EIO;
2290
2291         r = bus_fdset_add_all(m, fds);
2292         if (r < 0)
2293                 return r;
2294
2295         return 0;
2296 }
2297
2298 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
2299         int r = 0;
2300
2301         assert(m);
2302         assert(f);
2303
2304         log_debug("Deserializing state...");
2305
2306         m->n_reloading ++;
2307
2308         for (;;) {
2309                 char line[LINE_MAX], *l;
2310
2311                 if (!fgets(line, sizeof(line), f)) {
2312                         if (feof(f))
2313                                 r = 0;
2314                         else
2315                                 r = -errno;
2316
2317                         goto finish;
2318                 }
2319
2320                 char_array_0(line);
2321                 l = strstrip(line);
2322
2323                 if (l[0] == 0)
2324                         break;
2325
2326                 if (startswith(l, "current-job-id=")) {
2327                         uint32_t id;
2328
2329                         if (safe_atou32(l+15, &id) < 0)
2330                                 log_warning("Failed to parse current job id value %s", l+15);
2331                         else
2332                                 m->current_job_id = MAX(m->current_job_id, id);
2333
2334                 } else if (startswith(l, "n-installed-jobs=")) {
2335                         uint32_t n;
2336
2337                         if (safe_atou32(l+17, &n) < 0)
2338                                 log_warning("Failed to parse installed jobs counter %s", l+17);
2339                         else
2340                                 m->n_installed_jobs += n;
2341
2342                 } else if (startswith(l, "n-failed-jobs=")) {
2343                         uint32_t n;
2344
2345                         if (safe_atou32(l+14, &n) < 0)
2346                                 log_warning("Failed to parse failed jobs counter %s", l+14);
2347                         else
2348                                 m->n_failed_jobs += n;
2349
2350                 } else if (startswith(l, "taint-usr=")) {
2351                         int b;
2352
2353                         b = parse_boolean(l+10);
2354                         if (b < 0)
2355                                 log_warning("Failed to parse taint /usr flag %s", l+10);
2356                         else
2357                                 m->taint_usr = m->taint_usr || b;
2358
2359                 } else if (startswith(l, "firmware-timestamp="))
2360                         dual_timestamp_deserialize(l+19, &m->firmware_timestamp);
2361                 else if (startswith(l, "loader-timestamp="))
2362                         dual_timestamp_deserialize(l+17, &m->loader_timestamp);
2363                 else if (startswith(l, "kernel-timestamp="))
2364                         dual_timestamp_deserialize(l+17, &m->kernel_timestamp);
2365                 else if (startswith(l, "initrd-timestamp="))
2366                         dual_timestamp_deserialize(l+17, &m->initrd_timestamp);
2367                 else if (startswith(l, "userspace-timestamp="))
2368                         dual_timestamp_deserialize(l+20, &m->userspace_timestamp);
2369                 else if (startswith(l, "finish-timestamp="))
2370                         dual_timestamp_deserialize(l+17, &m->finish_timestamp);
2371                 else if (startswith(l, "security-start-timestamp="))
2372                         dual_timestamp_deserialize(l+25, &m->security_start_timestamp);
2373                 else if (startswith(l, "security-finish-timestamp="))
2374                         dual_timestamp_deserialize(l+26, &m->security_finish_timestamp);
2375                 else if (startswith(l, "generators-start-timestamp="))
2376                         dual_timestamp_deserialize(l+27, &m->generators_start_timestamp);
2377                 else if (startswith(l, "generators-finish-timestamp="))
2378                         dual_timestamp_deserialize(l+28, &m->generators_finish_timestamp);
2379                 else if (startswith(l, "units-load-start-timestamp="))
2380                         dual_timestamp_deserialize(l+27, &m->units_load_start_timestamp);
2381                 else if (startswith(l, "units-load-finish-timestamp="))
2382                         dual_timestamp_deserialize(l+28, &m->units_load_finish_timestamp);
2383                 else if (startswith(l, "env=")) {
2384                         _cleanup_free_ char *uce = NULL;
2385                         char **e;
2386
2387                         uce = cunescape(l+4);
2388                         if (!uce) {
2389                                 r = -ENOMEM;
2390                                 goto finish;
2391                         }
2392
2393                         e = strv_env_set(m->environment, uce);
2394                         if (!e) {
2395                                 r = -ENOMEM;
2396                                 goto finish;
2397                         }
2398
2399                         strv_free(m->environment);
2400                         m->environment = e;
2401
2402                 } else if (startswith(l, "notify-fd=")) {
2403                         int fd;
2404
2405                         if (safe_atoi(l + 10, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2406                                 log_warning("Failed to parse notify fd: %s", l + 10);
2407                         else {
2408                                 m->notify_event_source = sd_event_source_unref(m->notify_event_source);
2409                                 safe_close(m->notify_fd);
2410                                 m->notify_fd = fdset_remove(fds, fd);
2411                         }
2412
2413                 } else if (startswith(l, "notify-socket=")) {
2414                         char *n;
2415
2416                         n = strdup(l+14);
2417                         if (!n) {
2418                                 r = -ENOMEM;
2419                                 goto finish;
2420                         }
2421
2422                         free(m->notify_socket);
2423                         m->notify_socket = n;
2424
2425                 } else if (startswith(l, "kdbus-fd=")) {
2426                         int fd;
2427
2428                         if (safe_atoi(l + 9, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
2429                                 log_warning("Failed to parse kdbus fd: %s", l + 9);
2430                         else {
2431                                 safe_close(m->kdbus_fd);
2432                                 m->kdbus_fd = fdset_remove(fds, fd);
2433                         }
2434
2435                 } else if (bus_track_deserialize_item(&m->deserialized_subscribed, l) == 0)
2436                         log_warning("Unknown serialization item '%s'", l);
2437         }
2438
2439         for (;;) {
2440                 Unit *u;
2441                 char name[UNIT_NAME_MAX+2];
2442
2443                 /* Start marker */
2444                 if (!fgets(name, sizeof(name), f)) {
2445                         if (feof(f))
2446                                 r = 0;
2447                         else
2448                                 r = -errno;
2449
2450                         goto finish;
2451                 }
2452
2453                 char_array_0(name);
2454
2455                 r = manager_load_unit(m, strstrip(name), NULL, NULL, &u);
2456                 if (r < 0)
2457                         goto finish;
2458
2459                 r = unit_deserialize(u, f, fds);
2460                 if (r < 0)
2461                         goto finish;
2462         }
2463
2464 finish:
2465         if (ferror(f))
2466                 r = -EIO;
2467
2468         assert(m->n_reloading > 0);
2469         m->n_reloading --;
2470
2471         return r;
2472 }
2473
2474 int manager_reload(Manager *m) {
2475         int r, q;
2476         _cleanup_fclose_ FILE *f = NULL;
2477         _cleanup_fdset_free_ FDSet *fds = NULL;
2478
2479         assert(m);
2480
2481         r = manager_open_serialization(m, &f);
2482         if (r < 0)
2483                 return r;
2484
2485         m->n_reloading ++;
2486         bus_manager_send_reloading(m, true);
2487
2488         fds = fdset_new();
2489         if (!fds) {
2490                 m->n_reloading --;
2491                 return -ENOMEM;
2492         }
2493
2494         r = manager_serialize(m, f, fds, false);
2495         if (r < 0) {
2496                 m->n_reloading --;
2497                 return r;
2498         }
2499
2500         if (fseeko(f, 0, SEEK_SET) < 0) {
2501                 m->n_reloading --;
2502                 return -errno;
2503         }
2504
2505         /* From here on there is no way back. */
2506         manager_clear_jobs_and_units(m);
2507         manager_undo_generators(m);
2508         lookup_paths_free(&m->lookup_paths);
2509
2510         /* Find new unit paths */
2511         manager_run_generators(m);
2512
2513         q = lookup_paths_init(
2514                         &m->lookup_paths, m->running_as, true,
2515                         NULL,
2516                         m->generator_unit_path,
2517                         m->generator_unit_path_early,
2518                         m->generator_unit_path_late);
2519         if (q < 0)
2520                 r = q;
2521
2522         manager_build_unit_path_cache(m);
2523
2524         /* First, enumerate what we can from all config files */
2525         q = manager_enumerate(m);
2526         if (q < 0)
2527                 r = q;
2528
2529         /* Second, deserialize our stored data */
2530         q = manager_deserialize(m, f, fds);
2531         if (q < 0)
2532                 r = q;
2533
2534         fclose(f);
2535         f = NULL;
2536
2537         /* Re-register notify_fd as event source */
2538         q = manager_setup_notify(m);
2539         if (q < 0)
2540                 r = q;
2541
2542         /* Third, fire things up! */
2543         q = manager_coldplug(m);
2544         if (q < 0)
2545                 r = q;
2546
2547         assert(m->n_reloading > 0);
2548         m->n_reloading--;
2549
2550         m->send_reloading_done = true;
2551
2552         return r;
2553 }
2554
2555 bool manager_is_reloading_or_reexecuting(Manager *m) {
2556         assert(m);
2557
2558         return m->n_reloading != 0;
2559 }
2560
2561 void manager_reset_failed(Manager *m) {
2562         Unit *u;
2563         Iterator i;
2564
2565         assert(m);
2566
2567         HASHMAP_FOREACH(u, m->units, i)
2568                 unit_reset_failed(u);
2569 }
2570
2571 bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
2572         Unit *u;
2573
2574         assert(m);
2575         assert(name);
2576
2577         /* Returns true if the unit is inactive or going down */
2578         u = manager_get_unit(m, name);
2579         if (!u)
2580                 return true;
2581
2582         return unit_inactive_or_pending(u);
2583 }
2584
2585 static void manager_notify_finished(Manager *m) {
2586         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
2587         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
2588
2589         if (m->test_run)
2590                 return;
2591
2592         if (m->running_as == SYSTEMD_SYSTEM && detect_container(NULL) <= 0) {
2593
2594                 /* Note that m->kernel_usec.monotonic is always at 0,
2595                  * and m->firmware_usec.monotonic and
2596                  * m->loader_usec.monotonic should be considered
2597                  * negative values. */
2598
2599                 firmware_usec = m->firmware_timestamp.monotonic - m->loader_timestamp.monotonic;
2600                 loader_usec = m->loader_timestamp.monotonic - m->kernel_timestamp.monotonic;
2601                 userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2602                 total_usec = m->firmware_timestamp.monotonic + m->finish_timestamp.monotonic;
2603
2604                 if (dual_timestamp_is_set(&m->initrd_timestamp)) {
2605
2606                         kernel_usec = m->initrd_timestamp.monotonic - m->kernel_timestamp.monotonic;
2607                         initrd_usec = m->userspace_timestamp.monotonic - m->initrd_timestamp.monotonic;
2608
2609                         log_struct(LOG_INFO,
2610                                    MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2611                                    "KERNEL_USEC="USEC_FMT, kernel_usec,
2612                                    "INITRD_USEC="USEC_FMT, initrd_usec,
2613                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
2614                                    "MESSAGE=Startup finished in %s (kernel) + %s (initrd) + %s (userspace) = %s.",
2615                                    format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2616                                    format_timespan(initrd, sizeof(initrd), initrd_usec, USEC_PER_MSEC),
2617                                    format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2618                                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2619                                    NULL);
2620                 } else {
2621                         kernel_usec = m->userspace_timestamp.monotonic - m->kernel_timestamp.monotonic;
2622                         initrd_usec = 0;
2623
2624                         log_struct(LOG_INFO,
2625                                    MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2626                                    "KERNEL_USEC="USEC_FMT, kernel_usec,
2627                                    "USERSPACE_USEC="USEC_FMT, userspace_usec,
2628                                    "MESSAGE=Startup finished in %s (kernel) + %s (userspace) = %s.",
2629                                    format_timespan(kernel, sizeof(kernel), kernel_usec, USEC_PER_MSEC),
2630                                    format_timespan(userspace, sizeof(userspace), userspace_usec, USEC_PER_MSEC),
2631                                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2632                                    NULL);
2633                 }
2634         } else {
2635                 firmware_usec = loader_usec = initrd_usec = kernel_usec = 0;
2636                 total_usec = userspace_usec = m->finish_timestamp.monotonic - m->userspace_timestamp.monotonic;
2637
2638                 log_struct(LOG_INFO,
2639                            MESSAGE_ID(SD_MESSAGE_STARTUP_FINISHED),
2640                            "USERSPACE_USEC="USEC_FMT, userspace_usec,
2641                            "MESSAGE=Startup finished in %s.",
2642                            format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC),
2643                            NULL);
2644         }
2645
2646         bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
2647
2648         sd_notifyf(false,
2649                    "READY=1\n"
2650                    "STATUS=Startup finished in %s.",
2651                    format_timespan(sum, sizeof(sum), total_usec, USEC_PER_MSEC));
2652 }
2653
2654 void manager_check_finished(Manager *m) {
2655         Unit *u = NULL;
2656         Iterator i;
2657
2658         assert(m);
2659
2660         if (m->n_running_jobs == 0)
2661                 m->jobs_in_progress_event_source = sd_event_source_unref(m->jobs_in_progress_event_source);
2662
2663         if (hashmap_size(m->jobs) > 0) {
2664
2665                 if (m->jobs_in_progress_event_source)
2666                         sd_event_source_set_time(m->jobs_in_progress_event_source, now(CLOCK_MONOTONIC) + JOBS_IN_PROGRESS_WAIT_USEC);
2667
2668                 return;
2669         }
2670
2671         manager_flip_auto_status(m, false);
2672
2673         /* Notify Type=idle units that we are done now */
2674         m->idle_pipe_event_source = sd_event_source_unref(m->idle_pipe_event_source);
2675         manager_close_idle_pipe(m);
2676
2677         /* Turn off confirm spawn now */
2678         m->confirm_spawn = false;
2679
2680         /* No need to update ask password status when we're going non-interactive */
2681         manager_close_ask_password(m);
2682
2683         /* This is no longer the first boot */
2684         manager_set_first_boot(m, false);
2685
2686         if (dual_timestamp_is_set(&m->finish_timestamp))
2687                 return;
2688
2689         dual_timestamp_get(&m->finish_timestamp);
2690
2691         manager_notify_finished(m);
2692
2693         SET_FOREACH(u, m->startup_units, i)
2694                 if (u->cgroup_path)
2695                         cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
2696 }
2697
2698 static int create_generator_dir(Manager *m, char **generator, const char *name) {
2699         char *p;
2700         int r;
2701
2702         assert(m);
2703         assert(generator);
2704         assert(name);
2705
2706         if (*generator)
2707                 return 0;
2708
2709         if (m->running_as == SYSTEMD_SYSTEM && getpid() == 1) {
2710                 /* systemd --system, not running --test */
2711
2712                 p = strappend("/run/systemd/", name);
2713                 if (!p)
2714                         return log_oom();
2715
2716                 r = mkdir_p_label(p, 0755);
2717                 if (r < 0) {
2718                         log_error("Failed to create generator directory %s: %s",
2719                                   p, strerror(-r));
2720                         free(p);
2721                         return r;
2722                 }
2723         } else if (m->running_as == SYSTEMD_USER) {
2724                 const char *s = NULL;
2725
2726                 s = getenv("XDG_RUNTIME_DIR");
2727                 if (!s)
2728                         return -EINVAL;
2729                 p = strjoin(s, "/systemd/", name, NULL);
2730                 if (!p)
2731                         return log_oom();
2732
2733                 r = mkdir_p_label(p, 0755);
2734                 if (r < 0) {
2735                         log_error("Failed to create generator directory %s: %s",
2736                                   p, strerror(-r));
2737                         free(p);
2738                         return r;
2739                 }
2740         } else {
2741                 /* systemd --system --test */
2742
2743                 p = strjoin("/tmp/systemd-", name, ".XXXXXX", NULL);
2744                 if (!p)
2745                         return log_oom();
2746
2747                 if (!mkdtemp(p)) {
2748                         log_error("Failed to create generator directory %s: %m",
2749                                   p);
2750                         free(p);
2751                         return -errno;
2752                 }
2753         }
2754
2755         *generator = p;
2756         return 0;
2757 }
2758
2759 static void trim_generator_dir(Manager *m, char **generator) {
2760         assert(m);
2761         assert(generator);
2762
2763         if (!*generator)
2764                 return;
2765
2766         if (rmdir(*generator) >= 0) {
2767                 free(*generator);
2768                 *generator = NULL;
2769         }
2770
2771         return;
2772 }
2773
2774 void manager_run_generators(Manager *m) {
2775         _cleanup_closedir_ DIR *d = NULL;
2776         const char *generator_path;
2777         const char *argv[5];
2778         int r;
2779
2780         assert(m);
2781
2782         if (m->test_run)
2783                 return;
2784
2785         generator_path = m->running_as == SYSTEMD_SYSTEM ? SYSTEM_GENERATOR_PATH : USER_GENERATOR_PATH;
2786         d = opendir(generator_path);
2787         if (!d) {
2788                 if (errno == ENOENT)
2789                         return;
2790
2791                 log_error("Failed to enumerate generator directory %s: %m",
2792                           generator_path);
2793                 return;
2794         }
2795
2796         r = create_generator_dir(m, &m->generator_unit_path, "generator");
2797         if (r < 0)
2798                 goto finish;
2799
2800         r = create_generator_dir(m, &m->generator_unit_path_early, "generator.early");
2801         if (r < 0)
2802                 goto finish;
2803
2804         r = create_generator_dir(m, &m->generator_unit_path_late, "generator.late");
2805         if (r < 0)
2806                 goto finish;
2807
2808         argv[0] = NULL; /* Leave this empty, execute_directory() will fill something in */
2809         argv[1] = m->generator_unit_path;
2810         argv[2] = m->generator_unit_path_early;
2811         argv[3] = m->generator_unit_path_late;
2812         argv[4] = NULL;
2813
2814         RUN_WITH_UMASK(0022)
2815                 execute_directory(generator_path, d, DEFAULT_TIMEOUT_USEC, (char**) argv);
2816
2817 finish:
2818         trim_generator_dir(m, &m->generator_unit_path);
2819         trim_generator_dir(m, &m->generator_unit_path_early);
2820         trim_generator_dir(m, &m->generator_unit_path_late);
2821 }
2822
2823 static void remove_generator_dir(Manager *m, char **generator) {
2824         assert(m);
2825         assert(generator);
2826
2827         if (!*generator)
2828                 return;
2829
2830         strv_remove(m->lookup_paths.unit_path, *generator);
2831         rm_rf(*generator, false, true, false);
2832
2833         free(*generator);
2834         *generator = NULL;
2835 }
2836
2837 void manager_undo_generators(Manager *m) {
2838         assert(m);
2839
2840         remove_generator_dir(m, &m->generator_unit_path);
2841         remove_generator_dir(m, &m->generator_unit_path_early);
2842         remove_generator_dir(m, &m->generator_unit_path_late);
2843 }
2844
2845 int manager_environment_add(Manager *m, char **minus, char **plus) {
2846         char **a = NULL, **b = NULL, **l;
2847         assert(m);
2848
2849         l = m->environment;
2850
2851         if (!strv_isempty(minus)) {
2852                 a = strv_env_delete(l, 1, minus);
2853                 if (!a)
2854                         return -ENOMEM;
2855
2856                 l = a;
2857         }
2858
2859         if (!strv_isempty(plus)) {
2860                 b = strv_env_merge(2, l, plus);
2861                 if (!b) {
2862                         strv_free(a);
2863                         return -ENOMEM;
2864                 }
2865
2866                 l = b;
2867         }
2868
2869         if (m->environment != l)
2870                 strv_free(m->environment);
2871         if (a != l)
2872                 strv_free(a);
2873         if (b != l)
2874                 strv_free(b);
2875
2876         m->environment = l;
2877         manager_clean_environment(m);
2878         strv_sort(m->environment);
2879
2880         return 0;
2881 }
2882
2883 int manager_set_default_rlimits(Manager *m, struct rlimit **default_rlimit) {
2884         int i;
2885
2886         assert(m);
2887
2888         for (i = 0; i < _RLIMIT_MAX; i++) {
2889                 if (!default_rlimit[i])
2890                         continue;
2891
2892                 m->rlimit[i] = newdup(struct rlimit, default_rlimit[i], 1);
2893                 if (!m->rlimit[i])
2894                         return -ENOMEM;
2895         }
2896
2897         return 0;
2898 }
2899
2900 void manager_recheck_journal(Manager *m) {
2901         Unit *u;
2902
2903         assert(m);
2904
2905         if (m->running_as != SYSTEMD_SYSTEM)
2906                 return;
2907
2908         u = manager_get_unit(m, SPECIAL_JOURNALD_SOCKET);
2909         if (u && SOCKET(u)->state != SOCKET_RUNNING) {
2910                 log_close_journal();
2911                 return;
2912         }
2913
2914         u = manager_get_unit(m, SPECIAL_JOURNALD_SERVICE);
2915         if (u && SERVICE(u)->state != SERVICE_RUNNING) {
2916                 log_close_journal();
2917                 return;
2918         }
2919
2920         /* Hmm, OK, so the socket is fully up and the service is up
2921          * too, then let's make use of the thing. */
2922         log_open();
2923 }
2924
2925 void manager_set_show_status(Manager *m, ShowStatus mode) {
2926         assert(m);
2927         assert(IN_SET(mode, SHOW_STATUS_AUTO, SHOW_STATUS_NO, SHOW_STATUS_YES, SHOW_STATUS_TEMPORARY));
2928
2929         if (m->running_as != SYSTEMD_SYSTEM)
2930                 return;
2931
2932         m->show_status = mode;
2933
2934         if (mode > 0)
2935                 touch("/run/systemd/show-status");
2936         else
2937                 unlink("/run/systemd/show-status");
2938 }
2939
2940 static bool manager_get_show_status(Manager *m, StatusType type) {
2941         assert(m);
2942
2943         if (m->running_as != SYSTEMD_SYSTEM)
2944                 return false;
2945
2946         if (m->no_console_output)
2947                 return false;
2948
2949         if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
2950                 return false;
2951
2952         /* If we cannot find out the status properly, just proceed. */
2953         if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
2954                 return false;
2955
2956         if (m->show_status > 0)
2957                 return true;
2958
2959         /* If Plymouth is running make sure we show the status, so
2960          * that there's something nice to see when people press Esc */
2961         return plymouth_running();
2962 }
2963
2964 void manager_set_first_boot(Manager *m, bool b) {
2965         assert(m);
2966
2967         if (m->running_as != SYSTEMD_SYSTEM)
2968                 return;
2969
2970         m->first_boot = b;
2971
2972         if (m->first_boot)
2973                 touch("/run/systemd/first-boot");
2974         else
2975                 unlink("/run/systemd/first-boot");
2976 }
2977
2978 void manager_status_printf(Manager *m, StatusType type, const char *status, const char *format, ...) {
2979         va_list ap;
2980
2981         if (!manager_get_show_status(m, type))
2982                 return;
2983
2984         /* XXX We should totally drop the check for ephemeral here
2985          * and thus effectively make 'Type=idle' pointless. */
2986         if (type == STATUS_TYPE_EPHEMERAL && m->n_on_console > 0)
2987                 return;
2988
2989         va_start(ap, format);
2990         status_vprintf(status, true, type == STATUS_TYPE_EPHEMERAL, format, ap);
2991         va_end(ap);
2992 }
2993
2994 int manager_get_unit_by_path(Manager *m, const char *path, const char *suffix, Unit **_found) {
2995         _cleanup_free_ char *p = NULL;
2996         Unit *found;
2997
2998         assert(m);
2999         assert(path);
3000         assert(suffix);
3001         assert(_found);
3002
3003         p = unit_name_from_path(path, suffix);
3004         if (!p)
3005                 return -ENOMEM;
3006
3007         found = manager_get_unit(m, p);
3008         if (!found) {
3009                 *_found = NULL;
3010                 return 0;
3011         }
3012
3013         *_found = found;
3014         return 1;
3015 }
3016
3017 Set *manager_get_units_requiring_mounts_for(Manager *m, const char *path) {
3018         char p[strlen(path)+1];
3019
3020         assert(m);
3021         assert(path);
3022
3023         strcpy(p, path);
3024         path_kill_slashes(p);
3025
3026         return hashmap_get(m->units_requiring_mounts_for, streq(p, "/") ? "" : p);
3027 }
3028
3029 const char *manager_get_runtime_prefix(Manager *m) {
3030         assert(m);
3031
3032         return m->running_as == SYSTEMD_SYSTEM ?
3033                "/run" :
3034                getenv("XDG_RUNTIME_DIR");
3035 }
3036
3037 ManagerState manager_state(Manager *m) {
3038         Unit *u;
3039
3040         assert(m);
3041
3042         /* Did we ever finish booting? If not then we are still starting up */
3043         if (!dual_timestamp_is_set(&m->finish_timestamp)) {
3044
3045                 u = manager_get_unit(m, SPECIAL_BASIC_TARGET);
3046                 if (!u || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
3047                         return MANAGER_INITIALIZING;
3048
3049                 return MANAGER_STARTING;
3050         }
3051
3052         /* Is the special shutdown target queued? If so, we are in shutdown state */
3053         u = manager_get_unit(m, SPECIAL_SHUTDOWN_TARGET);
3054         if (u && u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))
3055                 return MANAGER_STOPPING;
3056
3057         /* Are the rescue or emergency targets active or queued? If so we are in maintenance state */
3058         u = manager_get_unit(m, SPECIAL_RESCUE_TARGET);
3059         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3060                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3061                 return MANAGER_MAINTENANCE;
3062
3063         u = manager_get_unit(m, SPECIAL_EMERGENCY_TARGET);
3064         if (u && (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)) ||
3065                   (u->job && IN_SET(u->job->type, JOB_START, JOB_RESTART, JOB_TRY_RESTART, JOB_RELOAD_OR_START))))
3066                 return MANAGER_MAINTENANCE;
3067
3068         /* Are there any failed units? If so, we are in degraded mode */
3069         if (set_size(m->failed_units) > 0)
3070                 return MANAGER_DEGRADED;
3071
3072         return MANAGER_RUNNING;
3073 }
3074
3075 static const char *const manager_state_table[_MANAGER_STATE_MAX] = {
3076         [MANAGER_INITIALIZING] = "initializing",
3077         [MANAGER_STARTING] = "starting",
3078         [MANAGER_RUNNING] = "running",
3079         [MANAGER_DEGRADED] = "degraded",
3080         [MANAGER_MAINTENANCE] = "maintenance",
3081         [MANAGER_STOPPING] = "stopping",
3082 };
3083
3084 DEFINE_STRING_TABLE_LOOKUP(manager_state, ManagerState);