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