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