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