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