src/core/manager.c

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