src/core/manager.c

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